Update app.py

app.py

@@ -40,165 +40,69 @@ logger.info(f"Using valuation column: {valuation_column}")
 
 # Clean and prepare data
 data["valuation_billions"] = data[valuation_column].apply(
-    lambda x: float(re.sub(r"[^\d.]", "", str(x))) if pd.notnull(x) else 0
+    lambda x: float(re.sub(r"[^0-9.]", "", str(x))) / 1e9 if pd.notnull(x) else 0
 )
-data["valuation_billions"] = pd.to_numeric(data["valuation_billions"], errors='coerce')
-
-# Clean string columns
-data = data.apply(lambda col: col.str.strip() if col.dtype == "object" else col)
-data.rename(columns={
-    "company": "Company",
-    "date_joined": "Date_Joined",
-    "country": "Country",
-    "city": "City",
-    "industry": "Industry",
-    "select_investors": "Select_Investors"
-}, inplace=True)
-
-logger.info("Data cleaned and columns renamed.")
-
-# Build investor-company mapping
-def build_investor_company_mapping(df):
-    mapping = {}
-    for _, row in df.iterrows():
-        company = row["Company"]
-        investors = row["Select_Investors"]
-        if pd.notnull(investors):
-            for investor in investors.split(","):
-                investor = investor.strip()
-                if investor:
-                    mapping.setdefault(investor, []).append(company)
-    return mapping
-
-investor_company_mapping = build_investor_company_mapping(data)
-logger.info("Investor to company mapping created.")
-
-# -------------------------
-# Valuation-Range Logic
-# -------------------------
-def filter_by_valuation_range(df, selected_valuation_range):
-    """Filter dataframe by the specified valuation range in billions."""
-    if selected_valuation_range == "All":
-        return df  # No further filtering
-
-    if selected_valuation_range == "1-5":
-        return df[(df["valuation_billions"] >= 1) & (df["valuation_billions"] < 5)]
-    elif selected_valuation_range == "5-10":
-        return df[(df["valuation_billions"] >= 5) & (df["valuation_billions"] < 10)]
-    elif selected_valuation_range == "10-15":
-        return df[(df["valuation_billions"] >= 10) & (df["valuation_billions"] < 15)]
-    elif selected_valuation_range == "15-20":
-        return df[(df["valuation_billions"] >= 15) & (df["valuation_billions"] < 20)]
-    elif selected_valuation_range == "20+":
-        return df[df["valuation_billions"] >= 20]
-    else:
-        return df  # Fallback, should never happen
-
-# Filter investors by country, industry, investor selection, company selection, and valuation range
-def filter_investors(
-    selected_country,
-    selected_industry,
-    selected_investors,
-    selected_company,
-    exclude_countries,
-    exclude_industries,
-    exclude_companies,
-    selected_valuation_range
-):
-    filtered_data = data.copy()
-
-    # Apply filters
-    if selected_country:
-        filtered_data = filtered_data[filtered_data["Country"] == selected_country]
-    if selected_industry:
-        filtered_data = filtered_data[filtered_data["Industry"] == selected_industry]
-    if selected_investors:
-        filtered_data = filtered_data[filtered_data["Select_Investors"].str.contains(selected_investors, na=False)]
-    if selected_company:
-        filtered_data = filtered_data[filtered_data["Company"] == selected_company]
-    if exclude_countries:
-        filtered_data = filtered_data[~filtered_data["Country"].isin(exclude_countries)]
-    if exclude_industries:
-        filtered_data = filtered_data[~filtered_data["Industry"].isin(exclude_industries)]
-    if exclude_companies:
-        filtered_data = filtered_data[~filtered_data["Company"].isin(exclude_companies)]
-    if selected_valuation_range:
-        filtered_data = filter_by_valuation_range(filtered_data, selected_valuation_range)
-
-    return filtered_data
-
-# Create the graph visualization
-def create_network_graph(filtered_data):
-    graph = nx.Graph()
-
-    # Add nodes and edges
-    for _, row in filtered_data.iterrows():
-        company = row['Company']
-        venture_firm = row['Select_Investors']
-
-        # Add company node (green color, size based on valuation)
-        graph.add_node(company, node_color='green', node_size=row['valuation_billions'] * 10)
-
-        # Add venture firm node (different color, fixed size)
-        graph.add_node(venture_firm, node_color='blue', node_size=30)
-
-        # Add an edge between the company and the venture firm
-        graph.add_edge(company, venture_firm)
-
-    # Generate visualization
-    pos = nx.spring_layout(graph)  # Layout for positioning
-    fig = go.Figure()
-
-    # Add nodes
-    for node, attrs in graph.nodes(data=True):
-        fig.add_trace(go.Scatter(
-            x=[pos[node][0]], y=[pos[node][1]],
-            mode='markers+text',
-            marker=dict(size=attrs['node_size'], color=attrs['node_color']),
-            text=node,
-            textposition='top center'
-        ))
-
-    # Add edges
-    for edge in graph.edges:
-        x0, y0 = pos[edge[0]]
-        x1, y1 = pos[edge[1]]
-        fig.add_trace(go.Scatter(
-            x=[x0, x1, None], y=[y0, y1, None],
-            mode='lines',
-            line=dict(width=1, color='grey')
-        ))
-
-    fig.update_layout(title="Company-Investor Network", showlegend=False)
-
-    # Add the note to the plot
-    note = ("Note: All companies are in green while venture firms have different colors. "
-            "The diameter of the company circle varies proportionate to the valuation of the corresponding company.")
-    logger.info(note)
-
-    return fig
-
-# Gradio interface
-def display_network(selected_country, selected_industry, selected_investors, selected_company, 
-                    exclude_countries, exclude_industries, exclude_companies, selected_valuation_range):
-    filtered_data = filter_investors(
-        selected_country, selected_industry, selected_investors, selected_company, 
-        exclude_countries, exclude_industries, exclude_companies, selected_valuation_range
+logger.info("Valuation column cleaned and converted to billions.")
+
+# Create a graph
+G = nx.Graph()
+
+for _, row in data.iterrows():
+    company_name = row["company"]
+    valuation = row["valuation_billions"]
+    industry = row["industry"]
+
+    # Add company node
+    G.add_node(
+        company_name,
+        size=valuation,
+        color="green" if industry == "Venture Firm" else "blue",
     )
-    return create_network_graph(filtered_data)
-
-# Gradio interface inputs
-inputs = [
-    gr.Textbox(label="Select Country"),
-    gr.Textbox(label="Select Industry"),
-    gr.Textbox(label="Select Investors"),
-    gr.Textbox(label="Select Company"),
-    gr.Textbox(label="Exclude Countries"),
-    gr.Textbox(label="Exclude Industries"),
-    gr.Textbox(label="Exclude Companies"),
-    gr.Radio(choices=["All", "1-5", "5-10", "10-15", "15-20", "20+"], label="Valuation Range")
-]
-
-# Launch the Gradio interface
-interface = gr.Interface(fn=display_network, inputs=inputs, outputs="plot", live=True)
-interface.launch()
+
+    # Add connections based on relationships (assume relationships column exists)
+    if "relationships" in data.columns:
+        relationships = str(row["relationships"]).split(";")
+        for relation in relationships:
+            G.add_edge(company_name, relation.strip())
+
+# Create Plotly visualization
+node_sizes = [G.nodes[node]["size"] * 50 for node in G.nodes]
+node_colors = [G.nodes[node]["color"] for node in G.nodes]
+
+pos = nx.spring_layout(G)
+x_coords = [pos[node][0] for node in G.nodes]
+y_coords = [pos[node][1] for node in G.nodes]
+
+fig = go.Figure()
+
+fig.add_trace(
+    go.Scatter(
+        x=x_coords,
+        y=y_coords,
+        mode="markers+text",
+        marker=dict(size=node_sizes, color=node_colors, opacity=0.8),
+        text=list(G.nodes),
+        textposition="top center",
+    )
+)
+
+fig.update_layout(
+    title="Company Network Visualization",
+    xaxis=dict(showgrid=False, zeroline=False),
+    yaxis=dict(showgrid=False, zeroline=False),
+    showlegend=False,
+)
+
+# Note: All companies are in green while venture firms have different colors. 
+# The diameter of the company circle varies proportionate to the valuation of the corresponding company.
+
+# Create Gradio interface
+def display_network():
+    return fig.to_html()
+
+gr.Interface(
+    fn=display_network,
+    inputs=[],
+    outputs="html",
+    title="Company Network Visualization",
+).launch()