Update app.py

app.py

@@ -3,24 +3,26 @@
 import os
 import gradio as gr
 import pandas as pd
-from geo_macro import UnifiedMarketDataDownloader, FRED_API_KEY
+import plotly.graph_objects as go
+import plotly.express as px
+from geo_macro import UnifiedMarketDataDownloader
 from feature_engineering import IntegratedTheoryFeatures
 
-# Cache to avoid re-downloading data on every click
+# Get FRED API key from environment (set in HF Spaces secrets)
+FRED_API_KEY = os.getenv("FRED_API_KEY", "")
+
+# Cache to avoid re-downloading data
 _cached_df = None
 _cached_dates = (None, None)
 
 
-
-
 def get_data(start_date: str, end_date: str):
-    """Download or return cached market data."""
     global _cached_df, _cached_dates
     if _cached_df is not None and _cached_dates == (start_date, end_date):
         return _cached_df.copy()
     
     print(f"📥 Downloading data from {start_date} to {end_date}...")
-    downloader = UnifiedMarketDataDownloader(FRED_API_KEY)
+    downloader = UnifiedMarketDataDownloader(fred_api_key=FRED_API_KEY)
     df = downloader.download_all_data(start_date=start_date, end_date=end_date)
     
     _cached_df = df.copy()
@@ -28,38 +30,104 @@ def get_data(start_date: str, end_date: str):
     return df
 
 
+def create_composite_bar(latest):
+    """Bar chart of the 4 core normalized scores"""
+    scores = {
+        "Dalio Composite": latest['dalio_composite_norm'],
+        "Stevenson Inequality": latest['stevenson_inequality_norm'],
+        "Thiel Monopoly": latest['thiel_monopoly_norm'],
+        "Gundlach Reckoning": latest['gundlach_reckoning_norm'],
+    }
+    colors = ["#1f77b4", "#ff7f0e", "#2ca02c", "#d62728"]
+    fig = go.Figure(go.Bar(
+        x=list(scores.keys()),
+        y=list(scores.values()),
+        marker_color=colors,
+        text=[f"{v:.3f}" for v in scores.values()],
+        textposition='auto',
+    ))
+    fig.update_layout(
+        title="Core Theory Scores (Normalized)",
+        yaxis_range=[-1, 1],
+        height=350
+    )
+    return fig
+
+
+def create_probabilities_bar(latest):
+    """Horizontal bar chart of scenario probabilities"""
+    probs = {
+        "Credit Collapse": latest['prob_credit_collapse'],
+        "Stagflation": latest['prob_stagflation'],
+        "Tech Boom": latest['prob_tech_boom'],
+    }
+    fig = go.Figure(go.Bar(
+        x=list(probs.values()),
+        y=list(probs.keys()),
+        orientation='h',
+        marker_color=["#d62728", "#ff7f0e", "#2ca02c"],
+        text=[f"{v:.1%}" for v in probs.values()],
+        textposition='auto',
+    ))
+    fig.update_layout(
+        title="Scenario Probabilities",
+        xaxis_tickformat='.0%',
+        xaxis_range=[0, 1],
+        height=250
+    )
+    return fig
+
+
+def create_regime_timeline(features):
+    """Timeline of regime over last 252 days"""
+    tail = features[['regime']].tail(252).copy()
+    tail['date'] = tail.index
+    color_map = {
+        'CRISIS': '#d62728',
+        'INEQUALITY_TRAP': '#ff7f0e',
+        'GEOPOLITICAL_SHOCK': '#9467bd',
+        'TECH_MONOPOLY': '#2ca02c',
+        'TRANSITION': '#7f7f7f'
+    }
+    tail['color'] = tail['regime'].map(color_map)
+    fig = go.Figure(go.Scatter(
+        x=tail['date'],
+        y=tail['regime'],
+        mode='markers',
+        marker=dict(color=tail['color'], size=8),
+        showlegend=False
+    ))
+    fig.update_layout(
+        title="Regime Timeline (Last 12 Months)",
+        height=200,
+        yaxis_title="Regime",
+        xaxis_title="Date"
+    )
+    return fig
+
+
 def run_pipeline(days_back: int = 1825):
     try:
-        # Define date range
         today = pd.Timestamp.today()
         start_date = (today - pd.Timedelta(days=days_back)).strftime('%Y-%m-%d')
         end_date = today.strftime('%Y-%m-%d')
         
-        # Get data (cached if possible)
         df = get_data(start_date, end_date)
-        
-        # Validate data
         if len(df) < 300:
-            return {"Error": "Insufficient data. Try increasing lookback window."}
+            return {"Error": "Insufficient data. Try increasing lookback window."}, None, None, None
         
-        # Run feature pipeline
         engine = IntegratedTheoryFeatures(df)
         features = engine.build_all_features()
-        
-        # Extract latest non-NaN row
         latest = features.dropna(subset=['regime']).iloc[-1]
         
+        # Format JSON
         def fmt(x):
-            if pd.isna(x):
-                return "N/A"
-            if isinstance(x, float) and -1 <= x <= 1:
-                return f"{x:.3f}"
-            elif isinstance(x, float) and 0 <= x <= 1:
-                return f"{x:.1%}"
-            else:
-                return str(x)
+            if pd.isna(x): return "N/A"
+            if isinstance(x, float) and -1 <= x <= 1: return f"{x:.3f}"
+            elif isinstance(x, float) and 0 <= x <= 1: return f"{x:.1%}"
+            else: return str(x)
         
-        output = {
+        json_output = {
             "Regime": str(latest["regime"]),
             "Dalio Composite": fmt(latest['dalio_composite_norm']),
             "Stevenson Inequality": fmt(latest['stevenson_inequality_norm']),
@@ -69,10 +137,17 @@ def run_pipeline(days_back: int = 1825):
             "Prob Stagflation": fmt(latest['prob_stagflation']),
             "Prob Tech Boom": fmt(latest['prob_tech_boom']),
         }
-        return output
+        
+        # Create plots
+        composite_fig = create_composite_bar(latest)
+        prob_fig = create_probabilities_bar(latest)
+        timeline_fig = create_regime_timeline(features)
+        
+        return json_output, composite_fig, prob_fig, timeline_fig
 
     except Exception as e:
-        return {"Error": str(e)}
+        error = {"Error": str(e)}
+        return error, None, None, None
 
 
 # Gradio UI
@@ -84,9 +159,18 @@ with gr.Blocks(title="🌍 Integrated Market Theory Dashboard") as demo:
         days = gr.Slider(365, 2500, value=1825, step=90, label="Lookback Window (days)")
         run_btn = gr.Button("🔄 Update Analysis", variant="primary")
     
-    output = gr.JSON(label="Current Market Regime & Probabilities")
+    with gr.Row():
+        json_output = gr.JSON(label="Current State")
+        composite_plot = gr.Plot(label="Core Theory Scores")
     
-    run_btn.click(run_pipeline, inputs=days, outputs=output)
+    with gr.Row():
+        prob_plot = gr.Plot(label="Scenario Probabilities")
+        timeline_plot = gr.Plot(label="Regime Timeline")
+
+    run_btn.click(
+        run_pipeline,
+        inputs=days,
+        outputs=[json_output, composite_plot, prob_plot, timeline_plot]
+    )
 
-# Launch (HF Spaces uses this)
 demo.launch()