Update app.py

app.py

@@ -21,11 +21,11 @@ except Exception as e:
     logger.error(f"Error loading CSV file: {e}")
     raise
 
-# Standardize column names: strip whitespace and convert to lowercase
+# Standardize column names
 data.columns = data.columns.str.strip().str.lower()
 logger.info(f"Standardized Column Names: {data.columns.tolist()}")
 
-# Identify the valuation column dynamically
+# Identify the valuation column
 valuation_columns = [col for col in data.columns if 'valuation' in col.lower()]
 if not valuation_columns:
     logger.error("No column containing 'Valuation' found in the dataset.")
@@ -42,11 +42,10 @@ data["valuation_billions"] = data[valuation_column].replace({'\$': '', ',': ''},
 data["valuation_billions"] = pd.to_numeric(data["valuation_billions"], errors='coerce')
 logger.info("Valuation data cleaned and converted to numeric.")
 
-# Strip whitespace from all string columns
 data = data.apply(lambda col: col.str.strip() if col.dtype == "object" else col)
 logger.info("Whitespace stripped from all string columns.")
 
-# Rename columns for consistency
+# Rename columns
 expected_columns = {
     "company": "Company",
     "valuation_billions": "Valuation_Billions",
@@ -65,7 +64,7 @@ if missing_columns:
 data = data.rename(columns=expected_columns)
 logger.info("Columns renamed for consistency.")
 
-# Parse the "Select_Investors" column to map investors to companies
+# Build investor to company mapping
 def build_investor_company_mapping(df):
     mapping = {}
     for _, row in df.iterrows():
@@ -74,39 +73,31 @@ def build_investor_company_mapping(df):
         if pd.notnull(investors):
             for investor in investors.split(","):
                 investor = investor.strip()
-                if investor:  # Ensure investor is not an empty string
+                if investor:
                     mapping.setdefault(investor, []).append(company)
     return mapping
 
 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
+# Filter investors
 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}")
-    
     if selected_country != "All":
         filtered_data = filtered_data[filtered_data["Country"] == selected_country]
-        logger.info(f"Data filtered by country: {selected_country}. Remaining records: {len(filtered_data)}")
     if selected_industry != "All":
         filtered_data = filtered_data[filtered_data["Industry"] == selected_industry]
-        logger.info(f"Data filtered by industry: {selected_industry}. Remaining records: {len(filtered_data)}")
-    
+
     investor_company_mapping_filtered = build_investor_company_mapping(filtered_data)
-    
-    # Calculate total valuation per investor
     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 >= valuation_threshold:
             investor_valuations[investor] = total_valuation
-    
-    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
+# Generate Plotly graph
 def generate_graph(investor_list, filtered_data):
     if not investor_list:
         logger.warning("No investors selected. Returning empty figure.")
@@ -118,9 +109,7 @@ def generate_graph(investor_list, filtered_data):
         for company in companies:
             G.add_edge(investor, company)
 
-    pos = nx.spring_layout(G, k=0.2, seed=42)
-
-    # Create Plotly traces for edges and nodes
+    pos = nx.spring_layout(G, seed=42)
     edge_trace = go.Scatter(
         x=[],
         y=[],
@@ -132,8 +121,8 @@ def generate_graph(investor_list, filtered_data):
     for edge in G.edges():
         x0, y0 = pos[edge[0]]
         x1, y1 = pos[edge[1]]
-        edge_trace['x'] += [x0, x1, None]
-        edge_trace['y'] += [y0, y1, None]
+        edge_trace.x += [x0, x1, None]
+        edge_trace.y += [y0, y1, None]
 
     node_trace = go.Scatter(
         x=[],
@@ -145,58 +134,42 @@ def generate_graph(investor_list, filtered_data):
             showscale=True,
             colorscale='YlGnBu',
             size=10,
-            colorbar=dict(thickness=15, title='Node Valuation')
+            colorbar=dict(thickness=15, title="Node Value")
         )
     )
 
     for node in G.nodes():
         x, y = pos[node]
-        node_trace['x'] += [x]
-        node_trace['y'] += [y]
-        node_trace['text'] += [f"{node}"]
+        node_trace.x += [x]
+        node_trace.y += [y]
+        node_trace.text += [node]
 
     fig = go.Figure(data=[edge_trace, node_trace])
     return fig
 
-# Gradio app function
+# Gradio app
 def app(selected_country, selected_industry, valuation_threshold):
     investor_list, filtered_data = filter_investors_by_country_and_industry(selected_country, selected_industry, valuation_threshold)
     graph = generate_graph(investor_list, filtered_data)
     return investor_list, graph
 
-# Gradio Interface
 def main():
     country_list = ["All"] + sorted(data["Country"].dropna().unique())
     industry_list = ["All"] + sorted(data["Industry"].dropna().unique())
     
-    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="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)")
-
-        investor_output = gr.Text(label="Investor Results")
-        graph_output = gr.Plot(label="Venture Network Graph")
-        
-        country_filter.change(
-            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]
-        )
-        valuation_threshold.change(
-            app,
-            inputs=[country_filter, industry_filter, valuation_threshold],
-            outputs=[investor_output, graph_output]
-        )
-    
+            valuation_slider = gr.Slider(0, 50, value=20, label="Valuation Threshold (B)")
+
+        investor_output = gr.Text(label="Investor List")
+        graph_output = gr.Plot(label="Network Graph")
+
+        country_filter.change(app, [country_filter, industry_filter, valuation_slider], [investor_output, graph_output])
+        industry_filter.change(app, [country_filter, industry_filter, valuation_slider], [investor_output, graph_output])
+        valuation_slider.change(app, [country_filter, industry_filter, valuation_slider], [investor_output, graph_output])
+
     demo.launch()
 
 if __name__ == "__main__":