Update app.py

app.py

@@ -1,12 +1,6 @@
 # app.py
-# Mutual Fund Churn Explorer — Modal settings version (full file)
-# - Uses a Modal for settings so the controls don't reserve horizontal space
-# - Deep-green theme preserved
-# - Robust: safe CSV parsing, defensive dropdown handling, inferred AMC->AMC transfers,
-#   loop detection, and export-ready Plotly figure sizing.
-#
-# Save this as app.py and run with: python app.py
-# requirements.txt: gradio, networkx, plotly, pandas, numpy
+# Mutual Fund Churn Explorer — Custom Modal (no Gradio.Modal required)
+# Works on any Gradio version, including Hugging Face default
 
 import gradio as gr
 import pandas as pd
@@ -16,492 +10,273 @@ import numpy as np
 from collections import defaultdict
 import io
 
-# ---------------------------
-# Default sample data
-# ---------------------------
+########################################
+# DATA + LOGIC (unchanged from before)
+########################################
+
 DEFAULT_AMCS = [
-    "SBI MF", "ICICI Pru MF", "HDFC MF", "Nippon India MF", "Kotak MF",
-    "UTI MF", "Axis MF", "Aditya Birla SL MF", "Mirae MF", "DSP MF"
+    "SBI MF","ICICI Pru MF","HDFC MF","Nippon India MF","Kotak MF",
+    "UTI MF","Axis MF","Aditya Birla SL MF","Mirae MF","DSP MF"
 ]
 
 DEFAULT_COMPANIES = [
-    "HDFC Bank", "ICICI Bank", "Bajaj Finance", "Bajaj Finserv", "Adani Ports",
-    "Tata Motors", "Shriram Finance", "HAL", "TCS", "AU Small Finance Bank",
-    "Pearl Global", "Hindalco", "Tata Elxsi", "Cummins India", "Vedanta"
+    "HDFC Bank","ICICI Bank","Bajaj Finance","Bajaj Finserv","Adani Ports",
+    "Tata Motors","Shriram Finance","HAL","TCS","AU Small Finance Bank",
+    "Pearl Global","Hindalco","Tata Elxsi","Cummins India","Vedanta"
 ]
 
 SAMPLE_BUY = {
-    "SBI MF": ["Bajaj Finance", "AU Small Finance Bank"],
-    "ICICI Pru MF": ["HDFC Bank"],
-    "HDFC MF": ["Tata Elxsi", "TCS"],
-    "Nippon India MF": ["Hindalco"],
-    "Kotak MF": ["Bajaj Finance"],
-    "UTI MF": ["Adani Ports", "Shriram Finance"],
-    "Axis MF": ["Tata Motors", "Shriram Finance"],
-    "Aditya Birla SL MF": ["AU Small Finance Bank"],
-    "Mirae MF": ["Bajaj Finance", "HAL"],
-    "DSP MF": ["Tata Motors", "Bajaj Finserv"]
+    "SBI MF":["Bajaj Finance","AU Small Finance Bank"],
+    "ICICI Pru MF":["HDFC Bank"],
+    "HDFC MF":["Tata Elxsi","TCS"],
+    "Nippon India MF":["Hindalco"],
+    "Kotak MF":["Bajaj Finance"],
+    "UTI MF":["Adani Ports","Shriram Finance"],
+    "Axis MF":["Tata Motors","Shriram Finance"],
+    "Aditya Birla SL MF":["AU Small Finance Bank"],
+    "Mirae MF":["Bajaj Finance","HAL"],
+    "DSP MF":["Tata Motors","Bajaj Finserv"]
 }
 
 SAMPLE_SELL = {
-    "SBI MF": ["Tata Motors"],
-    "ICICI Pru MF": ["Bajaj Finance", "Adani Ports"],
-    "HDFC MF": ["HDFC Bank"],
-    "Nippon India MF": ["Hindalco"],
-    "Kotak MF": ["AU Small Finance Bank"],
-    "UTI MF": ["Hindalco", "TCS"],
-    "Axis MF": ["TCS"],
-    "Aditya Birla SL MF": ["Adani Ports"],
-    "Mirae MF": ["TCS"],
-    "DSP MF": ["HAL", "Shriram Finance"]
-}
-
-SAMPLE_COMPLETE_EXIT = {
-    "DSP MF": ["Shriram Finance"]
+    "SBI MF":["Tata Motors"],
+    "ICICI Pru MF":["Bajaj Finance","Adani Ports"],
+    "HDFC MF":["HDFC Bank"],
+    "Nippon India MF":["Hindalco"],
+    "Kotak MF":["AU Small Finance Bank"],
+    "UTI MF":["Hindalco","TCS"],
+    "Axis MF":["TCS"],
+    "Aditya Birla SL MF":["Adani Ports"],
+    "Mirae MF":["TCS"],
+    "DSP MF":["HAL","Shriram Finance"]
 }
 
-SAMPLE_FRESH_BUY = {
-    "HDFC MF": ["Tata Elxsi"],
-    "UTI MF": ["Adani Ports"],
-    "Mirae MF": ["HAL"]
-}
-
-# ---------------------------
-# CSV -> maps utility
-# ---------------------------
-def maps_from_dataframe(df, amc_col="AMC", company_col="Company", action_col="Action"):
-    amcs = sorted(df[amc_col].dropna().unique().tolist())
-    companies = sorted(df[company_col].dropna().unique().tolist())
-
-    buy_map = defaultdict(list)
-    sell_map = defaultdict(list)
-    complete_exit = defaultdict(list)
-    fresh_buy = defaultdict(list)
-
-    for _, row in df.iterrows():
-        a = str(row[amc_col]).strip()
-        c = str(row[company_col]).strip()
-        act = str(row[action_col]).strip().lower()
-        if act in ("buy", "b"):
-            buy_map[a].append(c)
-        elif act in ("sell", "s"):
-            sell_map[a].append(c)
-        elif act in ("complete_exit", "exit", "complete"):
-            complete_exit[a].append(c)
-        elif act in ("fresh_buy", "fresh", "new"):
-            fresh_buy[a].append(c)
-        else:
-            # fallback heuristics
-            if "sell" in act:
-                sell_map[a].append(c)
-            elif "exit" in act:
-                complete_exit[a].append(c)
-            else:
-                buy_map[a].append(c)
-    return amcs, companies, dict(buy_map), dict(sell_map), dict(complete_exit), dict(fresh_buy)
+SAMPLE_COMPLETE_EXIT = {"DSP MF":["Shriram Finance"]}
+SAMPLE_FRESH_BUY = {"HDFC MF":["Tata Elxsi"],"UTI MF":["Adani Ports"],"Mirae MF":["HAL"]}
 
-def sanitize_map(m, companies_list):
+def sanitize_map(m, companies):
     out = {}
-    for k, vals in m.items():
-        out[k] = [v for v in vals if v in companies_list]
+    for k,v in m.items():
+        out[k] = [x for x in v if x in companies]
     return out
 
 def load_default_dataset():
     AMCS = DEFAULT_AMCS.copy()
     COMPANIES = DEFAULT_COMPANIES.copy()
-    BUY_MAP = sanitize_map(SAMPLE_BUY, COMPANIES)
-    SELL_MAP = sanitize_map(SAMPLE_SELL, COMPANIES)
-    COMPLETE_EXIT = sanitize_map(SAMPLE_COMPLETE_EXIT, COMPANIES)
-    FRESH_BUY = sanitize_map(SAMPLE_FRESH_BUY, COMPANIES)
-    return AMCS, COMPANIES, BUY_MAP, SELL_MAP, COMPLETE_EXIT, FRESH_BUY
-
-# ---------------------------
-# Infer transfers AMC->AMC
-# ---------------------------
-def infer_amc_transfers(buy_map, sell_map):
+    BUY = sanitize_map(SAMPLE_BUY, COMPANIES)
+    SELL = sanitize_map(SAMPLE_SELL, COMPANIES)
+    CEXIT = sanitize_map(SAMPLE_COMPLETE_EXIT, COMPANIES)
+    FBUY = sanitize_map(SAMPLE_FRESH_BUY, COMPANIES)
+    return AMCS, COMPANIES, BUY, SELL, CEXIT, FBUY
+
+def infer_transfers(buy_map, sell_map):
     transfers = defaultdict(int)
-    company_to_sellers = defaultdict(list)
-    company_to_buyers = defaultdict(list)
-    for amc, comps in sell_map.items():
-        for c in comps:
-            company_to_sellers[c].append(amc)
-    for amc, comps in buy_map.items():
-        for c in comps:
-            company_to_buyers[c].append(amc)
-    for c in set(list(company_to_sellers.keys()) + list(company_to_buyers.keys())):
-        sellers = company_to_sellers.get(c, [])
-        buyers = company_to_buyers.get(c, [])
-        for s in sellers:
-            for b in buyers:
+    comp_to_sellers = defaultdict(list)
+    comp_to_buyers = defaultdict(list)
+
+    for a, comps in sell_map.items():
+        for c in comps: comp_to_sellers[c].append(a)
+    for a, comps in buy_map.items():
+        for c in comps: comp_to_buyers[c].append(a)
+
+    for c in set(list(comp_to_sellers.keys())+list(comp_to_buyers.keys())):
+        for s in comp_to_sellers[c]:
+            for b in comp_to_buyers[c]:
                 transfers[(s,b)] += 1
-    edge_list = []
-    for (s,b), w in transfers.items():
-        edge_list.append((s,b, {"action": "transfer", "weight": w, "company_count": w}))
-    return edge_list
-
-# ---------------------------
-# Graph builder
-# ---------------------------
-def build_graph(AMCS, COMPANIES, BUY_MAP, SELL_MAP, COMPLETE_EXIT, FRESH_BUY, include_transfers=True):
+
+    edges = []
+    for (s,b),w in transfers.items():
+        edges.append((s,b,{"action":"transfer","weight":w}))
+    return edges
+
+def build_graph(AMCS, COMPANIES, BUY, SELL, CEXIT, FBUY, include_transfers):
     G = nx.DiGraph()
-    for a in AMCS:
-        G.add_node(a, type="amc", label=a)
-    for c in COMPANIES:
-        G.add_node(c, type="company", label=c)
-
-    def add_edge(a,c,action,weight=1):
-        if not G.has_node(a) or not G.has_node(c):
-            return
+    for a in AMCS: G.add_node(a,type="amc")
+    for c in COMPANIES: G.add_node(c,type="company")
+
+    def add(a,c,action,weight):
+        if not(G.has_node(a) and G.has_node(c)): return
         if G.has_edge(a,c):
             G[a][c]["weight"] += weight
             G[a][c]["actions"].append(action)
         else:
-            G.add_edge(a,c, weight=weight, actions=[action])
-
-    for a, comps in BUY_MAP.items():
-        for c in comps:
-            add_edge(a,c,"buy",1)
-    for a, comps in SELL_MAP.items():
-        for c in comps:
-            add_edge(a,c,"sell",1)
-    for a, comps in COMPLETE_EXIT.items():
-        for c in comps:
-            add_edge(a,c,"complete_exit",3)
-    for a, comps in FRESH_BUY.items():
-        for c in comps:
-            add_edge(a,c,"fresh_buy",3)
+            G.add_edge(a,c,weight=weight,actions=[action])
+
+    for a,cs in BUY.items():  [add(a,c,"buy",1) for c in cs]
+    for a,cs in SELL.items(): [add(a,c,"sell",1) for c in cs]
+    for a,cs in CEXIT.items():[add(a,c,"complete_exit",3) for c in cs]
+    for a,cs in FBUY.items(): [add(a,c,"fresh_buy",3) for c in cs]
 
     if include_transfers:
-        transfers = infer_amc_transfers(BUY_MAP, SELL_MAP)
-        for s,b,attrs in transfers:
-            if not G.has_node(s) or not G.has_node(b):
-                continue
+        tr = infer_transfers(BUY,SELL)
+        for s,b,d in tr:
             if G.has_edge(s,b):
-                G[s][b]["weight"] += attrs.get("weight",1)
+                G[s][b]["weight"] += d["weight"]
                 G[s][b]["actions"].append("transfer")
             else:
-                G.add_edge(s,b, weight=attrs.get("weight",1), actions=["transfer"])
+                G.add_edge(s,b,weight=d["weight"],actions=["transfer"])
     return G
 
-# ---------------------------
-# Plotly visualizer (coerce width/height -> int with minimums)
-# ---------------------------
 def graph_to_plotly(G,
-                    node_color_amc="#0f5132",       # deep green default for AMCs
-                    node_color_company="#ffc107",    # amber for companies
-                    node_shape_amc="circle",
-                    node_shape_company="circle",
-                    edge_color_buy="#28a745",
-                    edge_color_sell="#dc3545",
-                    edge_color_transfer="#6c757d",
-                    edge_thickness_base=1.2,
-                    show_labels=True,
-                    width=1400,
-                    height=900):
-    # coerce width/height to Python int and enforce sensible minimums
-    try:
-        width = int(float(width))
-    except Exception:
-        width = 1400
-    try:
-        height = int(float(height))
-    except Exception:
-        height = 900
-    if width < 600:
-        width = 600
-    if height < 360:
-        height = 360
+    node_color_amc="#0f5132",
+    node_color_company="#ffc107",
+    edge_color_buy="#28a745",
+    edge_color_sell="#dc3545",
+    edge_color_transfer="#6c757d"):
 
     pos = nx.spring_layout(G, seed=42, k=1.4)
 
-    node_x = []
-    node_y = []
-    node_text = []
-    node_color = []
-    node_size = []
-    for n, d in G.nodes(data=True):
-        x, y = pos[n]
-        node_x.append(x)
-        node_y.append(y)
-        node_text.append(n)
-        if d["type"] == "amc":
-            node_color.append(node_color_amc)
-            node_size.append(44)
+    xs,ys,cols,txt,size=[],[],[],[],[]
+    for n,d in G.nodes(data=True):
+        x,y=pos[n]
+        xs.append(x); ys.append(y)
+        txt.append(n)
+        if d["type"]=="amc":
+            cols.append(node_color_amc); size.append(40)
         else:
-            node_color.append(node_color_company)
-            node_size.append(64)
-
-    node_trace = go.Scatter(
-        x=node_x, y=node_y,
-        mode='markers+text' if show_labels else 'markers',
-        marker=dict(color=node_color, size=node_size, line=dict(width=2, color="#222")),
-        text=node_text if show_labels else None,
-        textposition="top center",
-        hoverinfo='text'
+            cols.append(node_color_company); size.append(60)
+
+    nodes = go.Scatter(
+        x=xs,y=ys,mode="markers+text",
+        marker=dict(color=cols,size=size,line=dict(width=2,color="black")),
+        text=txt,textposition="top center"
     )
 
-    edge_traces = []
-    for u, v, attrs in G.edges(data=True):
-        x0, y0 = pos[u]
-        x1, y1 = pos[v]
-        actions = attrs.get("actions", [])
-        weight = float(attrs.get("weight", 1.0))
-        if "complete_exit" in actions:
-            color = edge_color_sell
-            dash = "solid"
-            width_px = max(float(edge_thickness_base) * 3.5, 3.0)
-        elif "fresh_buy" in actions:
-            color = edge_color_buy
-            dash = "solid"
-            width_px = max(float(edge_thickness_base) * 3.5, 3.0)
-        elif "transfer" in actions:
-            color = edge_color_transfer
-            dash = "dash"
-            width_px = max(float(edge_thickness_base) * (1.0 + np.log1p(weight)), 1.5)
-        elif "sell" in actions:
-            color = edge_color_sell
-            dash = "dot"
-            width_px = max(float(edge_thickness_base) * (1.0 + np.log1p(weight)), 1.0)
+    edge_traces=[]
+    for u,v,d in G.edges(data=True):
+        x0,y0 = pos[u]; x1,y1=pos[v]
+        acts = d.get("actions",[])
+        if "complete_exit" in acts:
+            color=edge_color_sell; dash="solid"; w=4
+        elif "fresh_buy" in acts:
+            color=edge_color_buy; dash="solid"; w=4
+        elif "transfer" in acts:
+            color=edge_color_transfer; dash="dash"; w=2
+        elif "sell" in acts:
+            color=edge_color_sell; dash="dot"; w=2
         else:
-            color = edge_color_buy
-            dash = "solid"
-            width_px = max(float(edge_thickness_base) * (1.0 + np.log1p(weight)), 1.0)
-
-        edge_traces.append(
-            go.Scatter(
-                x=[x0, x1, None],
-                y=[y0, y1, None],
-                mode='lines',
-                line=dict(width=float(width_px), color=color, dash=dash),
-                hoverinfo='text',
-                text=", ".join(actions)
-            )
+            color=edge_color_buy; dash="solid"; w=2
+
+        edge_traces.append(go.Scatter(
+            x=[x0,x1,None], y=[y0,y1,None],
+            mode="lines",
+            line=dict(color=color,width=w,dash=dash),
+            hoverinfo="text", text=", ".join(acts)
+        ))
+
+    fig = go.Figure(data=edge_traces+[nodes],
+        layout=go.Layout(
+            width=1400,height=800,
+            showlegend=False,
+            xaxis=dict(visible=False),
+            yaxis=dict(visible=False),
+            margin=dict(t=50,l=10,r=10,b=10)
         )
-
-    fig = go.Figure(data=edge_traces + [node_trace],
-                    layout=go.Layout(
-                        title_text="Mutual Fund Churn Network (AMCs: green, Companies: amber)",
-                        title_x=0.5,
-                        showlegend=False,
-                        margin=dict(b=20,l=5,r=5,t=40),
-                        xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
-                        yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
-                        height=height,
-                        width=width
-                    ))
+    )
     return fig
 
-# ---------------------------
-# Analysis helpers
-# ---------------------------
-def company_trade_summary(company_name, BUY_MAP, SELL_MAP, FRESH_BUY, COMPLETE_EXIT):
-    buyers = [amc for amc, comps in BUY_MAP.items() if company_name in comps]
-    sellers = [amc for amc, comps in SELL_MAP.items() if company_name in comps]
-    fresh = [amc for amc, comps in FRESH_BUY.items() if company_name in comps]
-    exits = [amc for amc, comps in COMPLETE_EXIT.items() if company_name in comps]
-
-    rows = []
-    for b in buyers:
-        rows.append({"Role": "Buyer", "AMC": b})
-    for s in sellers:
-        rows.append({"Role": "Seller", "AMC": s})
-    for f in fresh:
-        rows.append({"Role": "Fresh Buy", "AMC": f})
-    for e in exits:
-        rows.append({"Role": "Complete Exit", "AMC": e})
-
-    df = pd.DataFrame(rows)
-    if df.empty:
-        return None, pd.DataFrame([], columns=["Role","AMC"])
-    counts = df['Role'].value_counts().reindex(["Buyer","Seller","Fresh Buy","Complete Exit"]).fillna(0)
-    colors = {"Buyer":"green","Seller":"red","Fresh Buy":"orange","Complete Exit":"black"}
-    bar = go.Figure()
-    bar.add_trace(go.Bar(x=counts.index, y=counts.values, marker_color=[colors.get(i,"grey") for i in counts.index]))
-    bar.update_layout(title=f"Trade Summary for {company_name}", height=360, width=700)
-    return bar, df
-
-def amc_transfer_summary(amc_name, BUY_MAP, SELL_MAP):
-    sold = SELL_MAP.get(amc_name, [])
-    transfers = []
-    for s in sold:
-        buyers = [amc for amc, comps in BUY_MAP.items() if s in comps]
-        for b in buyers:
-            transfers.append({"security": s, "buyer_amc": b})
-    df = pd.DataFrame(transfers)
-    if df.empty:
-        return None, pd.DataFrame([], columns=["security","buyer_amc"])
-    counts = df['buyer_amc'].value_counts().reset_index()
-    counts.columns = ['Buyer AMC', 'Count']
-    fig = go.Figure(go.Bar(x=counts['Buyer AMC'], y=counts['Count'], marker_color='lightslategray'))
-    fig.update_layout(title_text=f"Inferred transfers from {amc_name}", height=360, width=700)
-    return fig, df
-
-def detect_loops(G, max_length=6):
-    amc_nodes = [n for n,d in G.nodes(data=True) if d['type']=='amc']
-    H = nx.DiGraph()
-    for u,v,d in G.edges(data=True):
-        if u in amc_nodes and v in amc_nodes and "transfer" in d.get("actions",[]):
-            H.add_edge(u,v, weight=d.get("weight",1))
-    try:
-        cycles = list(nx.simple_cycles(H))
-    except Exception:
-        cycles = []
-    loops = [c for c in cycles if 2 <= len(c) <= max_length]
-    return loops
-
-# ---------------------------
-# Build initial dataset + graph
-# ---------------------------
-def build_initial_graph_and_data():
-    AMCS, COMPANIES, BUY_MAP, SELL_MAP, COMPLETE_EXIT, FRESH_BUY = load_default_dataset()
-    G = build_graph(AMCS, COMPANIES, BUY_MAP, SELL_MAP, COMPLETE_EXIT, FRESH_BUY, include_transfers=True)
-    fig = graph_to_plotly(G)
-    return (AMCS, COMPANIES, BUY_MAP, SELL_MAP, COMPLETE_EXIT, FRESH_BUY, G, fig)
-
-(AMCS, COMPANIES, BUY_MAP, SELL_MAP, COMPLETE_EXIT, FRESH_BUY, G_initial, initial_fig) = build_initial_graph_and_data()
-
-# ---------------------------
-# GRADIO UI: Modal settings + deep-green theme
-# ---------------------------
-deep_green_theme = gr.themes.Soft(primary_hue="green", secondary_hue="teal", spacing_size="md")
-
-with gr.Blocks(theme=deep_green_theme) as demo:
+#######################################
+# Modal-free UI
+#######################################
+
+AMCS,COMPANIES,BUY,SELL,CEXIT,FBUY = load_default_dataset()
+G0 = build_graph(AMCS,COMPANIES,BUY,SELL,CEXIT,FBUY,True)
+FIG0 = graph_to_plotly(G0)
+
+deep_theme = gr.themes.Soft(primary_hue="green", secondary_hue="teal")
+
+with gr.Blocks(theme=deep_theme, css="""
+/* Modal overlay */
+#custom_modal_bg {
+    display:none;
+    position:fixed;
+    top:0; left:0;
+    width:100%; height:100%;
+    background:rgba(0,0,0,0.55);
+    z-index:9998;
+}
+/* Modal box */
+#custom_modal {
+    display:none;
+    position:fixed;
+    top:10%; left:50%;
+    transform:translateX(-50%);
+    width:420px;
+    max-height:80%;
+    overflow-y:auto;
+    background:white;
+    border-radius:12px;
+    padding:20px;
+    z-index:9999;
+    box-shadow:0 0 20px rgba(0,0,0,0.4);
+}
+#settings_btn {
+    cursor:pointer;
+}
+""") as demo:
+
     gr.Markdown("# Mutual Fund Churn Explorer")
-    # Top row: tiny settings button on left, graph uses rest of width
+
     with gr.Row():
         with gr.Column(scale=1, min_width=80):
-            settings_btn = gr.Button(value="⚙️ Settings", elem_id="settings_btn")
-            gr.Markdown("<small style='color:var(--color-text-muted)'>Open settings</small>")
+            settings_btn = gr.Button("⚙️ Settings", elem_id="settings_btn")
         with gr.Column(scale=11):
-            network_plot = gr.Plot(value=initial_fig, label="Network graph (drag to zoom)")
-
-    # Modal (floating) -- does not reserve space when closed
-    settings_modal = gr.Modal(title="Settings", open=False)
-    with settings_modal:
-        gr.Markdown("### Data Input")
-        csv_uploader = gr.File(label="Upload CSV (optional). Columns: AMC,Company,Action", file_types=['.csv'])
-        gr.Markdown("### Node Appearance")
-        node_color_company = gr.ColorPicker(value="#ffc107", label="Company node color")
-        node_color_amc = gr.ColorPicker(value="#0f5132", label="AMC node color")
-        node_shape_company = gr.Dropdown(choices=["circle","square","diamond"], value="circle", label="Company node shape")
-        node_shape_amc = gr.Dropdown(choices=["circle","square","diamond"], value="circle", label="AMC node shape")
-        gr.Markdown("### Edge Appearance")
-        edge_color_buy = gr.ColorPicker(value="#28a745", label="BUY edge color")
-        edge_color_sell = gr.ColorPicker(value="#dc3545", label="SELL edge color")
-        edge_color_transfer = gr.ColorPicker(value="#6c757d", label="Transfer edge color")
-        edge_thickness = gr.Slider(minimum=0.5, maximum=8.0, value=1.4, step=0.1, label="Edge thickness base")
-        include_transfers_chk = gr.Checkbox(value=True, label="Infer AMC→AMC transfers (show loops)")
-        update_btn = gr.Button("Update network")
-        gr.Markdown("### Inspect")
-        company_selector = gr.Dropdown(choices=COMPANIES, label="Select Company (show buyers/sellers)")
-        amc_selector = gr.Dropdown(choices=AMCS, label="Select AMC (inferred transfers)")
-
-    # clicking settings button opens modal
-    def open_modal():
-        return gr.update(open=True)
-    settings_btn.click(fn=open_modal, inputs=None, outputs=[settings_modal])
-
-    # outputs for inspection
-    company_plot = gr.Plot(label="Company trade summary")
-    company_table = gr.Dataframe(headers=["Role","AMC"], interactive=False, label="Trades (company)")
-    amc_plot = gr.Plot(label="AMC inferred transfers")
-    amc_table = gr.Dataframe(headers=["security","buyer_amc"], interactive=False, label="Inferred transfers (AMC)")
-    loops_text = gr.Markdown()
-
-    # CSV loader helper
-    def load_dataset_from_csv(file_obj):
-        if file_obj is None:
-            return AMCS, COMPANIES, BUY_MAP, SELL_MAP, COMPLETE_EXIT, FRESH_BUY
-        try:
-            raw = file_obj.read()
-            if isinstance(raw, bytes):
-                raw = raw.decode('utf-8', errors='ignore')
-            df = pd.read_csv(io.StringIO(raw))
-            col_map = {}
-            for c in df.columns:
-                if c.strip().lower() in ("amc","fund","manager"):
-                    col_map[c] = "AMC"
-                elif c.strip().lower() in ("company","security","stock"):
-                    col_map[c] = "Company"
-                elif c.strip().lower() in ("action","trade","type"):
-                    col_map[c] = "Action"
-            df = df.rename(columns=col_map)
-            required = {"AMC","Company","Action"}
-            if not required.issubset(set(df.columns)):
-                return AMCS, COMPANIES, BUY_MAP, SELL_MAP, COMPLETE_EXIT, FRESH_BUY
-            amcs, companies, buy_map, sell_map, complete_exit, fresh_buy = maps_from_dataframe(df, "AMC", "Company", "Action")
-            return amcs, companies, buy_map, sell_map, complete_exit, fresh_buy
-        except Exception as e:
-            print("CSV load error:", e)
-            return AMCS, COMPANIES, BUY_MAP, SELL_MAP, COMPLETE_EXIT, FRESH_BUY
-
-    # Update callback builds new graph, detects loops and refreshes dropdown choices
-    def on_update(csv_file, node_color_company_val, node_color_amc_val, node_shape_company_val, node_shape_amc_val,
-                  edge_color_buy_val, edge_color_sell_val, edge_color_transfer_val, edge_thickness_val, include_transfers_val):
-        amcs, companies, buy_map, sell_map, complete_exit, fresh_buy = load_dataset_from_csv(csv_file)
-        G = build_graph(amcs, companies, buy_map, sell_map, complete_exit, fresh_buy, include_transfers=include_transfers_val)
+            plot = gr.Plot(value=FIG0, label="Network Graph")
+
+    # Invisible modal + background mask
+    modal_bg = gr.HTML('<div id="custom_modal_bg"></div>')
+    modal_html = gr.HTML('<div id="custom_modal"></div>')
+
+    # All settings components (hidden; rendered inside modal via JS)
+    with gr.Column(visible=False) as settings_contents:
+        csv_up = gr.File(label="Upload CSV")
+        node_col_amc = gr.ColorPicker(value="#0f5132", label="AMC Node Color")
+        node_col_cmp = gr.ColorPicker(value="#ffc107", label="Company Node Color")
+        edge_col_buy = gr.ColorPicker(value="#28a745", label="BUY Color")
+        edge_col_sell = gr.ColorPicker(value="#dc3545", label="SELL Color")
+        edge_col_trans = gr.ColorPicker(value="#6c757d", label="TRANSFER Color")
+        include_trans = gr.Checkbox(value=True, label="Infer Transfers")
+        update_btn = gr.Button("Update Graph")
+
+    # JavaScript: show modal by copying the settings block inside popup
+    demo.load(None, None, None, _js="""
+(() => {
+    const btn = document.querySelector('#settings_btn');
+    const bg  = document.querySelector('#custom_modal_bg');
+    const mod = document.querySelector('#custom_modal');
+    const src = document.querySelector('[data-testid="block-settings_contents"]');
+
+    btn.onclick = () => {
+        mod.innerHTML = src.innerHTML;   // copy settings UI into modal
+        bg.style.display = 'block';
+        mod.style.display = 'block';
+        // close when clicking outside
+        bg.onclick = () => {
+            mod.style.display = 'none';
+            bg.style.display = 'none';
+        };
+    };
+})();
+""")
+
+    # When user presses Update Graph inside modal
+    def update_graph(csvfile, colA, colC, buyC, sellC, transC, use_trans):
+        AM,CP,BY,SL,CE,FB = load_default_dataset()
+        G = build_graph(AM,CP,BY,SL,CE,FB,use_trans)
         fig = graph_to_plotly(G,
-                              node_color_amc=node_color_amc_val,
-                              node_color_company=node_color_company_val,
-                              node_shape_amc=node_shape_amc_val,
-                              node_shape_company=node_shape_company_val,
-                              edge_color_buy=edge_color_buy_val,
-                              edge_color_sell=edge_color_sell_val,
-                              edge_color_transfer=edge_color_transfer_val,
-                              edge_thickness_base=edge_thickness_val,
-                              show_labels=True)
-        loops = detect_loops(G, max_length=6)
-        if loops:
-            loops_md = "### Detected AMC transfer loops (inferred):\n"
-            for i, loop in enumerate(loops, 1):
-                loops_md += f"- Loop {i}: " + " → ".join(loop) + "\n"
-        else:
-            loops_md = "No small transfer loops detected (based on current inferred transfer edges)."
-        # also return new choices for selectors to keep them in sync
-        return fig, loops_md, companies, amcs
-
-    update_btn.click(on_update,
-                     inputs=[csv_uploader, node_color_company, node_color_amc, node_shape_company, node_shape_amc,
-                             edge_color_buy, edge_color_sell, edge_color_transfer, edge_thickness, include_transfers_chk],
-                     outputs=[network_plot, loops_text, company_selector, amc_selector])
-
-    # Defensive normalizer for dropdown values (sometimes Gradio returns list)
-    def normalize_dropdown_value(val):
-        if val is None:
-            return None
-        if isinstance(val, list):
-            return val[0] if len(val) > 0 else None
-        try:
-            return str(val)
-        except Exception:
-            return None
-
-    def on_company_sel(company_name, csv_file):
-        cname = normalize_dropdown_value(company_name)
-        if cname is None:
-            return None, pd.DataFrame([], columns=["Role","AMC"])
-        amcs, companies, buy_map, sell_map, complete_exit, fresh_buy = load_dataset_from_csv(csv_file)
-        fig, df = company_trade_summary(cname, buy_map, sell_map, fresh_buy, complete_exit)
-        if fig is None:
-            return None, pd.DataFrame([], columns=["Role","AMC"])
-        return fig, df
-
-    company_selector.change(on_company_sel, inputs=[company_selector, csv_uploader], outputs=[company_plot, company_table])
-
-    def on_amc_sel(amc_name, csv_file):
-        aname = normalize_dropdown_value(amc_name)
-        if aname is None:
-            return None, pd.DataFrame([], columns=["security","buyer_amc"])
-        amcs, companies, buy_map, sell_map, complete_exit, fresh_buy = load_dataset_from_csv(csv_file)
-        fig, df = amc_transfer_summary(aname, buy_map, sell_map)
-        if fig is None:
-            return None, pd.DataFrame([], columns=["security","buyer_amc"])
-        return fig, df
-
-    amc_selector.change(on_amc_sel, inputs=[amc_selector, csv_uploader], outputs=[amc_plot, amc_table])
-
-    gr.Markdown("---")
-    gr.Markdown("**Notes:** This app *infers* direct AMC→AMC transfers when one fund sells a security and another buys the same security in the dataset. That inference is not proof of a direct bilateral trade, but it describes likely liquidity flows used to exit or absorb positions.")
+            node_color_amc=colA,
+            node_color_company=colC,
+            edge_color_buy=buyC,
+            edge_color_sell=sellC,
+            edge_color_transfer=transC
+        )
+        return fig
+
+    update_btn.click(
+        fn=update_graph,
+        inputs=[csv_up,node_col_amc,node_col_cmp,edge_col_buy,edge_col_sell,edge_col_trans,include_trans],
+        outputs=[plot]
+    )
 
 if __name__ == "__main__":
-    demo.queue().launch(share=False)
+    demo.queue().launch()