Create app.py

app.py

@@ -0,0 +1,377 @@
+# app.py
+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, Counter
+
+# ---------------------------
+# Sample dataset (editable)
+# ---------------------------
+# 10 AMCs (from your table) and ~15 companies extracted earlier.
+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"
+]
+
+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"
+]
+
+# These are best-effort imputations from the newspaper table you provided.
+# BUY: AMC -> company
+BUY_MAP = {
+    "SBI MF": ["Bajaj Finance", "AU Small Finance Bank"],
+    "ICICI Pru MF": ["HDFC Bank", "NTPC"] if False else ["HDFC Bank"],  # NTPC not in COMPANIES list here
+    "HDFC MF": ["Tata Elxsi", "TCS"],
+    "Nippon India MF": ["Colgate-Palmolive (India)"] if False else ["Hindalco"],
+    "Kotak MF": ["Bajaj Finance", "Power Finance Corporation"] if False else ["Bajaj Finance"],
+    "UTI MF": ["Adani Ports", "Shriram Finance"],
+    "Axis MF": ["Tata Motors", "Shriram Finance"],
+    "Aditya Birla SL MF": ["AU Small Finance Bank", "Tata Steel"] if False else ["AU Small Finance Bank"],
+    "Mirae MF": ["Bajaj Finance", "HAL"],
+    "DSP MF": ["Tata Motors", "Bajaj Finserv"]
+}
+
+# SELL: AMC -> company
+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"]
+}
+
+# COMPLETE EXITs (one-way big exit)
+COMPLETE_EXIT = {
+    "DSP MF": ["Shriram Finance"],  # DSP completed exit of Shriram (example)
+}
+
+# FRESH_BUY (first time or notable fresh buy)
+FRESH_BUY = {
+    "HDFC MF": ["Tata Elxsi"],
+    "UTI MF": ["Adani Ports"],
+    "Mirae MF": ["HAL"]
+}
+
+# sanitize maps (remove any items not in COMPANIES)
+def sanitize_map(m):
+    out = {}
+    for k, vals in m.items():
+        out[k] = [v for v in vals if v in COMPANIES]
+    return out
+
+BUY_MAP = sanitize_map(BUY_MAP)
+SELL_MAP = sanitize_map(SELL_MAP)
+COMPLETE_EXIT = sanitize_map(COMPLETE_EXIT)
+FRESH_BUY = sanitize_map(FRESH_BUY)
+
+# Build edge lists (AMC -> company) with attributes
+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}))
+
+# Inferred AMC->AMC transfers: if AMC A sells company X and AMC B buys company X,
+# infer A -> B transfer (transfer volume increments with multiple shared tickers)
+def infer_amc_transfers(buy_map, sell_map):
+    transfers = defaultdict(int)
+    # for each company, find sellers and buyers
+    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:
+                # infer s -> b transfer for this company
+                transfers[(s,b)] += 1
+    # convert to list of edges
+    edge_list = []
+    for (s,b), w in transfers.items():
+        edge_list.append((s,b, {"action": "transfer", "weight": w, "company_count": w}))
+    return edge_list
+
+transfer_edges = infer_amc_transfers(BUY_MAP, SELL_MAP)
+
+# Combined graph builder
+def build_graph(include_transfers=True):
+    G = nx.DiGraph()
+    # add AMC nodes
+    for a in AMCS:
+        G.add_node(a, type="amc", label=a)
+    # add company nodes
+    for c in COMPANIES:
+        G.add_node(c, type="company", label=c)
+    # add company edges (amc->company)
+    for a, c, attrs in company_edges:
+        if not G.has_node(a) or not G.has_node(c):
+            continue
+        # use unique key if multiple edges to same target: accumulate weight
+        if G.has_edge(a,c):
+            G[a][c]["weight"] += attrs.get("weight",1)
+            G[a][c]["actions"].append(attrs["action"])
+        else:
+            G.add_edge(a, c, weight=attrs.get("weight",1), actions=[attrs["action"]])
+    # add transfers
+    if include_transfers:
+        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"] += attrs.get("weight",1)
+                G[s][b]["actions"].append("transfer")
+            else:
+                G.add_edge(s, b, weight=attrs.get("weight",1), actions=["transfer"])
+    return G
+
+# ---------------------------
+# Visualization helpers
+# ---------------------------
+def graph_to_plotly(G,
+                    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):
+    # Layout
+    pos = nx.spring_layout(G, seed=42, k=1.2)
+    # Build traces
+    node_x = []
+    node_y = []
+    node_text = []
+    node_color = []
+    node_size = []
+    marker_symbols = []
+    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)
+            marker_symbols.append(node_shape_amc)
+        else:
+            node_color.append(node_color_company)
+            node_size.append(60)
+            marker_symbols.append(node_shape_company)
+
+    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 (separate traces for buy, sell, transfers for color/thickness control)
+    edge_traces = []
+    for u, v, attrs in G.edges(data=True):
+        # get style by action mix - priority: complete_exit/fresh_buy > transfer > sell > buy
+        actions = attrs.get("actions",[])
+        weight = attrs.get("weight",1)
+        x0, y0 = pos[u]
+        x1, y1 = pos[v]
+        # choose color & dash & width
+        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:  # buy
+            color = edge_color_buy
+            dash = "solid"
+            width = max(edge_thickness_base * (1 + np.log1p(weight)), 1)
+        edge_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(edge_trace)
+
+    # Create figure
+    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=1000,
+                        width=1400,
+                    ))
+    return fig
+
+# ---------------------------
+# Analysis helpers (what user requested)
+# ---------------------------
+def company_trade_summary(company_name):
+    """Return a small bar chart / dataframe of who bought vs sold the given company."""
+    # build counts
+    buyers = []
+    sellers = []
+    for amc, comps in BUY_MAP.items():
+        if company_name in comps:
+            buyers.append(amc)
+    for amc, comps in SELL_MAP.items():
+        if company_name in comps:
+            sellers.append(amc)
+    # include complete exits and fresh buys
+    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 "No visible trades for this company in dataset."
+    # make simple counts bar chart
+    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=350, width=600)
+    return fig, df
+
+def amc_transfer_summary(amc_name):
+    """For a selected AMC, show which securities were sold to which other AMC (inferred)"""
+    # securities sold by this AMC
+    sold = SELL_MAP.get(amc_name, [])
+    # who bought those securities
+    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 "No inferred transfers for this AMC in dataset."
+    # return table and a simple count chart (buyers count)
+    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} (sold securities -> buyer AMCs)", height=350, width=600)
+    return fig, df
+
+# ---------------------------
+# Gradio UI
+# ---------------------------
+with gr.Blocks() as demo:
+    gr.Markdown("## Mutual Fund Churn explorer — interactive network + transfer analysis")
+    with gr.Row():
+        with gr.Column(scale=3):
+            # Graph controls
+            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 (yes = 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(label="Network graph (drag to zoom)")
+
+    # outputs for selections
+    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=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
+
+    def on_company_select(cname):
+        res = company_trade_summary(cname)
+        if isinstance(res, tuple):
+            fig, df = res
+            return fig, df
+        else:
+            return None, pd.DataFrame([], columns=["Role","AMC"])
+
+    def on_amc_select(aname):
+        res = amc_transfer_summary(aname)
+        if isinstance(res, tuple):
+            fig, df = res
+            return fig, df
+        else:
+            return None, pd.DataFrame([], columns=["security","buyer_amc"])
+
+    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])
+
+    # initial network
+    network_plot.update(value=update_network(node_color_company.value, node_color_amc.value,
+                                             node_shape_company.value, node_shape_amc.value,
+                                             edge_color_buy.value, edge_color_sell.value, edge_color_transfer.value,
+                                             edge_thickness.value, include_transfers.value))
+
+if __name__ == "__main__":
+    demo.launch()