Update app.py

app.py

@@ -6,52 +6,87 @@ import pandas as pd
 from geo_macro import UnifiedMarketDataDownloader
 from feature_engineering import IntegratedTheoryFeatures
 
-# Get FRED API key from environment (set in HF Spaces secrets)
+# Cache to avoid re-downloading data on every click
+_cached_df = None
+_cached_dates = (None, None)
 
 
-def run_pipeline(days_back=1825):  # ~5 years
+
+
+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()
+    df = downloader.download_all_data(start_date=start_date, end_date=end_date)
+    
+    _cached_df = df.copy()
+    _cached_dates = (start_date, end_date)
+    return df
+
+
+def run_pipeline(days_back: int = 1825):
     try:
-        # Download data
-        start_date = pd.Timestamp.today() - pd.Timedelta(days=days_back)
-        start_str = start_date.strftime('%Y-%m-%d')
-        end_str = pd.Timestamp.today().strftime('%Y-%m-%d')
+        # 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)
         
-        downloader = UnifiedMarketDataDownloader()
-        df = downloader.download_all_data(start_date=start_str, end_date=end_str)
+        # Validate data
+        if len(df) < 300:
+            return {"Error": "Insufficient data. Try increasing lookback window."}
         
-        # Run feature engineering
+        # Run feature pipeline
         engine = IntegratedTheoryFeatures(df)
         features = engine.build_all_features()
         
-        # Extract latest state
-        latest = features.iloc[-1]
+        # Extract latest non-NaN row
+        latest = features.dropna(subset=['regime']).iloc[-1]
+        
+        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)
+        
         output = {
-            "Regime": latest["regime"],
-            "Dalio Composite": f"{latest['dalio_composite_norm']:.3f}",
-            "Stevenson Inequality": f"{latest['stevenson_inequality_norm']:.3f}",
-            "Thiel Monopoly": f"{latest['thiel_monopoly_norm']:.3f}",
-            "Gundlach Reckoning": f"{latest['gundlach_reckoning_norm']:.3f}",
-            "Prob Credit Collapse": f"{latest['prob_credit_collapse']:.1%}",
-            "Prob Stagflation": f"{latest['prob_stagflation']:.1%}",
-            "Prob Tech Boom": f"{latest['prob_tech_boom']:.1%}",
+            "Regime": str(latest["regime"]),
+            "Dalio Composite": fmt(latest['dalio_composite_norm']),
+            "Stevenson Inequality": fmt(latest['stevenson_inequality_norm']),
+            "Thiel Monopoly": fmt(latest['thiel_monopoly_norm']),
+            "Gundlach Reckoning": fmt(latest['gundlach_reckoning_norm']),
+            "Prob Credit Collapse": fmt(latest['prob_credit_collapse']),
+            "Prob Stagflation": fmt(latest['prob_stagflation']),
+            "Prob Tech Boom": fmt(latest['prob_tech_boom']),
         }
-        
         return output
-    
+
     except Exception as e:
         return {"Error": str(e)}
 
+
 # Gradio UI
-with gr.Blocks(title="Integrated Market Theory Dashboard") as demo:
+with gr.Blocks(title="🌍 Integrated Market Theory Dashboard") as demo:
     gr.Markdown("# 🌍 Integrated Market Theory Dashboard")
     gr.Markdown("Real-time macro regime detection using Dalio, Stevenson, Thiel & Gundlach frameworks")
     
     with gr.Row():
-        days = gr.Slider(365, 2500, value=1825, label="Lookback Window (days)")
-        run_btn = gr.Button("🔄 Update Analysis")
+        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")
     
     run_btn.click(run_pipeline, inputs=days, outputs=output)
 
+# Launch (HF Spaces uses this)
 demo.launch()