Update app.py

app.py

@@ -2,7 +2,7 @@ import os
 import sys
 from datetime import datetime
 from pathlib import Path
-from typing import Tuple, Any, Dict, List
+from typing import Tuple, Any, List
 
 import duckdb
 import pandas as pd
@@ -18,8 +18,8 @@ from reportlab.pdfgen import canvas
 # Basic configuration
 # -------------------------------------------------------------------
 APP_TITLE = "ALCO Liquidity & Interest-Rate Risk Dashboard"
-TABLE_FQN = "my_db.main.masterdataset_v"   # <- your source
-VIEW_FQN = "my_db.main.positions_v"        # <- normalized view we create
+TABLE_FQN = "my_db.main.masterdataset_v"
+VIEW_FQN = "my_db.main.positions_v"
 EXPORT_DIR = Path("exports")
 EXPORT_DIR.mkdir(exist_ok=True)
 
@@ -32,35 +32,21 @@ def connect_md() -> duckdb.DuckDBPyConnection:
     if not token:
         raise RuntimeError("MOTHERDUCK_TOKEN is not set. Add it as a Space secret.")
     try:
-        conn = duckdb.connect(f"md:?motherduck_token={token}")
-        return conn
+        return duckdb.connect(f"md:?motherduck_token={token}")
     except Exception as e:
-        print("ERROR: Unable to connect to MotherDuck:", e, file=sys.stderr)
+        print("❌ Connection failed:", e, file=sys.stderr)
         raise
 
 
 # -------------------------------------------------------------------
-# Column discovery & dynamic SQL builders
+# Column discovery & dynamic SQL
 # -------------------------------------------------------------------
-WANTED_COLS = [
-    "as_of_date",
-    "product",
-    "months",
-    "segments",
-    "currency",
-    "Portfolio_value",
-    "Interest_rate",
-    "days_to_maturity",
+PRODUCT_ASSETS = [
+    "assets"
+]
+PRODUCT_SOF = [
+    "fd"
 ]
-
-PRODUCT_ASSETS = (
-    "loan", "overdraft", "advances", "bills", "bill", "tbond", "t-bond", "tbill",
-    "t-bill", "repo_asset", "assets"
-)
-PRODUCT_SOF = (
-    "fd", "term_deposit", "td", "savings", "current", "call", "repo_liab"
-)
-
 
 def discover_columns(conn: duckdb.DuckDBPyConnection, table_fqn: str) -> List[str]:
     q = f"""
@@ -70,265 +56,46 @@ def discover_columns(conn: duckdb.DuckDBPyConnection, table_fqn: str) -> List[st
       AND table_name   = split_part('{table_fqn}', '.', 3)
     """
     df = conn.execute(q).fetchdf()
-    return [c for c in df["col"].tolist()]
+    return df["col"].tolist()
 
 
 def build_view_sql(existing_cols: List[str]) -> str:
-    # Build a SELECT list that only references columns that exist; others are NULLs.
-    parts = []
-    for c in WANTED_COLS:
+    wanted = [
+        "as_of_date", "product", "months", "segments",
+        "currency", "Portfolio_value", "Interest_rate",
+        "days_to_maturity"
+    ]
+    select_list = []
+    for c in wanted:
         if c.lower() in existing_cols:
-            parts.append(c)
+            select_list.append(c)
         else:
-            # use sensible defaults for types
             if c in ("Portfolio_value", "Interest_rate", "days_to_maturity", "months"):
-                parts.append(f"CAST(NULL AS DOUBLE) AS {c}")
+                select_list.append(f"CAST(NULL AS DOUBLE) AS {c}")
             else:
-                parts.append(f"CAST(NULL AS VARCHAR) AS {c}")
+                select_list.append(f"CAST(NULL AS VARCHAR) AS {c}")
+
+    sof_list = ", ".join([f"'{p}'" for p in PRODUCT_SOF])
+    asset_list = ", ".join([f"'{p}'" for p in PRODUCT_ASSETS])
 
-    # Add bucket derived from product (which must exist; we hard-require product & Portfolio_value & days_to_maturity)
-    # If 'product' doesn't exist, the app can't work; guard above (we will assert later).
     bucket_case = (
-        "CASE "
-        f"WHEN lower(product) IN ({','.join([f\"'{p}'\" for p in PRODUCT_SOF])}) THEN 'SoF' "
-        f"WHEN lower(product) IN ({','.join([f\"'{p}'\" for p in PRODUCT_ASSETS])}) THEN 'Assets' "
-        "ELSE 'Unknown' END AS bucket"
+        f"CASE "
+        f"WHEN lower(product) IN ({sof_list}) THEN 'SoF' "
+        f"WHEN lower(product) IN ({asset_list}) THEN 'Assets' "
+        f"ELSE 'Unknown' END AS bucket"
     )
 
-    select_list = ",\n  ".join(parts + [bucket_case])
+    select_sql = ",\n  ".join(select_list + [bucket_case])
     return f"""
     CREATE OR REPLACE VIEW {VIEW_FQN} AS
     SELECT
-      {select_list}
+      {select_sql}
     FROM {TABLE_FQN};
     """
 
 
-def make_max_date_sql(has_asof: bool) -> str:
-    if not has_asof:
-        # No as_of_date column -> return N/A row
-        return "SELECT 'N/A'::VARCHAR AS d;"
-    return f"WITH maxd AS (SELECT max(as_of_date) AS d FROM {VIEW_FQN}) SELECT d FROM maxd;"
-
-
-def wrap_latest_date(sql_body: str, has_asof: bool) -> str:
-    """
-    If as_of_date exists, pin to latest date using a CTE and JOIN.
-    Otherwise, return the body directly from VIEW_FQN (no date pinning).
-    The sql_body must reference the view as 'p'.
-    """
-    if not has_asof:
-        # Remove any JOIN to maxd; just select from the view
-        return f"SELECT * FROM ({sql_body})"
-    else:
-        return f"SELECT * FROM ({sql_body})"
-
-
-def build_kpi_sql(has_asof: bool) -> str:
-    if has_asof:
-        return f"""
-        WITH maxd AS (SELECT max(as_of_date) AS d FROM {VIEW_FQN}),
-        t1 AS (
-          SELECT p.bucket, SUM(p.Portfolio_value) AS amt
-          FROM {VIEW_FQN} p
-          JOIN maxd m ON p.as_of_date = m.d
-          WHERE p.days_to_maturity <= 1
-          GROUP BY p.bucket
-        )
-        SELECT
-          COALESCE(SUM(CASE WHEN bucket='Assets' THEN amt END),0) AS assets_t1,
-          COALESCE(SUM(CASE WHEN bucket='SoF'    THEN amt END),0) AS sof_t1,
-          COALESCE(SUM(CASE WHEN bucket='Assets' THEN amt END),0)
-          - COALESCE(SUM(CASE WHEN bucket='SoF'  THEN amt END),0) AS net_gap_t1
-        FROM t1;
-        """
-    else:
-        return f"""
-        WITH t1 AS (
-          SELECT p.bucket, SUM(p.Portfolio_value) AS amt
-          FROM {VIEW_FQN} p
-          WHERE p.days_to_maturity <= 1
-          GROUP BY p.bucket
-        )
-        SELECT
-          COALESCE(SUM(CASE WHEN bucket='Assets' THEN amt END),0) AS assets_t1,
-          COALESCE(SUM(CASE WHEN bucket='SoF'    THEN amt END),0) AS sof_t1,
-          COALESCE(SUM(CASE WHEN bucket='Assets' THEN amt END),0)
-          - COALESCE(SUM(CASE WHEN bucket='SoF'  THEN amt END),0) AS net_gap_t1
-        FROM t1;
-        """
-
-
-def build_ladder_sql(has_asof: bool) -> str:
-    if has_asof:
-        return f"""
-        WITH maxd AS (SELECT max(as_of_date) AS d FROM {VIEW_FQN})
-        SELECT
-          CASE
-            WHEN p.days_to_maturity <= 1 THEN 'T+1'
-            WHEN p.days_to_maturity BETWEEN 2 AND 7  THEN 'T+2..7'
-            WHEN p.days_to_maturity BETWEEN 8 AND 30 THEN 'T+8..30'
-            ELSE 'T+31+'
-          END AS time_bucket,
-          p.bucket,
-          SUM(p.Portfolio_value) AS amount
-        FROM {VIEW_FQN} p
-        JOIN maxd m ON p.as_of_date = m.d
-        GROUP BY 1,2
-        ORDER BY CASE time_bucket WHEN 'T+1' THEN 1 WHEN 'T+2..7' THEN 2 WHEN 'T+8..30' THEN 3 ELSE 4 END, p.bucket;
-        """
-    else:
-        return f"""
-        SELECT
-          CASE
-            WHEN p.days_to_maturity <= 1 THEN 'T+1'
-            WHEN p.days_to_maturity BETWEEN 2 AND 7  THEN 'T+2..7'
-            WHEN p.days_to_maturity BETWEEN 8 AND 30 THEN 'T+8..30'
-            ELSE 'T+31+'
-          END AS time_bucket,
-          p.bucket,
-          SUM(p.Portfolio_value) AS amount
-        FROM {VIEW_FQN} p
-        GROUP BY 1,2
-        ORDER BY CASE time_bucket WHEN 'T+1' THEN 1 WHEN 'T+2..7' THEN 2 WHEN 'T+8..30' THEN 3 ELSE 4 END, p.bucket;
-        """
-
-
-def build_t1_group_sql(group_col: str, has_asof: bool) -> str:
-    if has_asof:
-        return f"""
-        WITH maxd AS (SELECT max(as_of_date) AS d FROM {VIEW_FQN})
-        SELECT p.bucket, p.{group_col} AS grp, SUM(p.Portfolio_value) AS amount
-        FROM {VIEW_FQN} p
-        JOIN maxd m ON p.as_of_date = m.d
-        WHERE p.days_to_maturity <= 1
-        GROUP BY 1,2
-        ORDER BY p.bucket, amount DESC
-        LIMIT 50;
-        """
-    else:
-        return f"""
-        SELECT p.bucket, p.{group_col} AS grp, SUM(p.Portfolio_value) AS amount
-        FROM {VIEW_FQN} p
-        WHERE p.days_to_maturity <= 1
-        GROUP BY 1,2
-        ORDER BY p.bucket, amount DESC
-        LIMIT 50;
-        """
-
-
-def build_irr_sql(has_asof: bool, has_months: bool, has_ir: bool) -> str:
-    # T_years uses days_to_maturity OR months (if present). y uses Interest_rate (if present).
-    t_years_expr = "CASE WHEN p.days_to_maturity IS NOT NULL THEN p.days_to_maturity/365.0"
-    if has_months:
-        t_years_expr += " WHEN p.months IS NOT NULL THEN p.months/12.0"
-    t_years_expr += " ELSE NULL END"
-
-    y_expr = "(p.Interest_rate / 100.0)" if has_ir else "NULL"
-
-    if has_asof:
-        base_from = f"FROM {VIEW_FQN} p JOIN maxd m ON p.as_of_date = m.d"
-        max_cte = f"WITH maxd AS (SELECT max(as_of_date) AS d FROM {VIEW_FQN}),"
-    else:
-        base_from = f"FROM {VIEW_FQN} p"
-        max_cte = "WITH"
-
-    return f"""
-{max_cte}
-base AS (
-  SELECT
-    p.bucket,
-    p.Portfolio_value AS pv,
-    {y_expr} AS y,
-    {t_years_expr} AS T_years
-  {base_from}
-  WHERE p.Portfolio_value IS NOT NULL
-),
-metrics AS (
-  SELECT
-    bucket,
-    pv,
-    CASE WHEN T_years IS NULL THEN NULL
-         WHEN y IS NULL THEN T_years
-         ELSE T_years/(1.0+y) END AS dur_mod,
-    CASE WHEN T_years IS NULL THEN NULL
-         WHEN y IS NULL THEN T_years*(T_years+1.0)
-         ELSE (T_years*(T_years+1.0))/POWER(1.0+y,2) END AS convexity_approx,
-    CASE WHEN T_years IS NULL THEN NULL
-         ELSE pv * (CASE WHEN y IS NULL THEN T_years ELSE T_years/(1.0+y) END) * 0.0001 END AS dv01
-  FROM base
-),
-agg AS (
-  SELECT
-    bucket,
-    SUM(pv) AS pv_sum,
-    SUM(pv * dur_mod) / NULLIF(SUM(pv),0) AS dur_mod_port,
-    SUM(dv01) AS dv01_sum
-  FROM metrics
-  GROUP BY bucket
-)
-SELECT
-  COALESCE(MAX(CASE WHEN bucket='Assets' THEN pv_sum END),0) AS assets_pv,
-  COALESCE(MAX(CASE WHEN bucket='SoF' THEN pv_sum END),0) AS sof_pv,
-  COALESCE(MAX(CASE WHEN bucket='Assets' THEN dur_mod_port END),0) AS assets_dur_mod,
-  COALESCE(MAX(CASE WHEN bucket='SoF' THEN dur_mod_port END),0) AS sof_dur_mod,
-  COALESCE(MAX(CASE WHEN bucket='Assets' THEN dur_mod_port END),0)
-  - COALESCE(MAX(CASE WHEN bucket='SoF' THEN dur_mod_port END),0) AS duration_gap,
-  COALESCE(MAX(CASE WHEN bucket='Assets' THEN dv01_sum END),0)
-  - COALESCE(MAX(CASE WHEN bucket='SoF' THEN dv01_sum END),0) AS net_dv01;
-    """
-
-
-def build_shock_sql(has_asof: bool, has_months: bool, has_ir: bool) -> str:
-    t_years_expr = "CASE WHEN p.days_to_maturity IS NOT NULL THEN p.days_to_maturity/365.0"
-    if has_months:
-        t_years_expr += " WHEN p.months IS NOT NULL THEN p.months/12.0"
-    t_years_expr += " ELSE NULL END"
-
-    y_expr = "(p.Interest_rate / 100.0)" if has_ir else "NULL"
-
-    if has_asof:
-        base_from = f"FROM {VIEW_FQN} p JOIN maxd m ON p.as_of_date = m.d"
-        max_cte = f"WITH maxd AS (SELECT max(as_of_date) AS d FROM {VIEW_FQN}),"
-    else:
-        base_from = f"FROM {VIEW_FQN} p"
-        max_cte = "WITH"
-
-    return f"""
-{max_cte}
-base AS (
-  SELECT
-    p.bucket,
-    p.Portfolio_value AS pv,
-    {y_expr} AS y,
-    {t_years_expr} AS T_years
-  {base_from}
-),
-k AS (
-  SELECT
-    bucket, pv,
-    CASE WHEN T_years IS NULL THEN NULL
-         WHEN y IS NULL THEN T_years
-         ELSE T_years/(1.0+y) END AS dur_mod,
-    CASE WHEN T_years IS NULL THEN NULL
-         WHEN y IS NULL THEN T_years*(T_years+1.0)
-         ELSE (T_years*(T_years+1.0))/POWER(1.0+y,2) END AS convexity_approx
-  FROM base
-),
-shock AS (
-  SELECT
-    bucket,
-    SUM((- pv * dur_mod * 0.01) + (0.5 * pv * convexity_approx * POWER(0.01,2))) AS dPV_up_100bp,
-    SUM((+ pv * dur_mod * 0.01) + (0.5 * pv * convexity_approx * POWER(-0.01,2))) AS dPV_dn_100bp
-  FROM k
-  GROUP BY bucket
-)
-SELECT * FROM shock ORDER BY bucket;
-    """
-
-
 # -------------------------------------------------------------------
-# Data class
+# Data model
 # -------------------------------------------------------------------
 class DashboardResult(BaseModel):
     as_of_date: str
@@ -336,100 +103,100 @@ class DashboardResult(BaseModel):
     sof_t1: float
     net_gap_t1: float
     ladder: pd.DataFrame
-    t1_by_month: pd.DataFrame
-    t1_by_segment: pd.DataFrame
-    t1_by_ccy: pd.DataFrame
     irr: pd.DataFrame
-    shocks: pd.DataFrame
 
 
 # -------------------------------------------------------------------
-# Query helpers
+# Core logic
 # -------------------------------------------------------------------
-def ensure_view(conn: duckdb.DuckDBPyConnection, existing_cols: List[str]) -> None:
-    # sanity: ensure mandatory columns exist in source table
-    mandatory = {"product", "portfolio_value", "days_to_maturity"}
-    if not mandatory.issubset(set(existing_cols)):
-        raise RuntimeError(
-            f"Source table {TABLE_FQN} must contain {mandatory}, "
-            f"found only: {existing_cols}"
-        )
-    conn.execute(build_view_sql(existing_cols))
+def ensure_view(conn: duckdb.DuckDBPyConnection, existing_cols: List[str]):
+    if not {"product", "portfolio_value", "days_to_maturity"}.issubset(set(existing_cols)):
+        raise RuntimeError("Missing required columns in source table.")
+    sql = build_view_sql(existing_cols)
+    conn.execute(sql)
 
 
 def fetch_all(conn: duckdb.DuckDBPyConnection) -> DashboardResult:
-    existing = discover_columns(conn, TABLE_FQN)
-    ensure_view(conn, existing)
-
-    has_asof = "as_of_date" in existing
-    has_months = "months" in existing
-    has_segments = "segments" in existing
-    has_currency = "currency" in existing
-    has_ir = "interest_rate" in existing
-
-    # As-of date (or N/A)
-    asof_df = conn.execute(make_max_date_sql(has_asof)).fetchdf()
-    as_of = asof_df["d"].iloc[0]
-    as_of_str = (
-        pd.to_datetime(as_of).strftime("%Y-%m-%d")
-        if has_asof and not pd.isna(as_of)
-        else "N/A"
-    )
+    cols = discover_columns(conn, TABLE_FQN)
+    ensure_view(conn, cols)
+    has_asof = "as_of_date" in cols
+    has_ir = "interest_rate" in cols
+    has_months = "months" in cols
+
+    # As-of date
+    as_of_date = "N/A"
+    if has_asof:
+        asof_df = conn.execute(f"SELECT max(as_of_date) AS d FROM {VIEW_FQN}").fetchdf()
+        if not asof_df.empty and not pd.isna(asof_df["d"].iloc[0]):
+            as_of_date = str(asof_df["d"].iloc[0])[:10]
 
-    # KPIs & ladder
-    kpis = conn.execute(build_kpi_sql(has_asof)).fetchdf()
-    ladder = conn.execute(build_ladder_sql(has_asof)).fetchdf()
+    # KPIs
+    kpi_sql = f"""
+    SELECT
+      COALESCE(SUM(CASE WHEN bucket='Assets' AND days_to_maturity<=1 THEN Portfolio_value END),0) AS assets_t1,
+      COALESCE(SUM(CASE WHEN bucket='SoF'    AND days_to_maturity<=1 THEN Portfolio_value END),0) AS sof_t1,
+      COALESCE(SUM(CASE WHEN bucket='Assets' AND days_to_maturity<=1 THEN Portfolio_value END),0)
+      - COALESCE(SUM(CASE WHEN bucket='SoF'  AND days_to_maturity<=1 THEN Portfolio_value END),0) AS net_gap_t1
+    FROM {VIEW_FQN};
+    """
+    kpi = conn.execute(kpi_sql).fetchdf()
+
+    # Ladder
+    ladder_sql = f"""
+    SELECT
+      CASE
+        WHEN days_to_maturity <= 1 THEN 'T+1'
+        WHEN days_to_maturity BETWEEN 2 AND 7 THEN 'T+2..7'
+        WHEN days_to_maturity BETWEEN 8 AND 30 THEN 'T+8..30'
+        ELSE 'T+31+'
+      END AS time_bucket,
+      bucket,
+      SUM(Portfolio_value) AS amount
+    FROM {VIEW_FQN}
+    GROUP BY 1,2
+    ORDER BY 1,2;
+    """
+    ladder = conn.execute(ladder_sql).fetchdf()
 
-    # Contributors (only if columns exist)
+    # IRR simplified
+    t_expr = "CASE WHEN days_to_maturity IS NOT NULL THEN days_to_maturity/365.0"
     if has_months:
-        t1_m = conn.execute(build_t1_group_sql("months", has_asof)).fetchdf()
-        t1_m = t1_m.rename(columns={"grp": "months"})
-    else:
-        t1_m = pd.DataFrame(columns=["bucket", "months", "amount"])
-
-    if has_segments:
-        t1_s = conn.execute(build_t1_group_sql("segments", has_asof)).fetchdf()
-        t1_s = t1_s.rename(columns={"grp": "segments"})
-    else:
-        t1_s = pd.DataFrame(columns=["bucket", "segments", "amount"])
-
-    if has_currency:
-        t1_c = conn.execute(build_t1_group_sql("currency", has_asof)).fetchdf()
-        t1_c = t1_c.rename(columns={"grp": "currency"})
-    else:
-        t1_c = pd.DataFrame(columns=["bucket", "currency", "amount"])
-
-    # IRR & shocks (works even if Interest_rate/months are missing)
-    irr = conn.execute(build_irr_sql(has_asof, has_months, has_ir)).fetchdf()
-    shocks = conn.execute(build_shock_sql(has_asof, has_months, has_ir)).fetchdf()
+        t_expr += " WHEN months IS NOT NULL THEN months/12.0"
+    t_expr += " ELSE NULL END"
+    y_expr = "(Interest_rate/100.0)" if has_ir else "NULL"
+
+    irr_sql = f"""
+    SELECT
+      bucket,
+      SUM(Portfolio_value) AS pv_sum,
+      SUM(Portfolio_value * {t_expr}) / NULLIF(SUM(Portfolio_value),0) AS dur_mac,
+      SUM(Portfolio_value * ({t_expr})/(1+COALESCE({y_expr},0))) / NULLIF(SUM(Portfolio_value),0) AS dur_mod
+    FROM {VIEW_FQN}
+    GROUP BY bucket;
+    """
+    irr = conn.execute(irr_sql).fetchdf()
 
     return DashboardResult(
-        as_of_date=as_of_str,
-        assets_t1=float(kpis["assets_t1"].iloc[0]),
-        sof_t1=float(kpis["sof_t1"].iloc[0]),
-        net_gap_t1=float(kpis["net_gap_t1"].iloc[0]),
+        as_of_date=as_of_date,
+        assets_t1=float(kpi["assets_t1"].iloc[0]),
+        sof_t1=float(kpi["sof_t1"].iloc[0]),
+        net_gap_t1=float(kpi["net_gap_t1"].iloc[0]),
         ladder=ladder,
-        t1_by_month=t1_m,
-        t1_by_segment=t1_s,
-        t1_by_ccy=t1_c,
         irr=irr,
-        shocks=shocks,
     )
 
 
 # -------------------------------------------------------------------
-# Plotting
+# Visualization
 # -------------------------------------------------------------------
 def plot_ladder(df: pd.DataFrame):
     pivot = df.pivot(index="time_bucket", columns="bucket", values="amount").fillna(0)
     order = ["T+1", "T+2..7", "T+8..30", "T+31+"]
     pivot = pivot.reindex(order)
     fig, ax = plt.subplots(figsize=(7, 4))
-    assets = pivot.get("Assets", pd.Series([0] * len(pivot), index=pivot.index))
-    sof = pivot.get("SoF", pd.Series([0] * len(pivot), index=pivot.index))
-    ax.bar(pivot.index, assets, label="Assets")
-    ax.bar(pivot.index, -sof, bottom=0, label="SoF")
-    ax.axhline(0, linewidth=1)
+    ax.bar(pivot.index, pivot.get("Assets", 0), label="Assets")
+    ax.bar(pivot.index, -pivot.get("SoF", 0), label="SoF")
+    ax.axhline(0, color="gray", lw=1)
     ax.set_ylabel("LKR")
     ax.set_title("Maturity Ladder (Assets vs SoF)")
     ax.legend()
@@ -450,123 +217,51 @@ def export_excel(res: DashboardResult) -> Path:
             "net_gap_t1": [res.net_gap_t1],
         }).to_excel(xw, index=False, sheet_name="kpis")
         res.ladder.to_excel(xw, index=False, sheet_name="ladder")
-        res.t1_by_month.to_excel(xw, index=False, sheet_name="t1_by_month")
-        res.t1_by_segment.to_excel(xw, index=False, sheet_name="t1_by_segment")
-        res.t1_by_ccy.to_excel(xw, index=False, sheet_name="t1_by_ccy")
         res.irr.to_excel(xw, index=False, sheet_name="irr")
-        res.shocks.to_excel(xw, index=False, sheet_name="shocks")
-    return out
-
-
-def export_pdf(res: DashboardResult) -> Path:
-    out = EXPORT_DIR / f"alco_report_{res.as_of_date}.pdf"
-    c = canvas.Canvas(str(out), pagesize=A4)
-    W, H = A4
-    y = H - 20 * mm
-
-    def line(txt, size=11, dy=6 * mm):
-        nonlocal y
-        c.setFont("Helvetica", size)
-        c.drawString(20 * mm, y, txt)
-        y -= dy
-
-    line(APP_TITLE, 14, dy=8 * mm)
-    line(f"As of: {res.as_of_date}")
-    line(f"Assets T+1: {res.assets_t1:,.0f} LKR")
-    line(f"SoF T+1: {res.sof_t1:,.0f} LKR")
-    line(f"Net Gap T+1: {res.net_gap_t1:,.0f} LKR  (negative = shortfall)")
-    y -= 4 * mm
-
-    if not res.irr.empty:
-        irr = res.irr.iloc[0]
-        line("Interest-Rate Risk (approx)", 12, dy=7 * mm)
-        line(f"Assets ModDur: {irr['assets_dur_mod']:.2f}  |  SoF ModDur: {irr['sof_dur_mod']:.2f}")
-        line(f"Duration Gap: {irr['duration_gap']:.2f}")
-        line(f"Net DV01: {irr['net_dv01']:,.0f} LKR/bp")
-
-    if not res.shocks.empty:
-        net_up = res.shocks["dPV_up_100bp"].sum()
-        net_dn = res.shocks["dPV_dn_100bp"].sum()
-        y -= 2 * mm
-        line(f"+100bp net ΔPV: {net_up:,.0f} LKR  |  -100bp net ΔPV: {net_dn:,.0f} LKR")
-
-    c.showPage()
-    c.save()
     return out
 
 
 # -------------------------------------------------------------------
 # Gradio UI
 # -------------------------------------------------------------------
-def run_dashboard() -> Tuple[str, float, float, float, Any, Any, Any, Any, Any, Any, Any]:
+def run_dashboard():
     conn = connect_md()
     res = fetch_all(conn)
     fig = plot_ladder(res.ladder)
     excel_path = export_excel(res)
-    pdf_path = export_pdf(res)
     return (
         res.as_of_date,
         res.assets_t1,
         res.sof_t1,
         res.net_gap_t1,
         fig,
-        res.t1_by_month,
-        res.t1_by_segment,
-        res.t1_by_ccy,
+        res.ladder,
         res.irr,
-        res.shocks,
         str(excel_path),
-        str(pdf_path),
     )
 
 
 with gr.Blocks(title=APP_TITLE) as demo:
-    gr.Markdown(
-        f"# {APP_TITLE}\n"
-        "*Source:* `my_db.main.masterdataset_v` → `positions_v`  |  *Sign:* Assets=+  SoF=–"
-    )
+    gr.Markdown(f"# {APP_TITLE}\n_Source:_ `{TABLE_FQN}` → `{VIEW_FQN}`")
 
     with gr.Row():
-        btn = gr.Button("🔄 Refresh", variant="primary")
+        refresh_btn = gr.Button("🔄 Refresh", variant="primary")
 
     with gr.Row():
         as_of = gr.Textbox(label="As of date", interactive=False)
-
     with gr.Row():
-        k1 = gr.Number(label="Assets T+1 (LKR)", precision=0)
-        k2 = gr.Number(label="SoF T+1 (LKR)", precision=0)
-        k3 = gr.Number(label="Net Gap T+1 (LKR)", precision=0)
+        a1 = gr.Number(label="Assets T+1 (LKR)", precision=0)
+        a2 = gr.Number(label="SoF T+1 (LKR)", precision=0)
+        a3 = gr.Number(label="Net Gap T+1 (LKR)", precision=0)
 
     chart = gr.Plot(label="Maturity Ladder")
+    ladder_df = gr.Dataframe(label="Ladder Detail")
+    irr_df = gr.Dataframe(label="Interest-Rate Risk (approx)")
+    excel_file = gr.File(label="Excel export", interactive=False)
 
-    with gr.Row():
-        t1m = gr.Dataframe(label="T+1 by Tenor (months)")
-        t1s = gr.Dataframe(label="T+1 by Segment")
-
-    t1c = gr.Dataframe(label="T+1 by Currency")
-    irr = gr.Dataframe(label="Interest-Rate Risk (bucketed)")
-    shocks = gr.Dataframe(label="Parallel Shock ±100bp (bucketed)")
-
-    with gr.Row():
-        excel_file = gr.File(label="Excel export", interactive=False)
-        pdf_file = gr.File(label="PDF export", interactive=False)
-
-    btn.click(
+    refresh_btn.click(
         fn=run_dashboard,
-        outputs=[
-            as_of,
-            k1,
-            k2,
-            k3,
-            chart,
-            t1m,
-            t1s,
-            t1c,
-            irr,
-            shocks,
-            excel_file,
-            pdf_file,
-        ],
+        outputs=[as_of, a1, a2, a3, chart, ladder_df, irr_df, excel_file],
     )
 
 if __name__ == "__main__":