Update app.py

app.py

@@ -27,26 +27,18 @@ 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 not valuation_columns:
-    logger.error("No column containing 'Valuation' found in the dataset.")
-    raise ValueError("Data Error: Unable to find the valuation column. Please check your CSV file.")
-elif len(valuation_columns) > 1:
-    logger.error("Multiple columns containing 'Valuation' found in the dataset.")
-    raise ValueError("Data Error: Multiple valuation columns detected. Please ensure only one valuation column exists.")
-else:
-    valuation_column = valuation_columns[0]
-    logger.info(f"Using valuation column: {valuation_column}")
+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')
-logger.info("Valuation data cleaned and converted to numeric.")
-
 data = data.apply(lambda col: col.str.strip() if col.dtype == "object" else col)
-logger.info("Whitespace stripped from all string columns.")
-
-# Rename columns
-expected_columns = {
+data.rename(columns={
     "company": "Company",
     "valuation_billions": "Valuation_Billions",
     "date_joined": "Date_Joined",
@@ -54,17 +46,11 @@ expected_columns = {
     "city": "City",
     "industry": "Industry",
     "select_investors": "Select_Investors"
-}
+}, inplace=True)
 
-missing_columns = set(expected_columns.keys()) - set(data.columns)
-if missing_columns:
-    logger.error(f"Missing columns in the dataset: {missing_columns}")
-    raise ValueError(f"Data Error: Missing columns {missing_columns} in the dataset.")
+logger.info("Data cleaned and columns renamed.")
 
-data = data.rename(columns=expected_columns)
-logger.info("Columns renamed for consistency.")
-
-# Build investor to company mapping
+# Build investor-company mapping
 def build_investor_company_mapping(df):
     mapping = {}
     for _, row in df.iterrows():
@@ -80,8 +66,8 @@ def build_investor_company_mapping(df):
 investor_company_mapping = build_investor_company_mapping(data)
 logger.info("Investor to company mapping created.")
 
-# Filter investors
-def filter_investors_by_country_and_industry(selected_country, selected_industry, valuation_threshold):
+# Filter investors by country, industry, and valuation threshold
+def filter_investors(selected_country, selected_industry, valuation_threshold):
     filtered_data = data.copy()
     if selected_country != "All":
         filtered_data = filtered_data[filtered_data["Country"] == selected_country]
@@ -89,81 +75,106 @@ def filter_investors_by_country_and_industry(selected_country, selected_industry
         filtered_data = filtered_data[filtered_data["Industry"] == selected_industry]
 
     investor_company_mapping_filtered = build_investor_company_mapping(filtered_data)
-    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
-
-    return list(investor_valuations.keys()), filtered_data
+    investor_valuations = {
+        investor: filtered_data[filtered_data["Company"].isin(companies)]["Valuation_Billions"].sum()
+        for investor, companies in investor_company_mapping_filtered.items()
+    }
+    filtered_investors = [investor for investor, total in investor_valuations.items() if total >= valuation_threshold]
+    return filtered_investors, filtered_data
 
 # Generate Plotly graph
-def generate_graph(investor_list, filtered_data):
-    if not investor_list:
-        logger.warning("No investors selected. Returning empty figure.")
+def generate_graph(investors, filtered_data):
+    if not investors:
+        logger.warning("No investors selected.")
         return go.Figure()
 
     G = nx.Graph()
-    for investor in investor_list:
+    for investor in investors:
         companies = filtered_data[filtered_data["Select_Investors"].str.contains(investor, na=False)]["Company"].tolist()
         for company in companies:
             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=[],
-        y=[],
+        x=edge_x,
+        y=edge_y,
         line=dict(width=0.5, color='#888'),
         hoverinfo='none',
         mode='lines'
     )
 
-    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]
+    node_x = []
+    node_y = []
+    node_text = []
+    node_color = []
+
+    for node in G.nodes():
+        x, y = pos[node]
+        node_x.append(x)
+        node_y.append(y)
+        node_text.append(node)
+        if node in investors:
+            node_color.append(20)  # Fixed color value for investors
+        else:
+            valuation = filtered_data.loc[filtered_data["Company"] == node, "Valuation_Billions"].sum()
+            node_color.append(valuation)
 
     node_trace = go.Scatter(
-        x=[],
-        y=[],
-        text=[],
+        x=node_x,
+        y=node_y,
+        text=node_text,
         mode='markers',
         hoverinfo='text',
         marker=dict(
             showscale=True,
             colorscale='YlGnBu',
             size=10,
-            colorbar=dict(thickness=15, title="Node Value")
+            color=node_color,
+            colorbar=dict(
+                thickness=15,
+                title="Valuation (B)",
+                xanchor='left',
+                titleside='right'
+            )
         )
     )
 
-    for node in G.nodes():
-        x, y = pos[node]
-        node_trace.x += [x]
-        node_trace.y += [y]
-        node_trace.text += [node]
-
     fig = go.Figure(data=[edge_trace, node_trace])
+    fig.update_layout(
+        showlegend=False,
+        title="Venture Networks",
+        titlefont_size=16,
+        margin=dict(l=40, r=40, t=40, b=40),
+        hovermode='closest'
+    )
     return fig
 
 # 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
+    investors, filtered_data = filter_investors(selected_country, selected_industry, valuation_threshold)
+    graph = generate_graph(investors, filtered_data)
+    return investors, graph
 
 def main():
     country_list = ["All"] + sorted(data["Country"].dropna().unique())
     industry_list = ["All"] + sorted(data["Industry"].dropna().unique())
-    
+
     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_slider = gr.Slider(0, 50, value=20, label="Valuation Threshold (B)")
+            country_filter = gr.Dropdown(choices=country_list, label="Country", value="All")
+            industry_filter = gr.Dropdown(choices=industry_list, label="Industry", value="All")
+            valuation_slider = gr.Slider(0, 50, value=20, step=1, label="Valuation Threshold (B)")
 
-        investor_output = gr.Text(label="Investor List")
+        investor_output = gr.Textbox(label="Filtered Investors")
         graph_output = gr.Plot(label="Network Graph")
 
         country_filter.change(app, [country_filter, industry_filter, valuation_slider], [investor_output, graph_output])