Update app.py

app.py

@@ -4,18 +4,18 @@ import plotly.graph_objects as go
 import gradio as gr
 import logging
 
-# -------------------- Setup Logging --------------------
+# Set up logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# -------------------- Load and Preprocess Data --------------------
-FILE_PATH = "cbinsights_data.csv"  # Replace with your actual file path
+# Load and preprocess the dataset
+file_path = "cbinsights_data.csv"  # Replace with your actual file path
 
 try:
-    data = pd.read_csv(FILE_PATH, skiprows=1)
+    data = pd.read_csv(file_path, skiprows=1)
     logger.info("CSV file loaded successfully.")
 except FileNotFoundError:
-    logger.error(f"File not found: {FILE_PATH}")
+    logger.error(f"File not found: {file_path}")
     raise
 except Exception as e:
     logger.error(f"Error loading CSV file: {e}")
@@ -35,8 +35,8 @@ 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["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",
@@ -49,11 +49,8 @@ data.rename(columns={
 
 logger.info("Data cleaned and columns renamed.")
 
-# -------------------- Build Investor-Company Mapping --------------------
+# Build investor-company mapping
 def build_investor_company_mapping(df):
-    """
-    Builds a mapping from investors to the companies they've invested in.
-    """
     mapping = {}
     for _, row in df.iterrows():
         company = row["Company"]
@@ -68,48 +65,30 @@ def build_investor_company_mapping(df):
 investor_company_mapping = build_investor_company_mapping(data)
 logger.info("Investor to company mapping created.")
 
-# -------------------- Filter Investors --------------------
+# Filter investors by country, industry, and investor selection
 def filter_investors(selected_country, selected_industry, selected_investors):
-    """
-    Filters the dataset based on selected country, industry, and 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_investors:
-        pattern = '|'.join(selected_investors)
+        pattern = '|'.join([re.escape(inv) for inv in 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
 
-# -------------------- Generate Network Graph --------------------
+# Generate Plotly graph
 def generate_graph(investors, filtered_data):
-    """
-    Generates an interactive network graph using Plotly.
-    """
     if not investors:
         logger.warning("No investors selected.")
-        # Create an empty figure with a message
-        fig = go.Figure()
-        fig.update_layout(
-            title="No data available for the selected filters.",
-            xaxis=dict(visible=False),
-            yaxis=dict(visible=False),
-            annotations=[dict(
-                text="Please adjust your filters to display the network graph.",
-                showarrow=False,
-                xref="paper", yref="paper",
-                x=0.5, y=0.5,
-                font=dict(size=20)
-            )]
-        )
-        return fig
+        return go.Figure()
 
-    # Define a color-blind friendly palette
+    # Create a color map for investors
+    unique_investors = investors
+    num_colors = len(unique_investors)
     color_palette = [
         "#377eb8",  # Blue
         "#e41a1c",  # Red
@@ -119,216 +98,200 @@ def generate_graph(investors, filtered_data):
         "#ffff33",  # Yellow
         "#a65628",  # Brown
         "#f781bf",  # Pink
+        "#999999",  # Grey
     ]
-
-    # Assign colors to investors
-    unique_investors = investors
-    num_colors = len(unique_investors)
-    color_palette_extended = color_palette * (num_colors // len(color_palette) + 1)
-    investor_color_map = {investor: color_palette_extended[i] for i, investor in enumerate(unique_investors)}
-
-    # Create the graph
+    # Extend color_palette if necessary
+    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)}
+    
     G = nx.Graph()
     for investor in investors:
-        companies = filtered_data[filtered_data["Select_Investors"].str.contains(investor, na=False)]["Company"].tolist()
+        companies = filtered_data[filtered_data["Select_Investors"].str.contains(re.escape(investor), na=False)]["Company"].tolist()
         for company in companies:
-            G.add_node(company, type='company', valuation=filtered_data.loc[filtered_data["Company"] == company, "Valuation_Billions"].values[0])
-            G.add_node(investor, type='investor')
+            G.add_node(company)
+            G.add_node(investor)
             G.add_edge(investor, company)
-
-    # Position nodes using spring layout
-    pos = nx.spring_layout(G, seed=42, k=0.5)
-
-    # Prepare edge traces
+    
+    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 += [x0, x1, None]
-        edge_y += [y0, y1, None]
-
+        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='#888'),
+        line=dict(width=0.5, color='#aaaaaa'),
         hoverinfo='none',
         mode='lines'
     )
-
-    # Prepare node traces
+    
     node_x = []
     node_y = []
     node_text = []
     node_color = []
     node_size = []
-    node_type = []
-
-    for node in G.nodes(data=True):
-        x, y = pos[node[0]]
+    node_hovertext = []
+    
+    for node in G.nodes():
+        x, y = pos[node]
         node_x.append(x)
         node_y.append(y)
-        node_type.append(node[1]['type'])
-        if node[1]['type'] == 'investor':
-            node_text.append(node[0])  # Investor labels
-            node_color.append(investor_color_map[node[0]])
-            node_size.append(20)  # Fixed size for investors
+        if node in investors:
+            # Investor node
+            node_text.append(node)  # Label investors
+            node_color.append(investor_color_map[node])  # Color assigned to investor
+            node_size.append(30)  # Fixed size for investors
+            node_hovertext.append(f"Investor: {node}")
         else:
-            valuation = node[1]['valuation']
-            size = (valuation * 5) if pd.notnull(valuation) else 10  # Scale size
-            size = max(size, 5)  # Minimum size
+            # Company node
+            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  # Scale size as needed
+                if size < 10:
+                    size = 10  # Minimum size
+            else:
+                size = 15  # Default size
             node_size.append(size)
-            node_text.append(f"{node[0]}<br>Valuation: ${valuation}B" if pd.notnull(valuation) else f"{node[0]}<br>Valuation: N/A")
-            node_color.append("#b2df8a")  # Light green for companies
-
+            node_text.append("")  # Hide company labels by default
+            node_color.append("#a6d854")  # Light green color for companies
+            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,
-        mode='markers+text',
         text=node_text,
-        textposition="top center",
+        mode='markers+text',
         hoverinfo='text',
+        hovertext=node_hovertext,
         marker=dict(
             showscale=False,
-            color=node_color,
             size=node_size,
-            line=dict(width=1, color='white')
-        )
+            color=node_color,
+            line=dict(width=0.5, color='#333333')
+        ),
+        textposition="middle center",
+        textfont=dict(size=12, color="#000000")
     )
-
-    # Create the figure
-    fig = go.Figure(data=[edge_trace, node_trace])
-
+    
     # Add legend manually
-    investor_colors = list(investor_color_map.values())[:8]  # Limit to first 8 for legend
-    investor_names = list(investor_color_map.keys())[:8]
-
-    for i, investor in enumerate(investor_names):
-        fig.add_trace(go.Scatter(
-            x=[None],
-            y=[None],
-            mode='markers',
-            marker=dict(
-                size=10,
-                color=investor_color_map[investor]
-            ),
-            legendgroup='Investors',
-            showlegend=True,
-            name=investor
-        ))
-
-    # Update layout for better aesthetics
+    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
+            )
+        )
+    
+    fig = go.Figure(data=legend_items + [edge_trace, node_trace])
     fig.update_layout(
-        title={
-            'text': "Venture Networks",
-            'y':0.95,
-            'x':0.5,
-            'xanchor': 'center',
-            'yanchor': 'top'
-        },
+        title="Venture Networks",
         titlefont_size=24,
-        showlegend=True,
-        legend=dict(
-            title="Top Investors",
-            itemsizing='constant',
-            itemclick='toggleothers',
-            itemdoubleclick='toggle',
-            font=dict(size=10)
-        ),
-        margin=dict(l=40, r=40, t=80, b=40),
+        margin=dict(l=20, r=20, t=60, b=20),
         hovermode='closest',
-        width=1200,
+        width=1000,
         height=800,
-        xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
-        yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+        legend=dict(
+            title="Investors",
+            font=dict(size=12),
+            itemsizing='constant'
+        )
     )
-
+    
+    # Improve layout responsiveness
+    fig.update_layout(
+        autosize=True,
+        xaxis={'showgrid': False, 'zeroline': False, 'visible': False},
+        yaxis={'showgrid': False, 'zeroline': False, 'visible': False}
+    )
+    
     return fig
 
-# -------------------- Gradio Application --------------------
+# Gradio app
 def app(selected_country, selected_industry, selected_investors):
-    """
-    Main application function that filters data and generates the network graph.
-    """
     investors, filtered_data = filter_investors(selected_country, selected_industry, selected_investors)
+    if not investors:
+        return "No investors found with the selected filters.", go.Figure()
     graph = generate_graph(investors, filtered_data)
-    return ', '.join(investors) if investors else "No investors found.", graph
+    return ', '.join(investors), graph
 
+# Main function
 def main():
-    """
-    Initializes and launches the Gradio interface.
-    """
-    # Prepare dropdown options
+    import re  # Added import for regex
     country_list = ["All"] + sorted(data["Country"].dropna().unique())
     industry_list = ["All"] + sorted(data["Industry"].dropna().unique())
     investor_list = sorted(investor_company_mapping.keys())
-
-    # Define Gradio Blocks
-    with gr.Blocks(css="""
-        .gradio-container { 
-            background-color: #f9f9f9; 
-            padding: 20px; 
-        }
-        .gradio-row {
-            justify-content: center;
-        }
-    """) as demo:
+    
+    with gr.Blocks(title="Venture Networks Visualization") as demo:
         gr.Markdown("""
         # Venture Networks Visualization
-
-        Explore the relationships between investors and companies across different countries and industries. Use the filters below to customize the network graph.
-
-        **Instructions:**
-        - Select a country and/or industry to filter the data.
-        - Choose one or more investors to focus on specific investment activities.
-        - Hover over company nodes to view their valuations.
+        Explore the connections between investors and companies in the venture capital ecosystem. Use the filters below to customize the network graph.
         """)
-
         with gr.Row():
-            with gr.Column(scale=1):
-                country_filter = gr.Dropdown(
-                    choices=country_list, 
-                    label="Country", 
-                    value="All",
-                    info="Select a country to filter the data."
-                )
-                industry_filter = gr.Dropdown(
-                    choices=industry_list, 
-                    label="Industry", 
-                    value="All",
-                    info="Select an industry to filter the data."
-                )
-                investor_filter = gr.Dropdown(
-                    choices=investor_list, 
-                    label="Investor", 
-                    value=[], 
-                    multiselect=True,
-                    info="Select one or more investors to focus on their investments."
-                )
-                reset_button = gr.Button("Reset Filters", variant="secondary")
-            with gr.Column(scale=3):
-                graph_output = gr.Plot(label="Network Graph")
-        
+            country_filter = gr.Dropdown(
+                choices=country_list,
+                label="Country",
+                value="All",
+                info="Filter companies by country."
+            )
+            industry_filter = gr.Dropdown(
+                choices=industry_list,
+                label="Industry",
+                value="All",
+                info="Filter companies by industry."
+            )
+            investor_filter = gr.Dropdown(
+                choices=investor_list,
+                label="Select Investors",
+                value=[],
+                multiselect=True,
+                info="Select one or more investors to visualize."
+            )
         with gr.Row():
             investor_output = gr.Textbox(label="Filtered Investors", interactive=False)
-
-        # Define Inputs and Outputs
+        graph_output = gr.Plot(label="Network Graph")
+        
         inputs = [country_filter, industry_filter, investor_filter]
         outputs = [investor_output, graph_output]
-
-        # Define Event Handlers
-        country_filter.change(fn=app, inputs=inputs, outputs=outputs)
-        industry_filter.change(fn=app, inputs=inputs, outputs=outputs)
-        investor_filter.change(fn=app, inputs=inputs, outputs=outputs)
-        reset_button.click(fn=lambda: ["", go.Figure()], inputs=None, outputs=outputs)
-
-        # Add Footer
+        
+        # Update the graph when any filter changes
+        country_filter.change(app, inputs, outputs)
+        industry_filter.change(app, inputs, outputs)
+        investor_filter.change(app, inputs, outputs)
+        
         gr.Markdown("""
-        ---
-        © 2024 Venture Networks Visualization Tool
+        **Instructions:**
+        - **Country**: Select a country to filter companies based on their location.
+        - **Industry**: Choose an industry to focus on companies within that sector.
+        - **Select Investors**: Pick one or more investors to visualize their network.
+        
+        **Graph Interaction:**
+        - **Zoom**: Use your mouse wheel or trackpad to zoom in and out.
+        - **Pan**: Click and drag to move around the graph.
+        - **Hover**: Hover over nodes to see more information.
         """)
-
-    # Launch the Gradio app
+    
     demo.launch()
 
 if __name__ == "__main__":