Update app.py

app.py

@@ -25,11 +25,21 @@ except Exception as e:
 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",
-    "valuation": "Valuation",
     "date_joined": "Date_Joined",
     "country": "Country",
     "city": "City",
@@ -37,10 +47,6 @@ data.rename(columns={
     "select_investors": "Select_Investors"
 }, inplace=True)
 
-# Convert valuation to numeric for proportional node sizing
-data["Valuation"] = pd.to_numeric(
-    data["Valuation"].replace({"\$": "", ",": ""}, regex=True), errors="coerce"
-)
 logger.info("Data cleaned and columns renamed.")
 
 # Build investor-company mapping
@@ -66,13 +72,10 @@ def filter_investors(selected_country, selected_industry, selected_investors):
         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 != ["All"]:
-        filtered_data = filtered_data[
-            filtered_data["Select_Investors"].apply(
-                lambda x: any(inv in x for inv in selected_investors) if pd.notnull(x) else False
-            )
-        ]
-
+    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
@@ -83,78 +86,99 @@ def generate_graph(investors, filtered_data):
         logger.warning("No investors selected.")
         return go.Figure()
 
+    # Create a color map for investors
+    unique_investors = investors
+    num_colors = len(unique_investors)
+    color_palette = [
+        "#000000",  # black
+        "#E69F00",  # orange
+        "#56B4E9",  # sky blue
+        "#009E73",  # bluish green
+        "#F0E442",  # yellow
+        "#0072B2",  # blue
+        "#D55E00",  # vermillion
+        "#CC79A7",  # reddish purple
+    ]
+    # 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()
         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=1, color="#888"),
-        hoverinfo="none",
-        mode="lines"
+        line=dict(width=1, color='#888'),
+        hoverinfo='none',
+        mode='lines'
     )
-
+    
     node_x = []
     node_y = []
     node_text = []
     node_color = []
     node_size = []
-
-    # Color palette for investors (color blind friendly)
-    investor_colors = [
-        "#E69F00", "#56B4E9", "#009E73", "#F0E442", "#0072B2", "#D55E00", "#CC79A7"
-    ]
-
-    investor_color_map = {investor: investor_colors[i % len(investor_colors)] for i, investor in enumerate(investors)}
-
+    
     for node in G.nodes():
         x, y = pos[node]
         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])  # Assign distinct colors to investors
-            node_size.append(20)  # Fixed size for investor nodes
+            node_color.append(investor_color_map[node])  # Color assigned to investor
+            node_size.append(20)  # Fixed size for investors
         else:
-            valuation = filtered_data.loc[filtered_data["Company"] == node, "Valuation"].sum()
+            # 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
+            node_size.append(size)
             node_text.append("")  # Hide company labels by default
-            node_color.append("lightgreen")  # Light green for companies
-            node_size.append(max(10, valuation / 100))  # Size proportional to valuation
-
+            node_color.append("#b2df8a")  # Light green color for companies
+    
     node_trace = go.Scatter(
         x=node_x,
         y=node_y,
         text=node_text,
-        mode="markers",
-        hoverinfo="text",
+        mode='markers',
+        hoverinfo='text',
         marker=dict(
             showscale=False,
             size=node_size,
             color=node_color,
         )
     )
-
+    
     fig = go.Figure(data=[edge_trace, node_trace])
     fig.update_layout(
         showlegend=False,
         title="Venture Networks",
         titlefont_size=20,
         margin=dict(l=20, r=20, t=50, b=20),
-        hovermode="closest",
+        hovermode='closest',
         width=1200,
         height=800
     )
@@ -164,34 +188,31 @@ def generate_graph(investors, filtered_data):
 def app(selected_country, selected_industry, selected_investors):
     investors, filtered_data = filter_investors(selected_country, selected_industry, selected_investors)
     graph = generate_graph(investors, filtered_data)
-    return investors, graph
+    return ', '.join(investors), graph
 
 # Main function
 def main():
     country_list = ["All"] + sorted(data["Country"].dropna().unique())
     industry_list = ["All"] + sorted(data["Industry"].dropna().unique())
-    investor_list = ["All"] + sorted(investor_company_mapping.keys())
+    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.CheckboxGroup(choices=investor_list, label="Investors", value=["All"])
+            investor_filter = gr.Dropdown(choices=investor_list, label="Investor", value=[], multiselect=True)
 
         investor_output = gr.Textbox(label="Filtered Investors")
         graph_output = gr.Plot(label="Network Graph")
 
-        country_filter.change(
-            app, [country_filter, industry_filter, investor_filter], [investor_output, graph_output]
-        )
-        industry_filter.change(
-            app, [country_filter, industry_filter, investor_filter], [investor_output, graph_output]
-        )
-        investor_filter.change(
-            app, [country_filter, industry_filter, investor_filter], [investor_output, graph_output]
-        )
+        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)
 
-    demo.launch()
+        demo.launch()
 
 if __name__ == "__main__":
     main()