Update app.py

app.py

@@ -82,7 +82,7 @@ investor_company_mapping = build_investor_company_mapping(data)
 logger.info("Investor to company mapping created.")
 
 # Function to filter investors based on selected country and industry
-def filter_investors_by_country_and_industry(selected_country, selected_industry):
+def filter_investors_by_country_and_industry(selected_country, selected_industry, valuation_threshold):
     filtered_data = data.copy()
     logger.info(f"Filtering data for Country: {selected_country}, Industry: {selected_industry}")
     
@@ -99,138 +99,56 @@ def filter_investors_by_country_and_industry(selected_country, selected_industry
     investor_valuations = {}
     for investor, companies in investor_company_mapping_filtered.items():
         total_valuation = filtered_data[filtered_data["Company"].isin(companies)]["Valuation_Billions"].sum()
-        if total_valuation >= 20:  # Investors with >= 20B total valuation
+        if total_valuation >= valuation_threshold:
             investor_valuations[investor] = total_valuation
     
-    logger.info(f"Filtered investors with total valuation >= 20B: {len(investor_valuations)}")
+    logger.info(f"Filtered investors with total valuation >= {valuation_threshold}B: {len(investor_valuations)}")
     
     return list(investor_valuations.keys()), filtered_data
 
-# Function to generate the Plotly graph
-def generate_graph(selected_investors, filtered_data):
-    if not selected_investors:
-        logger.warning("No investors selected. Returning empty figure.")
-        return go.Figure()
+# Gradio app function
+def app(selected_country, selected_industry, valuation_threshold):
+    investor_list, filtered_data = filter_investors_by_country_and_industry(selected_country, selected_industry, valuation_threshold)
     
-    investor_company_mapping_filtered = build_investor_company_mapping(filtered_data)
-    filtered_mapping = {inv: investor_company_mapping_filtered[inv] for inv in selected_investors if inv in investor_company_mapping_filtered}
-    
-    logger.info(f"Generating graph for {len(filtered_mapping)} investors.")
-    
-    # Build the graph
-    G = nx.Graph()
-    for investor, companies in filtered_mapping.items():
-        for company in companies:
-            G.add_edge(investor, company)
-    
-    # Generate positions using spring layout
-    pos = nx.spring_layout(G, k=0.2, seed=42)
-    
-    # Prepare Plotly traces
-    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_trace = go.Scatter(
-        x=edge_x, y=edge_y,
-        line=dict(width=0.5, color='#888'),
-        hoverinfo='none',
-        mode='lines'
-    )
-    
-    node_x = []
-    node_y = []
-    node_text = []
-    node_size = []
-    node_color = []
-    customdata = []
-    for node in G.nodes():
-        x, y = pos[node]
-        node_x.append(x)
-        node_y.append(y)
-        if node in filtered_mapping:
-            node_text.append(f"Investor: {node}")
-            node_size.append(20)  # Investors have larger size
-            node_color.append('orange')
-            customdata.append(None)  # Investors do not have a single valuation
-        else:
-            valuation = filtered_data.loc[filtered_data["Company"] == node, "Valuation_Billions"].sum()
-            node_text.append(f"Company: {node}<br>Valuation: ${valuation}B")
-            node_size.append(10 + (valuation / filtered_data["Valuation_Billions"].max()) * 30 if filtered_data["Valuation_Billions"].max() else 10)
-            node_color.append('green')
-            customdata.append(f"${valuation}B")
-    
-    node_trace = go.Scatter(
-        x=node_x, y=node_y,
-        mode='markers',
-        hoverinfo='text',
-        text=node_text,
-        customdata=customdata,
-        marker=dict(
-            showscale=False,
-            colorscale='YlGnBu',
-            color=node_color,
-            size=node_size,
-            line_width=2
+    if not investor_list:
+        return (
+            "No investors meet the selected criteria. Try reducing the valuation threshold or selecting different filters.",
+            None
         )
-    )
     
-    fig = go.Figure(data=[edge_trace, node_trace],
-             layout=go.Layout(
-                title='Venture Network Visualization',
-                titlefont_size=16,
-                showlegend=False,
-                hovermode='closest',
-                margin=dict(b=20,l=5,r=5,t=40),
-                annotations=[ dict(
-                    text="",
-                    showarrow=False,
-                    xref="paper", yref="paper") ],
-                xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
-                yaxis=dict(showgrid=False, zeroline=False, showticklabels=False))
-                )
-    
-    fig.update_traces(marker=dict(line=dict(width=0.5, color='white')), selector=dict(mode='markers'))
-    
-    logger.info("Plotly graph generated successfully.")
-    
-    return fig
+    return investor_list, generate_graph(investor_list, filtered_data)
 
 # Gradio Interface
 def main():
     country_list = ["All"] + sorted(data["Country"].dropna().unique())
     industry_list = ["All"] + sorted(data["Industry"].dropna().unique())
     
-    default_country = "United States" if "United States" in country_list else "All"
-    default_industry = "Enterprise Tech" if "Enterprise Tech" in industry_list else "All"
-    
     logger.info(f"Available countries: {country_list}")
     logger.info(f"Available industries: {industry_list}")
     
     with gr.Blocks() as demo:
         with gr.Row():
-            country_filter = gr.Dropdown(choices=country_list, label="Filter by Country", value=default_country)
-            industry_filter = gr.Dropdown(choices=industry_list, label="Filter by Industry", value=default_industry)
-        
-        filtered_investor_list = gr.CheckboxGroup(choices=[], label="Select Investors", visible=False)
+            country_filter = gr.Dropdown(choices=country_list, label="Filter by Country", value="All")
+            industry_filter = gr.Dropdown(choices=industry_list, label="Filter by Industry", value="All")
+            valuation_threshold = gr.Slider(minimum=0, maximum=50, step=1, value=20, label="Valuation Threshold (in B)")
+
         graph_output = gr.Plot(label="Venture Network Graph")
-        valuation_display = gr.Markdown(value="Click on a company node to see its valuation.", label="Company Valuation")
-        
-        filtered_data_holder = gr.State()
+        investor_output = gr.Text(label="Investor Results")
         
         country_filter.change(
-            filter_investors_by_country_and_industry,
-            inputs=[country_filter, industry_filter],
-            outputs=[filtered_investor_list, filtered_data_holder]
+            app,
+            inputs=[country_filter, industry_filter, valuation_threshold],
+            outputs=[investor_output, graph_output]
+        )
+        industry_filter.change(
+            app,
+            inputs=[country_filter, industry_filter, valuation_threshold],
+            outputs=[investor_output, graph_output]
         )
-        filtered_investor_list.change(
-            generate_graph,
-            inputs=[filtered_investor_list, filtered_data_holder],
-            outputs=graph_output
+        valuation_threshold.change(
+            app,
+            inputs=[country_filter, industry_filter, valuation_threshold],
+            outputs=[investor_output, graph_output]
         )
     
     demo.launch()