Update app.py

app.py

@@ -1,367 +1,413 @@
-# app.py
 import gradio as gr
 import pandas as pd
 import numpy as np
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
-from datetime import datetime, timedelta
+from datetime import datetime
 import warnings
 import os
 
 warnings.filterwarnings('ignore')
 
-# Assume geo_macro.py exists and works as intended.
 from geo_macro import UnifiedMarketDataDownloader
 
-# ======================
-# CONFIGURATION
-# ======================
-DATA_FILE = 'unified_market_data.csv'
-CACHE_HOURS = 24
+# Configuration
+FRED_API_KEY = os.getenv("FRED_API_KEY", "23f3511b0ca43918ccd503ef64cb844e")
 
+# Professional color palette
 COLORS = {
-    'primary': '#2E4053',    # Dark Slate Gray for main plots
-    'secondary': '#85929E',  # Lighter Gray for secondary elements
-    'accent': '#17202A',     # Nearly Black for titles
-    'grid': '#EAECEE',       # Very Light Gray for grids
-    'bg_primary': '#FFFFFF', # White background
-    'bg_secondary': '#F8F9F9',# Off-white for cards/tabs
-    'success': '#27AE60',    # Green
-    'danger': '#C0392B',     # Red
-    'warning': '#F39C12'     # Yellow
+    'primary': '#1a1a1a',
+    'secondary': '#4a4a4a',
+    'accent': '#0066cc',
+    'grid': '#e5e5e5',
+    'bg': '#ffffff',
+    'green': '#00a86b',
+    'red': '#d32f2f',
 }
 
-# Securely load FRED API key
-FRED_API_KEY = os.getenv("FRED_API_KEY")
-if not FRED_API_KEY:
-    print("⚠️ Warning: FRED_API_KEY not set. Economic data might be limited.")
-
-# ======================
-# DATA LOADING & MOCKING (if geo_macro.py is not available)
-# ======================
-def load_or_download_data():
-    downloader = UnifiedMarketDataDownloader(fred_api_key=FRED_API_KEY)
-    df = downloader.download_all_data(start_date='2018-01-01')
-    df.to_csv(DATA_FILE)
-    print(f"💾 Saved to {DATA_FILE}")
-except (ImportError, ModuleNotFoundError):
-    print("⚠️ `geo_macro.py` not found. Generating mock data.")
-    dates = pd.date_range(start='2018-01-01', end=datetime.today(), freq='B')
-    tickers = ['SP500', 'NASDAQ', 'VIX', 'Gold', 'Oil', 'TLT', 'HYG', 'DXY',
-               'T10Y2Y', 'CPIAUCSL', 'ITA', 'MTUM', 'VTV', 'QUAL', 'IJR',
-               'Technology', 'Financials', 'Healthcare', 'Consumer_Discretionary',
-               'Consumer_Staples', 'Energy', 'Materials', 'Industrials', 'Utilities']
-    data = {ticker: (100 + np.random.randn(len(dates)).cumsum() * 0.5) for ticker in tickers}
-    df = pd.DataFrame(data, index=dates)
-    # Make some series more realistic
-    df['VIX'] = np.random.uniform(10, 40, size=len(dates))
-    df['T10Y2Y'] = np.random.randn(len(dates)) * 0.5
-    df['CPIAUCSL'] = (3 + np.random.randn(len(dates)).cumsum() * 0.01)
-    df.to_csv(DATA_FILE)
-    print(f"💾 Mock data saved to {DATA_FILE}")
-    return df
-
-# ======================
-# ADVANCED FEATURE ENGINEERING
-# ======================
-def calculate_z_score(series, fast_window=60, slow_window=252):
-    """Calculates a rolling z-score of momentum."""
-    momentum = series.pct_change(fast_window)
-    mean = momentum.rolling(slow_window).mean()
-    std = momentum.rolling(slow_window).std()
-    return (momentum - mean) / std
-
-def add_thematic_and_factor_features(df):
-    """Engineer features for themes, factors, and custom indices."""
-    df_out = df.copy()
-
-    # 1. Thematic Baskets (Momentum Z-Score)
-    THEMES = {
-        "AI & Tech": ["Technology", "NASDAQ", "SMH"],
-        "Defense & Security": ["ITA", "XAR"],
-        "Inflationary Pressures": ["DBA", "DBB", "Oil", "Copper", "Energy"],
-        "Safe Havens": ["Gold", "TLT", "CHF"],
-        "Credit & Liquidity Stress": ["HYG", "JNK", "T10Y2Y"],
-    }
-    for name, assets in THEMES.items():
-        available = [a for a in assets if a in df_out.columns]
-        if available:
-            # Use z-score of price level for non-mean-reverting themes
-            theme_series = df_out[available].mean(axis=1)
-            df_out[f"{name}_Z"] = calculate_z_score(theme_series)
-
-    # 2. Factor Baskets (e.g., Fama-French proxies)
-    FACTORS = {
-        "Momentum": ["MTUM"], "Value": ["VTV"], "Quality": ["QUAL"],
-    }
-    for name, assets in FACTORS.items():
-         if assets[0] in df_out.columns:
-            df_out[f"Factor_{name}_Z"] = calculate_z_score(df_out[assets[0]])
-    if 'IJR' in df_out.columns and 'SP500' in df_out.columns:
-        size_premium = df_out['IJR'].pct_change() - df_out['SP500'].pct_change()
-        df_out["Factor_Size_Premium_Z"] = calculate_z_score(size_premium.cumsum() + 1)
-
-
-    # 3. Custom Geopolitical Risk Index
-    geo_assets = ['Oil', 'Gold', 'ITA', 'DXY']
-    available_geo = [a for a in geo_assets if a in df_out.columns]
-    if len(available_geo) > 1:
-        norm_geo = df_out[available_geo].dropna().apply(lambda x: (x / x.iloc[0]))
-        geo_index = norm_geo.mean(axis=1)
-        df_out['Geopolitical_Risk_Z'] = calculate_z_score(geo_index, fast_window=21) # More sensitive
-
-    return df_out
-
-def get_processed_data():
-    """Main data pipeline function."""
-    df = load_or_download_data()
-    return add_thematic_and_factor_features(df)
-
-# ======================
-# PLOTTING & AESTHETICS
-# ======================
-def monochrome_layout(title, height=500):
-    """Creates a professional, monochrome plot layout."""
+# Cache data globally
+_cached_data = None
+
+def load_data():
+    """Load and cache market data"""
+    global _cached_data
+    if _cached_data is None:
+        downloader = UnifiedMarketDataDownloader(fred_api_key=FRED_API_KEY)
+        _cached_data = downloader.download_all_data(start_date='2020-01-01')
+    return _cached_data
+
+def calculate_momentum_zscore(series, window=60):
+    """Calculate momentum z-score"""
+    returns = series.pct_change(window)
+    mean = returns.rolling(252).mean()
+    std = returns.rolling(252).std()
+    return (returns - mean) / std
+
+def create_layout(title, height=450):
+    """Standard plot layout"""
     return go.Layout(
-        title=dict(text=title, font=dict(color=COLORS['accent'], size=20), x=0.5),
-        plot_bgcolor=COLORS['bg_primary'],
-        paper_bgcolor=COLORS['bg_primary'],
-        font=dict(color=COLORS['primary'], size=12),
-        xaxis=dict(gridcolor=COLORS['grid'], linecolor=COLORS['secondary']),
-        yaxis=dict(gridcolor=COLORS['grid'], linecolor=COLORS['secondary']),
+        title=dict(text=title, font=dict(size=16, color=COLORS['primary']), x=0.5, xanchor='center'),
+        plot_bgcolor=COLORS['bg'],
+        paper_bgcolor=COLORS['bg'],
+        font=dict(color=COLORS['secondary'], size=11),
+        xaxis=dict(gridcolor=COLORS['grid'], showline=True, linecolor=COLORS['grid']),
+        yaxis=dict(gridcolor=COLORS['grid'], showline=True, linecolor=COLORS['grid']),
         hovermode='x unified',
-        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1),
-        height=height
+        height=height,
+        margin=dict(l=60, r=40, t=60, b=40),
     )
 
-def plot_heatmap(df, title, colorscale='RdBu_r', zmid=0):
-    """Generic heatmap plotting function."""
-    fig = go.Figure(go.Heatmap(
-        z=df.T.values,
-        x=df.index,
-        y=[col.replace('_Z', '').replace('_', ' ') for col in df.columns],
-        colorscale=colorscale, zmid=zmid, zmin=-2.5, zmax=2.5,
-        colorbar=dict(title="Z-Score")
+# === PLOT FUNCTIONS ===
+
+def plot_geopolitical_risk(start_date, end_date):
+    """Geopolitical risk composite index"""
+    df = load_data().loc[start_date:end_date]
+    
+    # Composite: Defense, Oil, Gold, VIX
+    components = ['Defense', 'Oil', 'Gold', 'VIX']
+    available = [c for c in components if c in df.columns]
+    
+    if len(available) < 2:
+        return go.Figure().update_layout(create_layout("Insufficient Data"))
+    
+    # Normalize each component
+    normalized = df[available].apply(lambda x: (x / x.iloc[0]) - 1)
+    risk_index = normalized.mean(axis=1)
+    
+    # Calculate z-score
+    zscore = (risk_index - risk_index.rolling(252).mean()) / risk_index.rolling(252).std()
+    
+    fig = go.Figure()
+    
+    # Add risk index
+    fig.add_trace(go.Scatter(
+        x=zscore.index, 
+        y=zscore,
+        fill='tozeroy',
+        line=dict(color=COLORS['accent'], width=2),
+        name='Risk Index'
     ))
-    fig.update_layout(monochrome_layout(title, height=500))
+    
+    # Add threshold lines
+    fig.add_hline(y=0, line_dash="dash", line_color=COLORS['secondary'], line_width=1)
+    fig.add_hline(y=2, line_dash="dot", line_color=COLORS['red'], line_width=1)
+    fig.add_hline(y=-2, line_dash="dot", line_color=COLORS['green'], line_width=1)
+    
+    fig.update_layout(create_layout("Geopolitical Risk Index (Z-Score)"))
+    fig.update_yaxes(title="Standard Deviations from Mean")
+    
     return fig
 
-# --- PLOT FUNCTIONS ---
-
-def plot_thematic_regime(start_date, end_date):
-    df = get_processed_data().loc[start_date:end_date]
-    z_cols = [c for c in df.columns if '_Z' in c and 'Factor' not in c and 'Geopolitical' not in c]
-    if not z_cols: return go.Figure().update_layout(monochrome_layout("No Thematic Data Available"))
-    return plot_heatmap(df[z_cols], "🌍 Thematic Regime Heatmap")
-
-def plot_factor_regime(start_date, end_date):
-    df = get_processed_data().loc[start_date:end_date]
-    z_cols = [c for c in df.columns if 'Factor' in c]
-    if not z_cols: return go.Figure().update_layout(monochrome_layout("No Factor Data Available"))
-    return plot_heatmap(df[z_cols], "🔭 Factor Performance Heatmap")
-
-def plot_macro_dashboard(start_date, end_date):
-    df = get_processed_data().loc[start_date:end_date]
-    indicators = {'CPIAUCSL': 'YoY Inflation (%)', 'T10Y2Y': 'Yield Curve (10Y-2Y)',
-                  'VIX': 'Volatility Index', 'DXY': 'US Dollar Index'}
+def plot_macro_indicators(start_date, end_date):
+    """Key macro indicators dashboard"""
+    df = load_data().loc[start_date:end_date]
+    
+    indicators = {
+        'CPI': ('Inflation (YoY %)', lambda x: x.pct_change(252) * 100),
+        'Yield_Curve': ('Yield Curve (10Y-2Y)', lambda x: x),
+        'VIX': ('Market Volatility', lambda x: x),
+        'USD_Index': ('Dollar Strength', lambda x: x),
+    }
+    
     available = {k: v for k, v in indicators.items() if k in df.columns}
-    if not available: return go.Figure().update_layout(monochrome_layout("No Macro Data Available"))
-
-    fig = make_subplots(rows=len(available), cols=1, shared_xaxes=True,
-                        subplot_titles=list(available.values()), vertical_spacing=0.1)
-    for i, (ticker, title) in enumerate(available.items(), 1):
-        series = df[ticker].dropna()
-        if ticker == 'CPIAUCSL': # Calculate YoY % change for CPI
-            series = series.pct_change(252) * 100
-        fig.add_trace(go.Scatter(x=series.index, y=series, mode='lines',
-                                 line=dict(color=COLORS['primary'], width=2), name=ticker), row=i, col=1)
-    fig.update_layout(monochrome_layout("📈 Key Macroeconomic Indicators"), height=200 * len(available), showlegend=False)
+    
+    if not available:
+        return go.Figure().update_layout(create_layout("No Data Available"))
+    
+    n_plots = len(available)
+    fig = make_subplots(
+        rows=n_plots, cols=1,
+        shared_xaxes=True,
+        vertical_spacing=0.05,
+        subplot_titles=[v[0] for v in available.values()]
+    )
+    
+    for i, (col, (title, transform)) in enumerate(available.items(), 1):
+        series = transform(df[col]).dropna()
+        
+        # Color based on last value
+        color = COLORS['red'] if series.iloc[-1] > series.mean() else COLORS['green']
+        if col == 'Yield_Curve':
+            color = COLORS['red'] if series.iloc[-1] < 0 else COLORS['green']
+        
+        fig.add_trace(
+            go.Scatter(
+                x=series.index,
+                y=series,
+                line=dict(color=color, width=2),
+                showlegend=False
+            ),
+            row=i, col=1
+        )
+        
+        # Add mean line
+        mean_val = series.mean()
+        fig.add_hline(
+            y=mean_val,
+            line_dash="dash",
+            line_color=COLORS['secondary'],
+            line_width=1,
+            row=i, col=1
+        )
+    
+    fig.update_layout(
+        create_layout("Macroeconomic Indicators", height=150 * n_plots),
+        showlegend=False
+    )
+    
     return fig
 
-def plot_geopolitical_risk(start_date, end_date):
-    df = get_processed_data().loc[start_date:end_date]
-    if 'Geopolitical_Risk_Z' not in df.columns:
-        return go.Figure().update_layout(monochrome_layout("Geopolitical Risk Index Not Available"))
-    
-    risk_series = df['Geopolitical_Risk_Z'].dropna()
-    fig = go.Figure(go.Scatter(x=risk_series.index, y=risk_series, mode='lines',
-                               fill='tozeroy', line_color=COLORS['danger']))
-    fig.add_hline(y=0, line_dash="dash", line_color=COLORS['secondary'])
-    fig.add_hline(y=1.5, line_dash="dot", line_color=COLORS['warning'])
-    fig.update_layout(monochrome_layout("💥 Geopolitical Risk Index (Z-Score)"), yaxis_title="Momentum Z-Score")
+def plot_safe_haven_flows(start_date, end_date):
+    """Safe haven vs risk asset flows"""
+    df = load_data().loc[start_date:end_date]
+    
+    safe_havens = ['Gold', 'US_10Y', 'CHF']
+    risk_assets = ['US_Equity', 'Emerging_Markets', 'High_Yield']
+    
+    safe_available = [c for c in safe_havens if c in df.columns]
+    risk_available = [c for c in risk_assets if c in df.columns]
+    
+    if not safe_available or not risk_available:
+        return go.Figure().update_layout(create_layout("Insufficient Data"))
+    
+    # Normalize to 100
+    safe_norm = df[safe_available].apply(lambda x: x / x.iloc[0] * 100).mean(axis=1)
+    risk_norm = df[risk_available].apply(lambda x: x / x.iloc[0] * 100).mean(axis=1)
+    
+    fig = go.Figure()
+    
+    fig.add_trace(go.Scatter(
+        x=safe_norm.index,
+        y=safe_norm,
+        name='Safe Havens',
+        line=dict(color=COLORS['green'], width=2)
+    ))
+    
+    fig.add_trace(go.Scatter(
+        x=risk_norm.index,
+        y=risk_norm,
+        name='Risk Assets',
+        line=dict(color=COLORS['red'], width=2)
+    ))
+    
+    fig.update_layout(create_layout("Safe Haven vs Risk Asset Performance"))
+    fig.update_yaxes(title="Indexed to 100")
+    
     return fig
 
-def plot_multi_asset_performance(start_date, end_date, assets):
-    df = get_processed_data().loc[start_date:end_date]
-    available = [a for a in assets if a in df.columns]
-    if not available: return go.Figure().update_layout(monochrome_layout("Select assets to plot"))
-
-    fig = go.Figure()
-    for asset in available:
-        prices = df[asset].dropna()
-        if not prices.empty:
-            norm = (prices / prices.iloc[0]) * 100
-            fig.add_trace(go.Scatter(x=norm.index, y=norm, mode='lines', name=asset))
-    fig.update_layout(monochrome_layout("📊 Multi-Asset Performance (Normalized)"),
-                      yaxis_title="Index (Base = 100)")
+def plot_relative_strength(start_date, end_date):
+    """Regional equity performance"""
+    df = load_data().loc[start_date:end_date]
+    
+    regions = ['US_Equity', 'Europe', 'China', 'Emerging_Markets']
+    available = [r for r in regions if r in df.columns]
+    
+    if len(available) < 2:
+        return go.Figure().update_layout(create_layout("Insufficient Data"))
+    
+    # Calculate 3-month momentum
+    momentum = df[available].pct_change(60).iloc[-1] * 100
+    momentum = momentum.sort_values(ascending=False)
+    
+    colors = [COLORS['green'] if x > 0 else COLORS['red'] for x in momentum.values]
+    
+    fig = go.Figure(go.Bar(
+        x=momentum.values,
+        y=[name.replace('_', ' ') for name in momentum.index],
+        orientation='h',
+        marker_color=colors,
+        text=[f"{x:.1f}%" for x in momentum.values],
+        textposition='auto',
+    ))
+    
+    fig.add_vline(x=0, line_color=COLORS['secondary'], line_width=1)
+    
+    fig.update_layout(create_layout("Regional Equity Strength (3M Return)"))
+    fig.update_xaxes(title="Return (%)")
+    
     return fig
 
-def plot_correlation_heatmap(start_date, end_date, assets):
-    df = get_processed_data().loc[start_date:end_date]
+def plot_correlation_matrix(start_date, end_date, assets):
+    """Correlation heatmap for selected assets"""
+    df = load_data().loc[start_date:end_date]
+    
     available = [a for a in assets if a in df.columns]
-    if len(available) < 2: return go.Figure().update_layout(monochrome_layout("Select 2+ assets"))
-
+    if len(available) < 2:
+        return go.Figure().update_layout(create_layout("Select at least 2 assets"))
+    
     corr = df[available].pct_change().corr()
+    
     fig = go.Figure(go.Heatmap(
-        z=corr.values, x=corr.columns, y=corr.columns,
-        colorscale='RdBu_r', zmid=0,
-        text=np.round(corr.values, 2), texttemplate='%{text}',
+        z=corr.values,
+        x=[c.replace('_', ' ') for c in corr.columns],
+        y=[c.replace('_', ' ') for c in corr.columns],
+        colorscale='RdBu_r',
+        zmid=0,
+        zmin=-1,
+        zmax=1,
+        text=np.round(corr.values, 2),
+        texttemplate='%{text}',
+        textfont=dict(size=10),
         colorbar=dict(title="Correlation")
     ))
-    fig.update_layout(monochrome_layout("🔗 Asset Correlation Matrix", height=600))
+    
+    fig.update_layout(create_layout("Asset Correlation Matrix", height=500))
+    
     return fig
 
-def plot_drawdown_analysis(start_date, end_date, assets):
-    df = get_processed_data().loc[start_date:end_date]
+def plot_drawdown(start_date, end_date, assets):
+    """Drawdown analysis"""
+    df = load_data().loc[start_date:end_date]
+    
     available = [a for a in assets if a in df.columns]
-    if not available: return go.Figure().update_layout(monochrome_layout("Select assets to plot"))
+    if not available:
+        return go.Figure().update_layout(create_layout("Select assets to analyze"))
+    
+    fig = go.Figure()
     
-    fig = make_subplots(rows=2, cols=1, shared_xaxes=True, row_heights=[0.6, 0.4],
-                        subplot_titles=('Cumulative Performance', 'Drawdown'), vertical_spacing=0.08)
     for asset in available:
         prices = df[asset].dropna()
-        if not prices.empty:
-            cum = (prices / prices.iloc[0]) * 100
-            rolling_max = cum.expanding().max()
-            drawdown = ((cum - rolling_max) / rolling_max) * 100
-            fig.add_trace(go.Scatter(x=cum.index, y=cum, mode='lines', name=asset), row=1, col=1)
-            fig.add_trace(go.Scatter(x=drawdown.index, y=drawdown, mode='lines',
-                                     fill='tozeroy', name=asset, showlegend=False,
-                                     line=dict(width=1)), row=2, col=1)
-    fig.update_layout(monochrome_layout("📉 Drawdown Analysis", height=700), legend=dict(y=1, x=1))
-    fig.update_yaxes(title_text="Index (Base=100)", row=1, col=1)
-    fig.update_yaxes(title_text="Drawdown (%)", row=2, col=1)
+        if len(prices) > 0:
+            rolling_max = prices.expanding().max()
+            drawdown = ((prices - rolling_max) / rolling_max) * 100
+            
+            fig.add_trace(go.Scatter(
+                x=drawdown.index,
+                y=drawdown,
+                name=asset.replace('_', ' '),
+                line=dict(width=2)
+            ))
+    
+    fig.update_layout(create_layout("Drawdown Analysis"))
+    fig.update_yaxes(title="Drawdown (%)")
+    
     return fig
 
-def plot_sector_rotation(start_date, end_date):
-    df = get_processed_data().loc[start_date:end_date]
-    sectors = ['Technology', 'Financials', 'Healthcare', 'Consumer_Discretionary',
-               'Consumer_Staples', 'Energy', 'Materials', 'Industrials', 'Utilities']
-    available = [s for s in sectors if s in df.columns]
-    if not available: return go.Figure().update_layout(monochrome_layout("No Sector Data Available"))
-
-    # Use 60-day returns for momentum
-    momentum = df[available].pct_change(60).iloc[-1] * 100
-    fig = go.Figure(go.Barpolar(
-        r=momentum.values,
-        theta=[s.replace('_', ' ') for s in momentum.index],
-        marker_color=COLORS['primary'],
-        opacity=0.8
-    ))
-    fig.update_layout(
-        monochrome_layout("🎯 Sector Rotation (3M Momentum %)"),
-        polar=dict(
-            radialaxis=dict(visible=True, gridcolor=COLORS['grid']),
-            angularaxis=dict(gridcolor=COLORS['grid'])
-        )
-    )
-    return fig
+# === GRADIO APP ===
 
-# ======================
-# GRADIO UI DEFINITION
-# ======================
 custom_css = """
-body, .gradio-container { font-family: 'Inter', sans-serif; background-color: #F8F9F9 !important; }
-h1 { color: #17202A; text-align: center; font-size: 2.5em !important; }
-h3 { color: #566573; text-align: center; font-weight: 500; }
-.gradio-plot { box-shadow: 0 4px 6px rgba(0,0,0,0.05); border-radius: 8px !important; }
-.tabs > .tab-nav > button { border-radius: 6px 6px 0 0 !important; background-color: #EAECEE !important; }
-.tabs > .tab-nav > button.selected { background-color: #FFFFFF !important; border-bottom: 2px solid #2E4053; }
-button.primary { background: #2E4053 !important; color: white !important; border-radius: 6px !important; }
-.gradio-accordion { background-color: #FFFFFF; border: 1px solid #EAECEE !important; border-radius: 8px !important; }
-footer { display: none !important }
+.gradio-container { 
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    max-width: 1400px;
+    margin: auto;
+}
+h1 { 
+    font-size: 2.2em !important;
+    font-weight: 600 !important;
+    color: #1a1a1a !important;
+    text-align: center;
+    margin-bottom: 0.3em !important;
+}
+h3 { 
+    font-size: 1.1em !important;
+    font-weight: 400 !important;
+    color: #4a4a4a !important;
+    text-align: center;
+    margin-top: 0 !important;
+}
+.tabs button {
+    font-size: 0.95em !important;
+    font-weight: 500 !important;
+}
+.tabs button.selected {
+    border-bottom: 2px solid #0066cc !important;
+}
+button.primary {
+    background: #0066cc !important;
+    font-weight: 500 !important;
+}
 """
 
-COMMON_TICKERS = [
-    'SP500', 'NASDAQ', 'VIX', 'Gold', 'Oil', 'TLT', 'HYG', 'DXY', 'T10Y2Y',
-    'CPIAUCSL', 'ITA', 'MTUM', 'VTV', 'QUAL', 'IJR',
-    'Technology', 'Financials', 'Energy', 'Healthcare', 'Utilities']
-
-with gr.Blocks(title="Monochrome Macro Intelligence", css=custom_css, theme=gr.themes.Soft()) as demo:
-    gr.Markdown("#  Monochrome Macro Intelligence\n### A Hedge Fund-Grade Dashboard for Geo-Macro & Factor Analysis")
+AVAILABLE_ASSETS = [
+    'US_Equity', 'Europe', 'China', 'Emerging_Markets',
+    'Gold', 'Oil', 'Copper', 'US_10Y', 'High_Yield',
+    'VIX', 'USD_Index', 'Defense', 'Technology'
+]
 
-    with gr.Tabs() as tabs:
-        # --- TAB 1: GLOBAL MACRO DASHBOARD ---
-        with gr.Tab("🌐 Global Macro Dashboard", id=0):
-            with gr.Accordion("📅 Date Range Settings", open=False):
-                with gr.Row():
-                    start_date_1 = gr.Textbox("2023-01-01", label="Start Date")
-                    end_date_1 = gr.Textbox(datetime.today().strftime('%Y-%m-%d'), label="End Date")
-            update_btn_1 = gr.Button("🔄 Generate Dashboard", variant="primary")
+with gr.Blocks(title="Geopolitical & Macro Intelligence", css=custom_css, theme=gr.themes.Soft()) as demo:
+    
+    gr.Markdown("# Geopolitical & Macro Intelligence")
+    gr.Markdown("### Professional analysis of global markets and economic indicators")
+    
+    with gr.Tabs():
+        
+        # TAB 1: Geopolitical Overview
+        with gr.Tab("🌍 Geopolitical Risk"):
             with gr.Row():
-                with gr.Column(scale=2):
-                    plot1 = gr.Plot() # Thematic Regime
-                    plot2 = gr.Plot() # Macro Dashboard
-                with gr.Column(scale=1):
-                    plot3 = gr.Plot() # Geopolitical Risk
+                start_1 = gr.Textbox("2023-01-01", label="Start Date", scale=1)
+                end_1 = gr.Textbox(datetime.today().strftime('%Y-%m-%d'), label="End Date", scale=1)
+                btn_1 = gr.Button("Update", variant="primary", scale=1)
             
-            update_btn_1.click(
-                fn=plot_thematic_regime, inputs=[start_date_1, end_date_1], outputs=plot1
-            ).then(
-                fn=plot_macro_dashboard, inputs=[start_date_1, end_date_1], outputs=plot2
+            with gr.Row():
+                plot_geo_risk = gr.Plot()
+                plot_safe_haven = gr.Plot()
+            
+            btn_1.click(
+                fn=plot_geopolitical_risk,
+                inputs=[start_1, end_1],
+                outputs=plot_geo_risk
             ).then(
-                fn=plot_geopolitical_risk, inputs=[start_date_1, end_date_1], outputs=plot3
+                fn=plot_safe_haven_flows,
+                inputs=[start_1, end_1],
+                outputs=plot_safe_haven
             )
-
-        # --- TAB 2: ASSET DEEP DIVE ---
-        with gr.Tab("🔬 Asset Deep Dive", id=1):
-            with gr.Accordion("🔬 Analysis Configuration", open=True):
-                with gr.Row():
-                    start_date_2 = gr.Textbox("2023-01-01", label="Start Date")
-                    end_date_2 = gr.Textbox(datetime.today().strftime('%Y-%m-%d'), label="End Date")
-                assets = gr.Dropdown(
-                    COMMON_TICKERS, value=['SP500', 'Gold', 'TLT', 'VIX'],
-                    multiselect=True, label="Select Assets for Analysis"
-                )
-            update_btn_2 = gr.Button("🔬 Run Deep Dive Analysis", variant="primary")
+        
+        # TAB 2: Macro Dashboard
+        with gr.Tab("📊 Macro Indicators"):
             with gr.Row():
-                plot4 = gr.Plot() # Performance
-                plot5 = gr.Plot() # Correlation
-            plot6 = gr.Plot() # Drawdown
+                start_2 = gr.Textbox("2023-01-01", label="Start Date", scale=1)
+                end_2 = gr.Textbox(datetime.today().strftime('%Y-%m-%d'), label="End Date", scale=1)
+                btn_2 = gr.Button("Update", variant="primary", scale=1)
             
-            update_btn_2.click(
-                fn=plot_multi_asset_performance, inputs=[start_date_2, end_date_2, assets], outputs=plot4
-            ).then(
-                fn=plot_correlation_heatmap, inputs=[start_date_2, end_date_2, assets], outputs=plot5
+            with gr.Row():
+                plot_macro = gr.Plot(scale=2)
+                plot_regional = gr.Plot(scale=1)
+            
+            btn_2.click(
+                fn=plot_macro_indicators,
+                inputs=[start_2, end_2],
+                outputs=plot_macro
             ).then(
-                fn=plot_drawdown_analysis, inputs=[start_date_2, end_date_2, assets], outputs=plot6
+                fn=plot_relative_strength,
+                inputs=[start_2, end_2],
+                outputs=plot_regional
             )
-
-        # --- TAB 3: FACTOR & ROTATIONAL ANALYSIS ---
-        with gr.Tab("🔭 Factor & Rotational Analysis", id=2):
-            with gr.Accordion("📅 Date Range Settings", open=False):
-                with gr.Row():
-                    start_date_3 = gr.Textbox("2023-01-01", label="Start Date")
-                    end_date_3 = gr.Textbox(datetime.today().strftime('%Y-%m-%d'), label="End Date")
-            update_btn_3 = gr.Button("🔄 Generate Analysis", variant="primary")
+        
+        # TAB 3: Custom Analysis
+        with gr.Tab("🔍 Custom Analysis"):
             with gr.Row():
-                plot7 = gr.Plot() # Factor Regime
-                plot8 = gr.Plot() # Sector Rotation
+                start_3 = gr.Textbox("2023-01-01", label="Start Date", scale=1)
+                end_3 = gr.Textbox(datetime.today().strftime('%Y-%m-%d'), label="End Date", scale=1)
             
-            update_btn_3.click(
-                fn=plot_factor_regime, inputs=[start_date_3, end_date_3], outputs=plot7
+            assets_select = gr.Dropdown(
+                AVAILABLE_ASSETS,
+                value=['US_Equity', 'Gold', 'Oil', 'VIX'],
+                multiselect=True,
+                label="Select Assets"
+            )
+            
+            btn_3 = gr.Button("Analyze", variant="primary")
+            
+            with gr.Row():
+                plot_corr = gr.Plot()
+                plot_dd = gr.Plot()
+            
+            btn_3.click(
+                fn=plot_correlation_matrix,
+                inputs=[start_3, end_3, assets_select],
+                outputs=plot_corr
             ).then(
-                fn=plot_sector_rotation, inputs=[start_date_3, end_date_3], outputs=plot8
+                fn=plot_drawdown,
+                inputs=[start_3, end_3, assets_select],
+                outputs=plot_dd
             )
-
-    # Initial load trigger
+    
+    # Load initial data
     demo.load(
-        fn=plot_thematic_regime, inputs=[start_date_1, end_date_1], outputs=plot1
-    ).then(
-        fn=plot_macro_dashboard, inputs=[start_date_1, end_date_1], outputs=plot2
-    ).then(
-        fn=plot_geopolitical_risk, inputs=[start_date_1, end_date_1], outputs=plot3
+        fn=plot_geopolitical_risk,
+        inputs=[start_1, end_1],
+        outputs=plot_geo_risk
     )
 
 if __name__ == "__main__":
-    demo.launch(debug=True)
+    demo.launch()