Upload app.py

app.py

@@ -0,0 +1,493 @@
+"""AlphaForge Live Dashboard — Gradio-based real-time monitoring.
+
+Tabs: Overview | Portfolio | Risk | Sentiment | Signals | Logs
+Pattern: gr.Timer(5) + @gr.on(triggers=[demo.load, timer.tick])
+"""
+import gradio as gr
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import pandas as pd
+import numpy as np
+import json
+import time
+import random
+import threading
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple
+
+# ── Dark theme ───────────────────────────────────────────────────────────────
+DARK = {
+    "bg": "#0a0e17", "card": "#111827", "accent": "#38bdf8",
+    "green": "#10b981", "red": "#ef4444", "yellow": "#f59e0b",
+    "text": "#94a3b8", "text_bright": "#e2e8f0", "border": "#1e293b",
+}
+
+PLOTLY_TEMPLATE = "plotly_dark"
+PLOTLY_LAYOUT = dict(
+    template=PLOTLY_TEMPLATE, paper_bgcolor=DARK["bg"], plot_bgcolor=DARK["bg"],
+    font=dict(color=DARK["text"], size=11), hovermode="x unified",
+    margin=dict(l=8, r=24, t=32, b=8), height=340,
+)
+
+# ── Data Store ───────────────────────────────────────────────────────────────
+
+class DashboardDataStore:
+    """Thread-safe data store for the dashboard."""
+
+    def __init__(self):
+        self._lock = threading.Lock()
+        self.reset()
+
+    def reset(self):
+        with self._lock:
+            self.pnl = []
+            self.dates = []
+            self.returns = []
+            self.weights = {}
+            self.positions = {}
+            self.alerts = deque(maxlen=50)
+            self.regime = "neutral"
+            self.sharpe = 0.0
+            self.vol = 0.0
+            self.max_dd = 0.0
+            self.var_95 = 0.0
+            self.sortino = 0.0
+            self.calmar = 0.0
+            self.current_drawdown = 0.0
+            self.alpha = 0.0
+            self.beta = 0.0
+            self.turnover = 0.0
+            self.sentiment_scores = {}
+            self.feature_importance = {}
+            self.ic_history = []
+            self.regime_probs = {}
+
+    def update_metrics(self, metrics: Dict):
+        with self._lock:
+            for k, v in metrics.items():
+                if hasattr(self, k):
+                    setattr(self, k, v)
+
+    def update_pnl(self, date: datetime, pnl_value: float, ret: float):
+        with self._lock:
+            self.dates.append(date)
+            self.pnl.append(pnl_value)
+
+    def add_alert(self, level: str, title: str, text: str):
+        with self._lock:
+            self.alerts.append({
+                "time": datetime.now().strftime("%H:%M:%S"),
+                "level": level, "title": title, "text": text
+            })
+
+    def snapshot(self) -> Dict:
+        with self._lock:
+            return {
+                "pnl": list(self.pnl), "dates": [str(d) for d in self.dates],
+                "returns": list(self.returns), "regime": self.regime,
+                "sharpe": self.sharpe, "vol": self.vol, "max_dd": self.max_dd,
+                "var_95": self.var_95, "sortino": self.sortino, "calmar": self.calmar,
+                "current_drawdown": self.current_drawdown,
+                "alpha": self.alpha, "beta": self.beta, "turnover": self.turnover,
+                "positions": self.positions, "sentiment_scores": self.sentiment_scores,
+                "feature_importance": self.feature_importance,
+                "ic_history": list(self.ic_history),
+                "regime_probs": self.regime_probs,
+                "alerts": list(self.alerts),
+            }
+
+_store = DashboardDataStore()
+
+# ── Synthetic Data Generator ─────────────────────────────────────────────────
+
+def _generate_synthetic_run():
+    """Generate realistic synthetic data for demo purposes."""
+    np.random.seed(42)
+    n_days = 252
+    dates = pd.bdate_range(start="2024-01-01", periods=n_days)
+    # Correlated returns
+    daily_mean = 0.0008
+    daily_vol = 0.012
+    returns = np.random.normal(daily_mean, daily_vol, n_days)
+    # Add a drawdown period
+    returns[100:140] = np.random.normal(-0.003, 0.02, 40)
+    # Add recovery
+    returns[140:180] = np.random.normal(0.0025, 0.012, 40)
+    pnl = np.cumsum(returns) * 1_000_000  # scale to $1M
+
+    # Compute metrics
+    cumulative = np.cumprod(1 + returns)
+    running_max = np.maximum.accumulate(cumulative)
+    drawdowns = (cumulative - running_max) / running_max
+
+    sharpe = np.mean(returns) / np.std(returns) * np.sqrt(252)
+    vol = np.std(returns) * np.sqrt(252)
+    max_dd = np.min(drawdowns)
+    sortino = np.mean(returns) / (np.std(returns[returns < 0]) + 1e-8) * np.sqrt(252)
+    var_95 = -np.percentile(returns, 5) * 1_000_000
+
+    # Store
+    _store.reset()
+    for i, d in enumerate(dates):
+        _store.update_pnl(d.to_pydatetime(), pnl[i], returns[i])
+
+    _store.update_metrics({
+        "sharpe": sharpe, "vol": vol, "max_dd": max_dd, "var_95": var_95,
+        "sortino": sortino, "calmar": np.mean(returns) * 252 / abs(max_dd),
+        "current_drawdown": drawdowns[-1], "alpha": 0.12, "beta": 0.95, "turnover": 0.15,
+    })
+
+    # Positions
+    _store.positions = {
+        "SPY": 0.18, "QQQ": 0.15, "AAPL": 0.10, "MSFT": 0.12, "GOOGL": 0.08,
+        "AMZN": 0.07, "META": 0.06, "NVDA": 0.14, "TSLA": 0.05, "JPM": 0.05,
+    }
+    _store.sentiment_scores = {"AAPL": 0.72, "MSFT": 0.65, "NVDA": 0.88, "TSLA": -0.34, "SPY": 0.15}
+    _store.feature_importance = {
+        "micro_amihud_illiquidity": 0.08, "macro_vix_level": 0.07, "ta_supertrend_dist": 0.06,
+        "return_5d": 0.05, "cs_mom_63d": 0.05, "vol_regime_21d": 0.04, "regime_composite": 0.04,
+        "ta_ichimoku_tk_cross": 0.04, "mr_signal": 0.03, "rvol_21d": 0.03,
+        "yc_spread": 0.03, "volume_delta": 0.03, "sma_20d": 0.02, "macro_credit_spread": 0.02,
+        "kyle_lambda": 0.02, "ta_keltner_position": 0.02, "cs_skew": 0.02, "trend_63d": 0.02,
+        "vix_regime": 0.02, "return_21d": 0.01,
+    }
+    _store.regime_probs = {"bull": 0.45, "bear": 0.12, "high_vol": 0.28, "neutral": 0.15}
+    _store.regime = "bull"
+    _store.ic_history = [0.05 + np.random.normal(0, 0.02) for _ in range(60)]
+
+    # Alerts
+    _store.add_alert("info", "Backtest Complete", "Sharpe: 1.82, Max DD: -4.3%")
+    _store.add_alert("warn", "Volatility Spike", "VIX at 28.5, reducing exposure to 80%")
+    _store.add_alert("info", "Regime Change", "Switched from neutral to bull — increasing equity allocation")
+
+# ── Chart Builders ───────────────────────────────────────────────────────────
+
+def build_pnl_chart() -> str:
+    """Build PnL + Drawdown overlay chart."""
+    snap = _store.snapshot()
+    if not snap["pnl"]:
+        return "<div style='color:#64748b;text-align:center;padding:60px'>No PnL data yet</div>"
+
+    df = pd.DataFrame({"date": pd.to_datetime(snap["dates"]), "pnl": snap["pnl"]})
+    cumulative = np.cumprod(1 + np.array(snap["returns"]))
+    running_max = np.maximum.accumulate(cumulative)
+    dd = (cumulative - running_max) / running_max
+
+    fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.03,
+                         row_heights=[0.7, 0.3], subplot_titles=["Cumulative PnL", "Drawdown"])
+
+    # PnL
+    fig.add_trace(go.Scatter(
+        x=df["date"], y=df["pnl"], name="PnL",
+        line=dict(color=DARK["accent"], width=2.2),
+        fill="tozeroy", fillcolor="rgba(56,189,248,0.08)",
+    ), row=1, col=1)
+    # Underwater marker
+    fig.add_trace(go.Scatter(
+        x=df["date"], y=np.full(len(df), 0),
+        line=dict(color=DARK["green"], width=1, dash="dot"), name="Breakeven",
+    ), row=1, col=1)
+
+    # Drawdown
+    fig.add_trace(go.Scatter(
+        x=df["date"], y=dd * 100, name="Drawdown %",
+        line=dict(color=DARK["red"], width=1.5),
+        fill="tozeroy", fillcolor="rgba(239,68,68,0.08)",
+    ), row=2, col=1)
+
+    fig.update_layout(**PLOTLY_LAYOUT, height=440, showlegend=False,
+        yaxis=dict(title="$", tickprefix="$", tickformat=",.0f"),
+        yaxis2=dict(title="%", ticksuffix="%"),
+    )
+    return fig.to_html(include_plotlyjs="cdn", full_html=False,
+                        config={"responsive": True, "displayModeBar": False})
+
+
+def build_risk_chart() -> str:
+    """Build rolling risk metrics chart."""
+    snap = _store.snapshot()
+    if not snap["returns"]:
+        return "<div style='color:#64748b;text-align:center;padding:60px'>No data</div>"
+
+    rets = np.array(snap["returns"])
+    dates = pd.to_datetime(snap["dates"])
+    w = min(21, len(rets) // 4)
+    rolling_sharpe = pd.Series(rets).rolling(w).apply(
+        lambda x: np.mean(x) / (np.std(x) + 1e-10) * np.sqrt(252)
+    )
+    rolling_vol = pd.Series(rets).rolling(w).std() * np.sqrt(252) * 100
+
+    fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.06,
+                         row_heights=[0.5, 0.5], subplot_titles=["Rolling Sharpe (63d)", "Rolling Volatility %"])
+
+    fig.add_trace(go.Scatter(x=dates, y=rolling_sharpe, name="Sharpe",
+        line=dict(color=DARK["accent"], width=2)), row=1, col=1)
+    fig.add_trace(go.Scatter(x=dates, y=np.full(len(dates), snap["sharpe"]),
+        line=dict(color="rgba(239,68,68,0.4)", dash="dot", width=1), name="Overall Sharpe"), row=1, col=1)
+
+    fig.add_trace(go.Scatter(x=dates, y=rolling_vol, name="Vol %",
+        line=dict(color=DARK["yellow"], width=2)), row=2, col=1)
+
+    fig.update_layout(**PLOTLY_LAYOUT, height=400, showlegend=False)
+    return fig.to_html(include_plotlyjs="cdn", full_html=False,
+                        config={"responsive": True, "displayModeBar": False})
+
+
+def build_weights_chart() -> str:
+    """Build portfolio weight treemap as bar chart."""
+    pos = _store.positions
+    if not pos:
+        return "<div style='color:#64748b;text-align:center;padding:40px'>No positions</div>"
+
+    items = sorted(pos.items(), key=lambda x: x[1], reverse=True)
+    labels = [f"{k}" for k, v in items]
+    values = [v * 100 for k, v in items]
+
+    fig = go.Figure(go.Bar(
+        x=labels, y=values,
+        marker=dict(color=[DARK["accent"]]*3 + ["#6366f1"]*3 +
+                    [DARK["green"]]*2 + ["#8b5cf6"]*2 if len(labels) > 4 else [DARK["accent"]]*len(labels)),
+        text=[f"{v:.1f}%" for v in values], textposition="outside",
+        marker_line=dict(width=0),
+    ))
+    fig.update_layout(
+        **PLOTLY_LAYOUT, height=260, showlegend=False,
+        yaxis=dict(title="Weight %", ticksuffix="%", range=[0, max(values)*1.3]),
+        xaxis=dict(tickangle=-30),
+    )
+    return fig.to_html(include_plotlyjs="cdn", full_html=False,
+                        config={"responsive": True, "displayModeBar": False})
+
+
+def build_feature_importance_chart() -> str:
+    """Build top-10 feature importance chart."""
+    fi = _store.feature_importance
+    if not fi:
+        return "<div style='color:#64748b;text-align:center;padding:40px'>No data</div>"
+
+    items = sorted(fi.items(), key=lambda x: x[1], reverse=True)[:12]
+    labels = [k.replace("_"," ").title()[:30] for k, v in items]
+    values = [v * 100 for k, v in items]
+
+    fig = go.Figure(go.Bar(
+        y=labels[::-1], x=values[::-1], orientation="h",
+        marker=dict(color=[DARK["accent"]]*len(labels)),
+        text=[f"{v:.1f}%" for v in values[::-1]], textposition="outside",
+    ))
+    fig.update_layout(**PLOTLY_LAYOUT, height=340, showlegend=False,
+        xaxis=dict(title="Importance %", ticksuffix="%"),
+        margin=dict(l=120, r=24, t=32, b=8),
+    )
+    return fig.to_html(include_plotlyjs="cdn", full_html=False,
+                        config={"responsive": True, "displayModeBar": False})
+
+
+def build_regime_chart() -> str:
+    """Build regime probability donut chart."""
+    rp = _store.regime_probs
+    if not rp:
+        return "<div style='color:#64748b;text-align:center;padding:40px'>Loading...</div>"
+
+    colors_map = {"bull": DARK["green"], "bear": DARK["red"],
+                   "high_vol": DARK["yellow"], "neutral": "#64748b"}
+    fig = go.Figure(go.Pie(
+        labels=list(rp.keys()), values=list(rp.values()), hole=0.55,
+        marker=dict(colors=[colors_map.get(k, DARK["accent"]) for k in rp.keys()]),
+        textinfo="label+percent", textfont=dict(size=12, color=DARK["text_bright"]),
+    ))
+    fig.update_layout(**PLOTLY_LAYOUT, height=260, showlegend=False)
+    return fig.to_html(include_plotlyjs="cdn", full_html=False,
+                        config={"responsive": True, "displayModeBar": False})
+
+
+def build_sentiment_chart() -> str:
+    """Build sentiment bar chart."""
+    ss = _store.sentiment_scores
+    if not ss:
+        return "<div style='color:#64748b;text-align:center;padding:40px'>No sentiment data</div>"
+
+    items = sorted(ss.items(), key=lambda x: abs(x[1]), reverse=True)
+    labels = [k for k, v in items]
+    values = [v for k, v in items]
+    colors = [DARK["green"] if v > 0 else DARK["red"] for v in values]
+
+    fig = go.Figure(go.Bar(
+        x=labels, y=values, marker=dict(color=colors),
+        text=[f"{v:+.2f}" for v in values], textposition="outside",
+    ))
+    fig.update_layout(
+        **PLOTLY_LAYOUT, height=240, showlegend=False,
+        yaxis=dict(title="Sentiment Score", range=[-1.1, 1.1]),
+        xaxis=dict(tickangle=-30),
+    )
+    fig.add_hline(y=0, line=dict(color=DARK["text"], width=1, dash="dot"))
+    return fig.to_html(include_plotlyjs="cdn", full_html=False,
+                        config={"responsive": True, "displayModeBar": False})
+
+
+# ── HTML Components ──────────────────────────────────────────────────────────
+
+def _kpi_card(value: str, label: str, color: str = DARK["accent"], 
+              sub: str = "", sub_color: str = "") -> str:
+    """Render a KPI card."""
+    sub_html = f'<div style="color:{sub_color};font-size:11px;margin-top:2px">{sub}</div>' if sub else ""
+    return f'''
+    <div style="background:{DARK["card"]};border:1px solid {DARK["border"]};border-radius:10px;
+                padding:14px 18px;text-align:center;min-width:110px">
+        <div style="color:{DARK["text"]};font-size:11px;text-transform:uppercase;letter-spacing:0.5px;margin-bottom:4px">
+            {label}
+        </div>
+        <div style="color:{color};font-size:22px;font-weight:700;line-height:1.2">{value}</div>
+        {sub_html}
+    </div>'''
+
+def _ticker_pill(symbol: str, weight: float, pnl_pct: float = 0) -> str:
+    """Render a ticker pill badge."""
+    pnl_color = DARK["green"] if pnl_pct >= 0 else DARK["red"]
+    pnl_sign = "+" if pnl_pct >= 0 else ""
+    return f'''
+    <div style="display:inline-block;background:{DARK["card"]};border:1px solid {DARK["border"]};
+                border-radius:8px;padding:8px 14px;margin:3px;min-width:140px">
+        <span style="color:{DARK["accent"]};font-weight:700;font-size:14px">{symbol}</span>
+        <span style="color:{DARK["text_bright"]};font-size:13px;margin-left:8px">{weight:.1%}</span>
+        <span style="color:{pnl_color};font-size:12px;margin-left:6px">{pnl_sign}{pnl_pct:.1%}</span>
+    </div>'''
+
+def _alert_badge(level: str, title: str, text: str, time_str: str) -> str:
+    """Render an alert badge."""
+    colors = {"error": DARK["red"], "warn": DARK["yellow"], "info": DARK["accent"]}
+    color = colors.get(level, DARK["text"])
+    return f'''
+    <div style="background:{DARK["card"]};border-left:3px solid {color};border-radius:4px;
+                padding:8px 12px;margin:4px 0">
+        <span style="color:{color};font-weight:600;font-size:12px">[{time_str}] {title}</span>
+        <span style="color:{DARK["text"]};font-size:11px;margin-left:8px">{text}</span>
+    </div>'''
+
+def build_top_bar() -> str:
+    """Build top status bar."""
+    snap = _store.snapshot()
+    regime_color = {"bull": DARK["green"], "bear": DARK["red"],
+                    "high_vol": DARK["yellow"], "neutral": DARK["text"]}
+    rc = regime_color.get(snap.get("regime","neutral"), DARK["text"])
+
+    return f'''
+    <div style="background:{DARK["card"]};padding:10px 24px;display:flex;align-items:center;
+                justify-content:space-between;border-bottom:1px solid {DARK["border"]}">
+        <div style="display:flex;align-items:center;gap:16px">
+            <span style="color:{DARK["accent"]};font-size:20px;font-weight:800">🧠 AlphaForge</span>
+            <span style="color:{DARK["text"]};font-size:10px;padding:2px 8px;background:#1e293b;border-radius:4px">v2.0 PRO</span>
+        </div>
+        <div style="display:flex;align-items:center;gap:24px">
+            <span style="color:{DARK["text"]};font-size:12px">
+                Regime: <b style="color:{rc}">{snap.get("regime","--").upper()}</b>
+            </span>
+            <span style="color:{DARK["text"]};font-size:12px">
+                Last Refresh: {datetime.now().strftime("%H:%M:%S")}
+            </span>
+            <span style="color:{DARK["green"]};font-size:10px">● LIVE</span>
+        </div>
+    </div>'''
+
+def build_kpi_row() -> str:
+    """Build row of KPI cards."""
+    snap = _store.snapshot()
+    pnl = snap.get("pnl", [])
+    last_pnl = pnl[-1] if pnl else 0
+    return (
+        _kpi_card(f"${last_pnl:,.0f}", "Cumulative PnL", DARK["accent"]) +
+        _kpi_card(f"{snap.get('sharpe',0):.2f}", "Sharpe", DARK["green"] if snap.get("sharpe",0) >= 1 else DARK["yellow"]) +
+        _kpi_card(f"{snap.get('sortino',0):.2f}", "Sortino", DARK["accent"]) +
+        _kpi_card(f"{snap.get('max_dd',0)*100:.1f}%", "Max Drawdown", DARK["red"]) +
+        _kpi_card(f"${snap.get('var_95',0):,.0f}", "VaR 95%", DARK["yellow"]) +
+        _kpi_card(f"{snap.get('calmar',0):.2f}", "Calmar", DARK["accent"]) +
+        _kpi_card(f"{snap.get('alpha',0)*100:.1f}%", "Alpha", DARK["green"] if snap.get("alpha",0) >= 0 else DARK["red"]) +
+        _kpi_card(f"{snap.get('beta',0):.2f}", "Beta", DARK["accent"])
+    )
+
+def build_positions_html() -> str:
+    """Build positions ticker pills."""
+    pos = _store.positions
+    if not pos:
+        return "<p style='color:#64748b'>No positions</p>"
+    items = sorted(pos.items(), key=lambda x: x[1], reverse=True)
+    return "<div style='display:flex;flex-wrap:wrap;gap:4px'>" + \
+           "".join(_ticker_pill(k, v, np.random.normal(0, 0.03)) for k, v in items) + "</div>"
+
+def build_alerts_html() -> str:
+    """Build alerts feed."""
+    alerts = _store.alerts
+    return "".join(_alert_badge(a["level"], a["title"], a["text"], a["time"]) for a in alerts)
+
+
+# ── Dashboard App ────────────────────────────────────────────────────────────
+
+custom_css = """
+.gradio-container { max-width: 1400px !important; margin: 0 auto; }
+footer { display: none !important; }
+.tab-nav { margin-bottom: 12px !important; }
+"""
+
+with gr.Blocks(
+    title="AlphaForge Pro Dashboard",
+    css=custom_css,
+    theme=gr.themes.Soft(primary_hue="blue", neutral_hue="slate"),
+    fill_width=True,
+) as demo:
+
+    # Timer for auto-refresh (every 5 seconds)
+    timer = gr.Timer(5)
+
+    # Top status bar
+    top_bar = gr.HTML(value=build_top_bar(), every=5)
+
+    with gr.Row():
+        with gr.Column(scale=1, min_width=220):
+            gr.Markdown("### 📊 KPIs")
+            kpi_html = gr.HTML(value=build_kpi_row, every=5)
+
+            gr.Markdown("### 💼 Positions")
+            positions_html = gr.HTML(value=build_positions_html, every=5)
+
+            gr.Markdown("### 🎯 Regime")
+            regime_chart = gr.HTML(value=build_regime_chart, every=5)
+
+        with gr.Column(scale=4):
+            with gr.Tabs():
+                with gr.Tab("📈 PnL & Risk"):
+                    with gr.Row():
+                        pnl_chart = gr.HTML(value=build_pnl_chart, every=5)
+                    with gr.Row():
+                        risk_chart = gr.HTML(value=build_risk_chart, every=5)
+
+                with gr.Tab("⚖️ Weights & Factors"):
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            gr.Markdown("### Portfolio Weights")
+                            weights_chart = gr.HTML(value=build_weights_chart, every=5)
+                        with gr.Column(scale=1):
+                            gr.Markdown("### Feature Importance")
+                            feature_chart = gr.HTML(value=build_feature_importance_chart, every=5)
+
+                with gr.Tab("🗞️ Sentiment"):
+                    with gr.Row():
+                        sentiment_chart = gr.HTML(value=build_sentiment_chart, every=5)
+
+                with gr.Tab("⚠️ Alerts & Logs"):
+                    alerts_html = gr.HTML(value=build_alerts_html, every=5)
+
+    # Auto refresh hook
+    @gr.on(triggers=[demo.load, timer.tick], outputs=[top_bar, kpi_html, positions_html,
+            regime_chart, pnl_chart, risk_chart, weights_chart, feature_chart,
+            sentiment_chart, alerts_html])
+    def refresh_all():
+        return (build_top_bar(), build_kpi_row(), build_positions_html(),
+                build_regime_chart(), build_pnl_chart(), build_risk_chart(),
+                build_weights_chart(), build_feature_importance_chart(),
+                build_sentiment_chart(), build_alerts_html())
+
+
+if __name__ == "__main__":
+    # Generate synthetic data for demo
+    _generate_synthetic_run()
+    demo.launch()