Update app.py

app.py

@@ -2,9 +2,7 @@ import pandas as pd
 import networkx as nx
 import plotly.graph_objects as go
 import gradio as gr
-import re
 import logging
-import os
 
 # Set up logging
 logging.basicConfig(level=logging.INFO)
@@ -13,48 +11,32 @@ logger = logging.getLogger(__name__)
 # Load and preprocess the dataset
 file_path = "cbinsights_data.csv"  # Replace with your actual file path
 
-def load_data():
-    if not os.path.exists(file_path):
-        logger.error(f"File not found: {file_path}")
-        raise FileNotFoundError(f"File not found: {file_path}")
-
-    try:
-        data = pd.read_csv(file_path, skiprows=1)
-        logger.info("CSV file loaded successfully.")
-    except Exception as e:
-        logger.error(f"Error loading CSV file: {e}")
-        raise
-
-    # Standardize column names
-    data.columns = data.columns.str.strip().str.lower()
-    logger.info(f"Standardized Column Names: {data.columns.tolist()}")
-
-    # Identify the valuation column
-    valuation_columns = [col for col in data.columns if 'valuation' in col.lower()]
-    if len(valuation_columns) != 1:
-        logger.error("Unable to identify a single valuation column.")
-        raise ValueError("Dataset should contain exactly one column with 'valuation' in its name.")
-
-    valuation_column = valuation_columns[0]
-    logger.info(f"Using valuation column: {valuation_column}")
-
-    # Clean and prepare data
-    data["Valuation_Billions"] = data[valuation_column].replace({'\$': '', ',': ''}, regex=True)
-    data["Valuation_Billions"] = pd.to_numeric(data["Valuation_Billions"], errors='coerce')
-    data = data.apply(lambda col: col.str.strip() if col.dtype == "object" else col)
-    data.rename(columns={
-        "company": "Company",
-        "date_joined": "Date_Joined",
-        "country": "Country",
-        "city": "City",
-        "industry": "Industry",
-        "select_investors": "Select_Investors"
-    }, inplace=True)
-
-    logger.info("Data cleaned and columns renamed.")
-    return data
-
-data = load_data()
+try:
+    data = pd.read_csv(file_path, skiprows=1)
+    logger.info("CSV file loaded successfully.")
+except FileNotFoundError:
+    logger.error(f"File not found: {file_path}")
+    raise
+except Exception as e:
+    logger.error(f"Error loading CSV file: {e}")
+    raise
+
+# Standardize column names
+data.columns = data.columns.str.strip().str.lower()
+logger.info(f"Standardized Column Names: {data.columns.tolist()}")
+
+# Clean and prepare data
+data["valuation_billions"] = data["valuation (usd billions)"].replace({'\$': '', ',': ''}, regex=True)
+data["valuation_billions"] = pd.to_numeric(data["valuation_billions"], errors='coerce')
+data = data.apply(lambda col: col.str.strip() if col.dtype == "object" else col)
+data.rename(columns={
+    "company": "Company",
+    "country": "Country",
+    "industry": "Industry",
+    "select_investors": "Select_Investors"
+}, inplace=True)
+
+logger.info("Data cleaned and columns renamed.")
 
 # Build investor-company mapping
 def build_investor_company_mapping(df):
@@ -72,19 +54,17 @@ def build_investor_company_mapping(df):
 investor_company_mapping = build_investor_company_mapping(data)
 logger.info("Investor to company mapping created.")
 
-# Filter investors by country, industry, investor selection, and company selection
-def filter_investors(selected_country, selected_industry, selected_investors, selected_company):
+# Filter investors by country, industry, and investor selection
+def filter_investors(selected_country, selected_industry, selected_investors):
     filtered_data = data.copy()
     if selected_country != "All":
         filtered_data = filtered_data[filtered_data["Country"] == selected_country]
     if selected_industry != "All":
         filtered_data = filtered_data[filtered_data["Industry"] == selected_industry]
-    if selected_company != "All":
-        filtered_data = filtered_data[filtered_data["Company"] == selected_company]
     if selected_investors:
-        pattern = '|'.join([re.escape(inv) for inv in selected_investors])
+        pattern = '|'.join(selected_investors)
         filtered_data = filtered_data[filtered_data["Select_Investors"].str.contains(pattern, na=False)]
-
+    
     investor_company_mapping_filtered = build_investor_company_mapping(filtered_data)
     filtered_investors = list(investor_company_mapping_filtered.keys())
     return filtered_investors, filtered_data
@@ -93,190 +73,77 @@ def filter_investors(selected_country, selected_industry, selected_investors, se
 def generate_graph(investors, filtered_data):
     if not investors:
         logger.warning("No investors selected.")
-        return go.Figure()
-
-    # Create a color map for investors
-    unique_investors = investors
-    num_colors = len(unique_investors)
-    color_palette = [
-        "#377eb8",  # Blue
-        "#e41a1c",  # Red
-        "#4daf4a",  # Green
-        "#984ea3",  # Purple
-        "#ff7f00",  # Orange
-        "#ffff33",  # Yellow
-        "#a65628",  # Brown
-        "#f781bf",  # Pink
-        "#999999",  # Grey
-    ]
-    while num_colors > len(color_palette):
-        color_palette.extend(color_palette)
-
-    investor_color_map = {investor: color_palette[i] for i, investor in enumerate(unique_investors)}
+        return go.Figure(), "No data available for the selected filters."
 
     G = nx.Graph()
     for investor in investors:
-        companies = filtered_data[filtered_data["Select_Investors"].str.contains(re.escape(investor), na=False)]["Company"].tolist()
+        companies = filtered_data[filtered_data["Select_Investors"].str.contains(investor, na=False)]["Company"].tolist()
         for company in companies:
-            G.add_node(company)
-            G.add_node(investor)
             G.add_edge(investor, company)
 
     pos = nx.spring_layout(G, seed=42)
-    edge_x = []
-    edge_y = []
-
-    for edge in G.edges():
-        x0, y0 = pos[edge[0]]
-        x1, y1 = pos[edge[1]]
-        edge_x.extend([x0, x1, None])
-        edge_y.extend([y0, y1, None])
-
     edge_trace = go.Scatter(
-        x=edge_x,
-        y=edge_y,
-        line=dict(width=0.5, color='#aaaaaa'),
+        x=[pos[node][0] for edge in G.edges() for node in edge] + [None],
+        y=[pos[node][1] for edge in G.edges() for node in edge] + [None],
+        line=dict(width=0.5, color='#888'),
         hoverinfo='none',
         mode='lines'
     )
 
-    node_x = []
-    node_y = []
-    node_text = []
-    node_color = []
-    node_size = []
-    node_hovertext = []
-
-    for node in G.nodes():
-        x, y = pos[node]
-        node_x.append(x)
-        node_y.append(y)
-        if node in investors:
-            node_text.append(node)
-            node_color.append(investor_color_map[node])
-            node_size.append(30)
-            node_hovertext.append(f"Investor: {node}")
-        else:
-            valuation = filtered_data.loc[filtered_data["Company"] == node, "Valuation_Billions"].values
-            industry = filtered_data.loc[filtered_data["Company"] == node, "Industry"].values
-            if len(valuation) > 0 and not pd.isnull(valuation[0]):
-                size = valuation[0] * 5
-                if size < 10:
-                    size = 10
-            else:
-                size = 15
-            node_size.append(size)
-            node_text.append("")
-            node_color.append("#a6d854")
-            hovertext = f"Company: {node}"
-            if len(industry) > 0 and not pd.isnull(industry[0]):
-                hovertext += f"<br>Industry: {industry[0]}"
-            if len(valuation) > 0 and not pd.isnull(valuation[0]):
-                hovertext += f"<br>Valuation: ${valuation[0]}B"
-            node_hovertext.append(hovertext)
-
     node_trace = go.Scatter(
-        x=node_x,
-        y=node_y,
-        text=node_text,
+        x=[pos[node][0] for node in G.nodes()],
+        y=[pos[node][1] for node in G.nodes()],
+        text=[node for node in G.nodes()],
         mode='markers+text',
         hoverinfo='text',
-        hovertext=node_hovertext,
         marker=dict(
             showscale=False,
-            size=node_size,
-            color=node_color,
-            line=dict(width=0.5, color='#333333')
-        ),
-        textposition="middle center",
-        textfont=dict(size=12, color="#000000")
-    )
-
-    legend_items = []
-    for investor in unique_investors:
-        legend_items.append(
-            go.Scatter(
-                x=[None],
-                y=[None],
-                mode='markers',
-                marker=dict(
-                    size=10,
-                    color=investor_color_map[investor]
-                ),
-                legendgroup=investor,
-                showlegend=True,
-                name=investor
-            )
+            size=[20 if node in investors else 10 for node in G.nodes()],
+            color=[('blue' if node in investors else 'lightgreen') for node in G.nodes()]
         )
+    )
 
-    fig = go.Figure(data=legend_items + [edge_trace, node_trace])
+    fig = go.Figure(data=[edge_trace, node_trace])
     fig.update_layout(
         title="Venture Networks",
-        titlefont_size=24,
-        margin=dict(l=20, r=20, t=60, b=20),
+        titlefont_size=16,
+        showlegend=False,
+        margin=dict(b=0,l=0,r=0,t=40),
         hovermode='closest',
-        width=1200,
-        height=800
-    )
-
-    fig.update_layout(
-        autosize=True,
-        xaxis={'showgrid': False, 'zeroline': False, 'visible': False},
-        yaxis={'showgrid': False, 'zeroline': False, 'visible': False}
+        xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+        yaxis=dict(showgrid=False, zeroline=False, showticklabels=False)
     )
+    return fig, ""
 
-    return fig
-
-# Gradio app
-def app(selected_country, selected_industry, selected_company, selected_investors):
-    investors, filtered_data = filter_investors(selected_country, selected_industry, selected_investors, selected_company)
-    if not investors:
-        return "No investors found with the selected filters.", go.Figure()
-    graph = generate_graph(investors, filtered_data)
-    return ', '.join(investors), graph
+# Gradio interface
+def app(selected_country, selected_industry, selected_investors):
+    investors, filtered_data = filter_investors(selected_country, selected_industry, selected_investors)
+    graph, message = generate_graph(investors, filtered_data)
+    return message, graph
 
 # Main function
 def main():
     country_list = ["All"] + sorted(data["Country"].dropna().unique())
     industry_list = ["All"] + sorted(data["Industry"].dropna().unique())
-    company_list = ["All"] + sorted(data["Company"].dropna().unique())
     investor_list = sorted(investor_company_mapping.keys())
 
-    with gr.Blocks(title="Venture Networks Visualization") as demo:
-        gr.Markdown("""
-        # Venture Networks Visualization
-        Explore the connections between investors and companies in the venture capital ecosystem. Use the filters below to customize the network graph.
-        """)
-        with gr.Row():
-            country_filter = gr.Dropdown(choices=country_list, label="Country", value="All")
-            industry_filter = gr.Dropdown(choices=industry_list, label="Industry", value="All")
-            company_filter = gr.Dropdown(choices=company_list, label="Company", value="All")
-            investor_filter = gr.Dropdown(choices=investor_list, label="Select Investors", value=[], multiselect=True)
-        with gr.Row():
-            investor_output = gr.Textbox(label="Filtered Investors", interactive=False)
-        graph_output = gr.Plot(label="Network Graph")
+    demo = gr.Blocks()
 
-        inputs = [country_filter, industry_filter, company_filter, investor_filter]
-        outputs = [investor_output, graph_output]
+    with demo:
+        gr.Markdown("## Venture Network Visualization Tool")
+        with gr.Row():
+            country_filter = gr.Dropdown(label="Select Country", choices=country_list, value="All")
+            industry_filter = gr.Dropdown(label="Select Industry", choices=industry_list, value="All")
+            investor_filter = gr.Dropdown(label="Select Investors", choices=investor_list, multiselect=True, value=[])
 
-        # Update the graph when any filter changes
-        country_filter.change(app, inputs, outputs)
-        industry_filter.change(app, inputs, outputs)
-        company_filter.change(app, inputs, outputs)
-        investor_filter.change(app, inputs, outputs)
+        message = gr.Textbox(label="Status Message", visible=False)
+        graph_output = gr.Plot()
 
-        gr.Markdown("""
-        **Instructions:**
-        - **Country**: Filter companies by country.
-        - **Industry**: Filter companies by industry.
-        - **Company**: Select a specific company to focus on.
-        - **Select Investors**: Choose investors to visualize their network connections.
+        inputs = [country_filter, industry_filter, investor_filter]
+        outputs = [message, graph_output]
 
-        **Tips:**
-        - Hover over nodes to see more information.
-        - Use the legend to identify investor nodes.
-        - Adjust filters to refine your network view.
-        """)
+        for input_widget in inputs:
+            input_widget.change(fn=app, inputs=inputs, outputs=outputs)
 
     demo.launch()