Update app.py

app.py

@@ -4,18 +4,18 @@ import plotly.graph_objects as go
 import gradio as gr
 import logging
 
-# Set up logging
+# -------------------- Setup Logging --------------------
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Load and preprocess the dataset
-file_path = "cbinsights_data.csv"  # Replace with your actual file path
+# -------------------- Load and Preprocess Data --------------------
+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,8 +49,11 @@ 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"]
@@ -65,8 +68,11 @@ 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, and investor selection
+# -------------------- Filter Investors --------------------
 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]
@@ -75,144 +81,255 @@ def filter_investors(selected_country, selected_industry, selected_investors):
     if 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
 
-# Generate Plotly graph
+# -------------------- Generate Network Graph --------------------
 def generate_graph(investors, filtered_data):
+    """
+    Generates an interactive network graph using Plotly.
+    """
     if not investors:
         logger.warning("No investors selected.")
-        return go.Figure()
+        # 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
 
-    # Create a color map for investors
-    unique_investors = investors
-    num_colors = len(unique_investors)
+    # Define a color-blind friendly palette
     color_palette = [
-        "#000000",  # black
-        "#E69F00",  # orange
-        "#56B4E9",  # sky blue
-        "#009E73",  # bluish green
-        "#F0E442",  # yellow
-        "#0072B2",  # blue
-        "#D55E00",  # vermillion
-        "#CC79A7",  # reddish purple
+        "#377eb8",  # Blue
+        "#e41a1c",  # Red
+        "#4daf4a",  # Green
+        "#984ea3",  # Purple
+        "#ff7f00",  # Orange
+        "#ffff33",  # Yellow
+        "#a65628",  # Brown
+        "#f781bf",  # Pink
     ]
-    # 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)}
-    
+
+    # 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
     G = nx.Graph()
     for investor in investors:
         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_node(company, type='company', valuation=filtered_data.loc[filtered_data["Company"] == company, "Valuation_Billions"].values[0])
+            G.add_node(investor, type='investor')
             G.add_edge(investor, company)
-    
-    pos = nx.spring_layout(G, seed=42)
+
+    # Position nodes using spring layout
+    pos = nx.spring_layout(G, seed=42, k=0.5)
+
+    # Prepare edge traces
     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_x += [x0, x1, None]
+        edge_y += [y0, y1, None]
+
     edge_trace = go.Scatter(
         x=edge_x,
         y=edge_y,
-        line=dict(width=1, color='#888'),
+        line=dict(width=0.5, color='#888'),
         hoverinfo='none',
         mode='lines'
     )
-    
+
+    # Prepare node traces
     node_x = []
     node_y = []
     node_text = []
     node_color = []
     node_size = []
-    
-    for node in G.nodes():
-        x, y = pos[node]
+    node_type = []
+
+    for node in G.nodes(data=True):
+        x, y = pos[node[0]]
         node_x.append(x)
         node_y.append(y)
-        if node in investors:
-            # Investor node
-            node_text.append(node)  # Label investors
-            node_color.append(investor_color_map[node])  # Color assigned to investor
+        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
         else:
-            # Company node
-            valuation = filtered_data.loc[filtered_data["Company"] == node, "Valuation_Billions"].values
-            if len(valuation) > 0 and not pd.isnull(valuation[0]):
-                size = valuation[0] * 5  # Scale size as needed
-                if size < 5:
-                    size = 5  # Minimum size
-            else:
-                size = 10  # Default size
+            valuation = node[1]['valuation']
+            size = (valuation * 5) if pd.notnull(valuation) else 10  # Scale size
+            size = max(size, 5)  # Minimum size
             node_size.append(size)
-            node_text.append("")  # Hide company labels by default
-            node_color.append("#b2df8a")  # Light green color for companies
-    
+            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_trace = go.Scatter(
         x=node_x,
         y=node_y,
+        mode='markers+text',
         text=node_text,
-        mode='markers',
+        textposition="top center",
         hoverinfo='text',
         marker=dict(
             showscale=False,
-            size=node_size,
             color=node_color,
+            size=node_size,
+            line=dict(width=1, color='white')
         )
     )
-    
+
+    # 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
     fig.update_layout(
-        showlegend=False,
-        title="Venture Networks",
-        titlefont_size=20,
-        margin=dict(l=20, r=20, t=50, b=20),
+        title={
+            'text': "Venture Networks",
+            'y':0.95,
+            'x':0.5,
+            'xanchor': 'center',
+            'yanchor': 'top'
+        },
+        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),
         hovermode='closest',
         width=1200,
-        height=800
+        height=800,
+        xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+        yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
     )
+
     return fig
 
-# Gradio app
+# -------------------- Gradio Application --------------------
 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)
     graph = generate_graph(investors, filtered_data)
-    return ', '.join(investors), graph
+    return ', '.join(investors) if investors else "No investors found.", graph
 
-# Main function
 def main():
+    """
+    Initializes and launches the Gradio interface.
+    """
+    # Prepare dropdown options
     country_list = ["All"] + sorted(data["Country"].dropna().unique())
     industry_list = ["All"] + sorted(data["Industry"].dropna().unique())
     investor_list = sorted(investor_company_mapping.keys())
 
-    with gr.Blocks() as demo:
-        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")
-            investor_filter = gr.Dropdown(choices=investor_list, label="Investor", value=[], multiselect=True)
+    # Define Gradio Blocks
+    with gr.Blocks(css="""
+        .gradio-container { 
+            background-color: #f9f9f9; 
+            padding: 20px; 
+        }
+        .gradio-row {
+            justify-content: center;
+        }
+    """) 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.
+        """)
 
-        investor_output = gr.Textbox(label="Filtered Investors")
-        graph_output = gr.Plot(label="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")
+        
+        with gr.Row():
+            investor_output = gr.Textbox(label="Filtered Investors", interactive=False)
 
+        # Define Inputs and Outputs
         inputs = [country_filter, industry_filter, investor_filter]
         outputs = [investor_output, graph_output]
 
-        country_filter.change(app, inputs, outputs)
-        industry_filter.change(app, inputs, outputs)
-        investor_filter.change(app, inputs, outputs)
+        # 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
+        gr.Markdown("""
+        ---
+        © 2024 Venture Networks Visualization Tool
+        """)
 
-        demo.launch()
+    # Launch the Gradio app
+    demo.launch()
 
 if __name__ == "__main__":
     main()