Update app.py

app.py

@@ -1,282 +1,294 @@
-# app.py
-# Mutual Fund Churn Explorer — Custom Modal (no Gradio.Modal required)
-# Works on any Gradio version, including Hugging Face default
-
+# app.py (fixed)
 import gradio as gr
 import pandas as pd
 import networkx as nx
 import plotly.graph_objects as go
 import numpy as np
 from collections import defaultdict
-import io
-
-########################################
-# 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"
+# ---------------------------
+# Data (same as before)
+# ---------------------------
+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"
 ]
 
-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"
+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"
 ]
 
-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"]
+BUY_MAP = {
+    "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"]
+}
+
+SELL_MAP = {
+    "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_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"]
+COMPLETE_EXIT = {
+    "DSP MF": ["Shriram Finance"],
 }
 
-SAMPLE_COMPLETE_EXIT = {"DSP MF":["Shriram Finance"]}
-SAMPLE_FRESH_BUY = {"HDFC MF":["Tata Elxsi"],"UTI MF":["Adani Ports"],"Mirae MF":["HAL"]}
+FRESH_BUY = {
+    "HDFC MF": ["Tata Elxsi"],
+    "UTI MF": ["Adani Ports"],
+    "Mirae MF": ["HAL"]
+}
 
-def sanitize_map(m, companies):
+def sanitize_map(m):
     out = {}
-    for k,v in m.items():
-        out[k] = [x for x in v if x in companies]
+    for k, vals in m.items():
+        out[k] = [v for v in vals if v in COMPANIES]
     return out
 
-def load_default_dataset():
-    AMCS = DEFAULT_AMCS.copy()
-    COMPANIES = DEFAULT_COMPANIES.copy()
-    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):
+BUY_MAP = sanitize_map(BUY_MAP)
+SELL_MAP = sanitize_map(SELL_MAP)
+COMPLETE_EXIT = sanitize_map(COMPLETE_EXIT)
+FRESH_BUY = sanitize_map(FRESH_BUY)
+
+company_edges = []
+for amc, comps in BUY_MAP.items():
+    for c in comps:
+        company_edges.append((amc, c, {"action": "buy", "weight": 1}))
+for amc, comps in SELL_MAP.items():
+    for c in comps:
+        company_edges.append((amc, c, {"action": "sell", "weight": 1}))
+for amc, comps in COMPLETE_EXIT.items():
+    for c in comps:
+        company_edges.append((amc, c, {"action": "complete_exit", "weight": 3}))
+for amc, comps in FRESH_BUY.items():
+    for c in comps:
+        company_edges.append((amc, c, {"action": "fresh_buy", "weight": 3}))
+
+def infer_amc_transfers(buy_map, sell_map):
     transfers = defaultdict(int)
-    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]:
+    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:
                 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
 
-    edges = []
-    for (s,b),w in transfers.items():
-        edges.append((s,b,{"action":"transfer","weight":w}))
-    return edges
+transfer_edges = infer_amc_transfers(BUY_MAP, SELL_MAP)
 
-def build_graph(AMCS, COMPANIES, BUY, SELL, CEXIT, FBUY, include_transfers):
+def build_graph(include_transfers=True):
     G = nx.DiGraph()
-    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
+    for a in AMCS:
+        G.add_node(a, type="amc", label=a)
+    for c in COMPANIES:
+        G.add_node(c, type="company", label=c)
+    for a, c, attrs in company_edges:
+        if not G.has_node(a) or not G.has_node(c):
+            continue
         if G.has_edge(a,c):
-            G[a][c]["weight"] += weight
-            G[a][c]["actions"].append(action)
+            G[a][c]["weight"] += attrs.get("weight",1)
+            G[a][c]["actions"].append(attrs["action"])
         else:
-            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]
-
+            G.add_edge(a, c, weight=attrs.get("weight",1), actions=[attrs["action"]])
     if include_transfers:
-        tr = infer_transfers(BUY,SELL)
-        for s,b,d in tr:
+        for s,b,attrs in transfer_edges:
+            if not G.has_node(s) or not G.has_node(b):
+                continue
             if G.has_edge(s,b):
-                G[s][b]["weight"] += d["weight"]
+                G[s][b]["weight"] += attrs.get("weight",1)
                 G[s][b]["actions"].append("transfer")
             else:
-                G.add_edge(s,b,weight=d["weight"],actions=["transfer"])
+                G.add_edge(s, b, weight=attrs.get("weight",1), actions=["transfer"])
     return G
 
+# ---------------------------
+# Visualization
+# ---------------------------
 def graph_to_plotly(G,
-    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)
-
-    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)
+                    node_color_amc="#9EC5FF",
+                    node_color_company="#FFCF9E",
+                    node_shape_amc="circle",
+                    node_shape_company="circle",
+                    edge_color_buy="#2ca02c",
+                    edge_color_sell="#d62728",
+                    edge_color_transfer="#888888",
+                    edge_thickness_base=1.2,
+                    show_labels=True):
+    pos = nx.spring_layout(G, seed=42, k=1.2)
+    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(40)
         else:
-            cols.append(node_color_company); size.append(60)
+            node_color.append(node_color_company); node_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"
+    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'
     )
 
-    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
+    edge_traces = []
+    for u, v, attrs in G.edges(data=True):
+        actions = attrs.get("actions",[])
+        weight = attrs.get("weight",1)
+        x0, y0 = pos[u]; x1, y1 = pos[v]
+        if "complete_exit" in actions:
+            color = edge_color_sell; dash = "solid"; width = max(edge_thickness_base * 3, 3)
+        elif "fresh_buy" in actions:
+            color = edge_color_buy; dash = "solid"; width = max(edge_thickness_base * 3, 3)
+        elif "transfer" in actions:
+            color = edge_color_transfer; dash = "dash"; width = max(edge_thickness_base * (1 + np.log1p(weight)), 1.5)
+        elif "sell" in actions:
+            color = edge_color_sell; dash = "dot"; width = max(edge_thickness_base * (1 + np.log1p(weight)), 1)
         else:
-            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)
-        )
-    )
+            color = edge_color_buy; dash = "solid"; width = max(edge_thickness_base * (1 + np.log1p(weight)), 1)
+        trace = go.Scatter(x=[x0, x1, None], y=[y0, y1, None],
+                           line=dict(width=width, color=color, dash=dash),
+                           hoverinfo='none', mode='lines')
+        edge_traces.append(trace)
+
+    fig = go.Figure(data=edge_traces + [node_trace],
+                    layout=go.Layout(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=900, width=1400))
     return fig
 
-#######################################
-# 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")
-
+# ---------------------------
+# Analysis helpers
+# ---------------------------
+def company_trade_summary(company_name):
+    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]
+    df = pd.DataFrame({
+        "Role": ["Buyer"]*len(buyers) + ["Seller"]*len(sellers) + ["Fresh buy"]*len(fresh) + ["Complete exit"]*len(exits),
+        "AMC": buyers + sellers + fresh + exits
+    })
+    if df.empty:
+        return None, pd.DataFrame([], columns=["Role","AMC"])
+    counts = df.groupby("Role").size().reset_index(name="Count")
+    fig = go.Figure(go.Bar(x=counts["Role"], y=counts["Count"], marker_color=["green","red","orange","black"][:len(counts)]))
+    fig.update_layout(title_text=f"Trade summary for {company_name}", height=300, width=600)
+    return fig, df
+
+def amc_transfer_summary(amc_name):
+    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=300, width=600)
+    return fig, df
+
+# Build an initial figure (no transfers by default)
+initial_G = build_graph(include_transfers=True)
+initial_fig = graph_to_plotly(initial_G)
+
+# ---------------------------
+# Gradio UI (Blocks)
+# ---------------------------
+with gr.Blocks() as demo:
+    gr.Markdown("## Mutual Fund Churn explorer — interactive network + transfer analysis")
     with gr.Row():
-        with gr.Column(scale=1, min_width=80):
-            settings_btn = gr.Button("⚙️ Settings", elem_id="settings_btn")
-        with gr.Column(scale=11):
-            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)
+        with gr.Column(scale=3):
+            gr.Markdown("### Network customization")
+            node_color_company = gr.ColorPicker(value="#FFCF9E", label="Company node color")
+            node_color_amc = gr.ColorPicker(value="#9EC5FF", 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")
+            edge_color_buy = gr.ColorPicker(value="#2ca02c", label="BUY edge color")
+            edge_color_sell = gr.ColorPicker(value="#d62728", label="SELL edge color")
+            edge_color_transfer = gr.ColorPicker(value="#888888", label="Transfer edge color")
+            edge_thickness = gr.Slider(minimum=0.5, maximum=6.0, value=1.4, step=0.1, label="Edge thickness base")
+            include_transfers = gr.Checkbox(value=True, label="Infer AMC → AMC transfers (show direct loops)")
+            update_button = gr.Button("Update network")
+
+            gr.Markdown("### Inspect specific node")
+            select_company = gr.Dropdown(choices=COMPANIES, label="Select company (show buyers/sellers)")
+            select_amc = gr.Dropdown(choices=AMCS, label="Select AMC (show inferred transfers)")
+        with gr.Column(scale=7):
+            network_plot = gr.Plot(value=initial_fig, label="Network graph (drag to zoom)")
+
+    company_out_plot = gr.Plot(label="Company trade summary")
+    company_out_table = gr.DataFrame(label="Trades (company)")
+    amc_out_plot = gr.Plot(label="AMC inferred transfers")
+    amc_out_table = gr.DataFrame(label="Inferred transfers (AMC)")
+
+    def update_network(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):
+        G = build_graph(include_transfers=include_transfers_val)
         fig = graph_to_plotly(G,
-            node_color_amc=colA,
-            node_color_company=colC,
-            edge_color_buy=buyC,
-            edge_color_sell=sellC,
-            edge_color_transfer=transC
-        )
+                              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)
         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]
-    )
+    def on_company_select(cname):
+        fig, df = company_trade_summary(cname)
+        if fig is None:
+            return None, pd.DataFrame([], columns=["Role","AMC"])
+        return fig, df
+
+    def on_amc_select(aname):
+        fig, df = amc_transfer_summary(aname)
+        if fig is None:
+            return None, pd.DataFrame([], columns=["security","buyer_amc"])
+        return fig, df
+
+    update_button.click(fn=update_network,
+                        inputs=[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],
+                        outputs=[network_plot])
+    select_company.change(fn=on_company_select, inputs=[select_company], outputs=[company_out_plot, company_out_table])
+    select_amc.change(fn=on_amc_select, inputs=[select_amc], outputs=[amc_out_plot, amc_out_table])
 
 if __name__ == "__main__":
-    demo.queue().launch()
+    demo.launch(server_name="0.0.0.0", server_port=7860)