Update app.py

app.py

@@ -2,18 +2,16 @@
 import gradio as gr
 import pandas as pd
 import numpy as np
-import plotly.express as px
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
 from datetime import datetime, timedelta
 import warnings
-from functools import lru_cache
 import os
 
 warnings.filterwarnings('ignore')
 
-# Import your data engine
-from geo_macro import UnifiedMarketDataDownloader, FRED_API_KEY
+# Import data engine (ensure file is named `geo_macro.py`)
+from geo_macro import UnifiedMarketDataDownloader
 
 # ======================
 # CONFIGURATION
@@ -22,35 +20,36 @@ from geo_macro import UnifiedMarketDataDownloader, FRED_API_KEY
 DATA_FILE = 'unified_market_data.csv'
 CACHE_HOURS = 24
 
-# Color scheme for modern dark theme
+# Modern dark theme
 COLORS = {
     'primary': '#00D9FF',
     'secondary': '#FF6B9D',
-    'accent': '#C0FF00',
+    'accent': '#00FFAA',
     'warning': '#FFB800',
     'danger': '#FF3864',
     'success': '#00FF88',
     'bg_dark': '#0A0E27',
-    'bg_card': '#151932'
+    'bg_card': '#151932',
+    'grid': '#2a2e45'
 }
 
+# Securely load FRED API key from environment (set as Secret in HF Spaces)
+FRED_API_KEY = os.getenv("FRED_API_KEY")
+if not FRED_API_KEY:
+    print("⚠️ Warning: FRED_API_KEY not set. Economic data will be skipped.")
+
 # ======================
-# DATA LOADING & CACHING
+# DATA LOADING (File-based only)
 # ======================
 
-@lru_cache(maxsize=1)
-def load_or_download_data(force_refresh=False):
-    """Load data from cache or download fresh data"""
-    
-    # Check if cache exists and is fresh
-    if os.path.exists(DATA_FILE) and not force_refresh:
+def load_or_download_data():
+    """Load from CSV or download if missing"""
+    if os.path.exists(DATA_FILE):
         file_time = datetime.fromtimestamp(os.path.getmtime(DATA_FILE))
         if datetime.now() - file_time < timedelta(hours=CACHE_HOURS):
             print(f"📦 Loading cached data from {DATA_FILE}")
-            df = pd.read_csv(DATA_FILE, index_col=0, parse_dates=True)
-            return df
+            return pd.read_csv(DATA_FILE, index_col=0, parse_dates=True)
     
-    # Download fresh data
     print("🔄 Downloading fresh market data...")
     downloader = UnifiedMarketDataDownloader(fred_api_key=FRED_API_KEY)
     df = downloader.download_all_data(start_date='2018-01-01')
@@ -63,7 +62,6 @@ def load_or_download_data(force_refresh=False):
 # ======================
 
 def add_thematic_features(df):
-    """Add thematic momentum and z-scores"""
     THEMES = {
         "AI & Datacenters": ["Technology", "SMH", "SKYY", "BOTZ", "Cloud_Computing"],
         "Defense & Security": ["ITA", "XAR", "HACK", "Aerospace_Defense", "Defense_Stocks"],
@@ -81,96 +79,39 @@ def add_thematic_features(df):
     for name, assets in THEMES.items():
         available = [a for a in assets if a in df.columns]
         if available:
-            # Equal-weight momentum (60-day)
             returns = df[available].pct_change()
             mom = returns.mean(axis=1).rolling(60, min_periods=30).sum()
-            df[f"{name}_Momentum"] = mom
-            
-            # Z-score over 2 years
             mean = mom.rolling(500, min_periods=100).mean()
             std = mom.rolling(500, min_periods=100).std()
             df[f"{name}_Z"] = (mom - mean) / std
         else:
             df[f"{name}_Z"] = np.nan
-    
     return df
 
-def calculate_portfolio_metrics(df, assets, lookback=252):
-    """Calculate Sharpe, volatility, and drawdown for a portfolio"""
-    available = [a for a in assets if a in df.columns]
-    if not available:
-        return pd.DataFrame()
-    
-    returns = df[available].pct_change().mean(axis=1)
-    
-    metrics = pd.DataFrame(index=df.index)
-    metrics['Returns'] = returns
-    metrics['Cumulative'] = (1 + returns).cumprod()
-    metrics['Rolling_Vol'] = returns.rolling(lookback).std() * np.sqrt(252)
-    metrics['Rolling_Sharpe'] = (returns.rolling(lookback).mean() * 252) / metrics['Rolling_Vol']
-    
-    # Drawdown
-    cum_max = metrics['Cumulative'].expanding().max()
-    metrics['Drawdown'] = (metrics['Cumulative'] - cum_max) / cum_max
-    
-    return metrics
-
 def get_processed_data():
-    """Get data with all features"""
     df = load_or_download_data()
     return add_thematic_features(df)
 
 # ======================
-# ANALYSIS FUNCTIONS
+# PLOT THEME
 # ======================
 
-def analyze_regime_strength(df):
-    """Analyze current regime strength"""
-    z_cols = [col for col in df.columns if col.endswith('_Z')]
-    if not z_cols:
-        return pd.DataFrame()
-    
-    latest = df[z_cols].iloc[-1].dropna()
-    prev_week = df[z_cols].iloc[-5].dropna() if len(df) > 5 else latest
-    
-    analysis = pd.DataFrame({
-        'Current': latest,
-        'Week_Ago': prev_week,
-        'Change': latest - prev_week,
-        'Strength': latest.apply(lambda x: 'Strong' if abs(x) > 1.5 else 'Moderate' if abs(x) > 0.5 else 'Weak'),
-        'Direction': latest.apply(lambda x: 'Bullish' if x > 0 else 'Bearish')
-    })
-    
-    analysis.index = [col.replace('_Z', '').replace('_', ' ') for col in analysis.index]
-    return analysis.sort_values('Current', ascending=False)
-
-def calculate_correlation_matrix(df, assets, window=60):
-    """Calculate rolling correlation matrix"""
-    available = [a for a in assets if a in df.columns]
-    if len(available) < 2:
-        return pd.DataFrame()
-    
-    returns = df[available].pct_change()
-    corr = returns.rolling(window).corr()
-    
-    return corr
-
-# ======================
-# PLOT FUNCTIONS
-# ======================
-
-def create_modern_theme():
-    """Create modern plotly theme"""
+def modern_layout(title):
     return dict(
         plot_bgcolor=COLORS['bg_dark'],
         paper_bgcolor=COLORS['bg_card'],
-        font=dict(color='white', family='Arial, sans-serif'),
-        xaxis=dict(gridcolor='#2a2e45', showgrid=True),
-        yaxis=dict(gridcolor='#2a2e45', showgrid=True),
+        font=dict(color='white', size=13),
+        title=dict(text=title, font=dict(size=22, color=COLORS['accent']), x=0.5),
+        xaxis=dict(gridcolor=COLORS['grid'], showgrid=True),
+        yaxis=dict(gridcolor=COLORS['grid'], showgrid=True),
+        hovermode='x unified'
     )
 
+# ======================
+# PLOT FUNCTIONS (FIXED)
+# ======================
+
 def plot_regime_dashboard(start_date, end_date):
-    """Enhanced regime heatmap with annotations"""
     df = get_processed_data()
     df = df[(df.index >= pd.to_datetime(start_date)) & (df.index <= pd.to_datetime(end_date))]
     
@@ -181,7 +122,7 @@ def plot_regime_dashboard(start_date, end_date):
     clean_names = [col.replace('_Z', '').replace('_', ' ') for col in z_cols]
     heatmap_data = df[z_cols].fillna(0)
     
-    fig = go.Figure(data=go.Heatmap(
+    fig = go.Figure(go.Heatmap(
         z=heatmap_data.T.values,
         x=heatmap_data.index,
         y=clean_names,
@@ -189,29 +130,21 @@ def plot_regime_dashboard(start_date, end_date):
         zmid=0,
         zmin=-3,
         zmax=3,
-        colorbar=dict(title="Z-Score", titleside='right')
+        colorbar=dict(title="Z-Score")  # ✅ FIXED: removed 'titleside'
     ))
-    
-    fig.update_layout(
-        **create_modern_theme(),
-        title=dict(text="🌍 Thematic Regime Heatmap", font=dict(size=24)),
-        height=600,
-        xaxis_title="Date",
-        yaxis_title="Themes"
-    )
-    
+    fig.update_layout(**modern_layout("🌍 Thematic Regime Heatmap"), height=600)
     return fig
 
 def plot_thematic_pulse(start_date, end_date):
-    """Current thematic strength bar chart"""
     df = get_processed_data()
     df = df[(df.index >= pd.to_datetime(start_date)) & (df.index <= pd.to_datetime(end_date))]
     
-    z_cols = [f"{name}_Z" for name in [
+    theme_names = [
         "AI & Datacenters", "Defense & Security", "Nuclear Renaissance",
         "China Stress", "Commodity Inflation", "Gold & Safe Havens",
         "Early Cycle", "Late Cycle", "Credit Stress", "Liquidity Conditions"
-    ] if f"{name}_Z" in df.columns]
+    ]
+    z_cols = [f"{name}_Z" for name in theme_names if f"{name}_Z" in df.columns]
     
     if not z_cols:
         return go.Figure()
@@ -220,391 +153,229 @@ def plot_thematic_pulse(start_date, end_date):
     clean_names = [col.replace('_Z', '').replace('_', ' ') for col in latest.index]
     latest.index = clean_names
     
-    # Color coding based on strength
     colors = [
         COLORS['danger'] if x < -1.5 else 
         COLORS['warning'] if x < -0.5 else
         COLORS['success'] if x > 1.5 else
         COLORS['primary'] if x > 0.5 else
-        '#444444'
+        '#555'
         for x in latest
     ]
     
     fig = go.Figure(go.Bar(
-        x=latest.values, 
-        y=latest.index, 
-        orientation='h', 
-        marker_color=colors,
-        text=[f"{x:.2f}" for x in latest.values],
+        x=latest.values, y=latest.index, orientation='h',
+        marker_color=colors, text=[f"{x:.2f}" for x in latest.values],
         textposition='outside'
     ))
-    
-    fig.update_layout(
-        **create_modern_theme(),
-        title=dict(text="🔥 Current Thematic Pulse", font=dict(size=24)),
-        height=600,
-        xaxis_title="Z-Score",
-        yaxis_title="Themes"
-    )
-    
+    fig.update_layout(**modern_layout("🔥 Current Thematic Pulse"), height=600, xaxis_title="60-Day Momentum Z-Score")
     return fig
 
 def plot_multi_asset_performance(start_date, end_date, assets):
-    """Multi-asset normalized performance"""
     df = get_processed_data()
     df = df[(df.index >= pd.to_datetime(start_date)) & (df.index <= pd.to_datetime(end_date))]
-    
     available = [a for a in assets if a in df.columns]
     if not available:
         return go.Figure()
     
     fig = go.Figure()
-    
     for asset in available:
         prices = df[asset].dropna()
         if len(prices) > 0:
-            normalized = (prices / prices.iloc[0]) * 100
-            fig.add_trace(go.Scatter(
-                x=normalized.index, 
-                y=normalized, 
-                mode='lines', 
-                name=asset,
-                line=dict(width=2)
-            ))
-    
-    fig.update_layout(
-        **create_modern_theme(),
-        title=dict(text="📈 Multi-Asset Performance (Normalized)", font=dict(size=24)),
-        height=600,
-        xaxis_title="Date",
-        yaxis_title="Performance (Base = 100)",
-        hovermode='x unified'
-    )
+            norm = (prices / prices.iloc[0]) * 100
+            fig.add_trace(go.Scatter(x=norm.index, y=norm, mode='lines', name=asset))
     
+    fig.update_layout(**modern_layout("📈 Multi-Asset Performance (Normalized)"), height=600, yaxis_title="Index (Base = 100)")
     return fig
 
 def plot_correlation_heatmap(start_date, end_date, assets):
-    """Correlation matrix heatmap"""
     df = get_processed_data()
     df = df[(df.index >= pd.to_datetime(start_date)) & (df.index <= pd.to_datetime(end_date))]
-    
     available = [a for a in assets if a in df.columns]
     if len(available) < 2:
         return go.Figure()
     
-    returns = df[available].pct_change().dropna()
-    corr = returns.corr()
-    
-    fig = go.Figure(data=go.Heatmap(
+    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,
-        zmin=-1,
-        zmax=1,
         text=np.round(corr.values, 2),
         texttemplate='%{text}',
-        textfont={"size": 10},
-        colorbar=dict(title="Correlation")
+        colorbar=dict(title="Correlation")  # ✅ FIXED: removed 'titleside'
     ))
-    
-    fig.update_layout(
-        **create_modern_theme(),
-        title=dict(text="🔗 Asset Correlation Matrix", font=dict(size=24)),
-        height=700,
-        width=800
-    )
-    
+    fig.update_layout(**modern_layout("🔗 Asset Correlation Matrix"), height=650, width=750)
     return fig
 
 def plot_drawdown_analysis(start_date, end_date, assets):
-    """Drawdown analysis for selected assets"""
     df = get_processed_data()
     df = df[(df.index >= pd.to_datetime(start_date)) & (df.index <= pd.to_datetime(end_date))]
-    
     available = [a for a in assets if a in df.columns]
     if not available:
         return go.Figure()
     
     fig = make_subplots(rows=2, cols=1, shared_xaxes=True,
                         subplot_titles=('Cumulative Performance', 'Drawdown'),
-                        vertical_spacing=0.1, row_heights=[0.6, 0.4])
+                        vertical_spacing=0.08, row_heights=[0.6, 0.4])
     
     for asset in available:
         prices = df[asset].dropna()
         if len(prices) > 0:
-            cum_ret = (prices / prices.iloc[0]) * 100
-            cum_max = cum_ret.expanding().max()
-            drawdown = ((cum_ret - cum_max) / cum_max) * 100
-            
-            fig.add_trace(go.Scatter(x=cum_ret.index, y=cum_ret, mode='lines', name=asset),
-                         row=1, col=1)
-            fig.add_trace(go.Scatter(x=drawdown.index, y=drawdown, mode='lines', 
-                                    name=asset, showlegend=False, fill='tozeroy'),
-                         row=2, col=1)
-    
-    fig.update_layout(
-        **create_modern_theme(),
-        title=dict(text="📉 Drawdown Analysis", font=dict(size=24)),
-        height=800,
-        hovermode='x unified'
-    )
+            cum = (prices / prices.iloc[0]) * 100
+            drawdown = ((cum - cum.expanding().max()) / cum.expanding().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', showlegend=False), row=2, col=1)
     
+    fig.update_layout(**modern_layout("📉 Drawdown Analysis"), height=800)
     fig.update_xaxes(title_text="Date", row=2, col=1)
-    fig.update_yaxes(title_text="Performance (%)", row=1, col=1)
+    fig.update_yaxes(title_text="Index (Base = 100)", row=1, col=1)
     fig.update_yaxes(title_text="Drawdown (%)", row=2, col=1)
-    
     return fig
 
 def plot_rolling_sharpe(start_date, end_date, assets, window=252):
-    """Rolling Sharpe ratio analysis"""
     df = get_processed_data()
     df = df[(df.index >= pd.to_datetime(start_date)) & (df.index <= pd.to_datetime(end_date))]
-    
     available = [a for a in assets if a in df.columns]
     if not available:
         return go.Figure()
     
     fig = go.Figure()
-    
     for asset in available:
-        returns = df[asset].pct_change().dropna()
-        if len(returns) > window:
-            rolling_sharpe = (returns.rolling(window).mean() * 252) / (returns.rolling(window).std() * np.sqrt(252))
-            fig.add_trace(go.Scatter(
-                x=rolling_sharpe.index, 
-                y=rolling_sharpe, 
-                mode='lines', 
-                name=asset
-            ))
+        ret = df[asset].pct_change().dropna()
+        if len(ret) > window:
+            sharpe = (ret.rolling(window).mean() * 252) / (ret.rolling(window).std() * np.sqrt(252))
+            fig.add_trace(go.Scatter(x=sharpe.index, y=sharpe, mode='lines', name=asset))
     
     fig.add_hline(y=0, line_dash="dash", line_color="gray")
-    fig.add_hline(y=1, line_dash="dot", line_color=COLORS['success'], annotation_text="Sharpe=1")
-    
-    fig.update_layout(
-        **create_modern_theme(),
-        title=dict(text=f"📊 Rolling Sharpe Ratio ({window//252}Y)", font=dict(size=24)),
-        height=600,
-        xaxis_title="Date",
-        yaxis_title="Sharpe Ratio",
-        hovermode='x unified'
-    )
-    
+    fig.add_hline(y=1, line_dash="dot", line_color=COLORS['success'])
+    fig.update_layout(**modern_layout(f"📊 Rolling Sharpe Ratio ({window//252}Y)"), height=600, yaxis_title="Sharpe Ratio")
     return fig
 
 def plot_sector_rotation(start_date, end_date):
-    """Sector rotation spider chart"""
     df = get_processed_data()
     df = df[(df.index >= pd.to_datetime(start_date)) & (df.index <= pd.to_datetime(end_date))]
-    
     sectors = ['Technology', 'Financials', 'Healthcare', 'Consumer_Discretionary', 
                'Consumer_Staples', 'Energy', 'Materials', 'Industrials', 'Utilities', 
                'Real_Estate', 'Communication_Services']
-    
     available = [s for s in sectors if s in df.columns]
     if not available:
         return go.Figure()
     
-    # Calculate 3-month momentum
-    momentum = {}
-    for sector in available:
-        ret = df[sector].pct_change(60).iloc[-1] * 100
-        momentum[sector] = ret
-    
-    fig = go.Figure()
-    
-    fig.add_trace(go.Scatterpolar(
+    momentum = {s: df[s].pct_change(60).iloc[-1] * 100 for s in available}
+    fig = go.Figure(go.Scatterpolar(
         r=list(momentum.values()),
         theta=[s.replace('_', ' ') for s in momentum.keys()],
         fill='toself',
-        name='3M Momentum',
         line_color=COLORS['primary']
     ))
-    
     fig.update_layout(
-        **create_modern_theme(),
+        **modern_layout("🎯 Sector Rotation (3M Momentum %)"),
+        height=650,
         polar=dict(
-            radialaxis=dict(visible=True, gridcolor='#2a2e45'),
-            angularaxis=dict(gridcolor='#2a2e45')
-        ),
-        title=dict(text="🎯 Sector Rotation (3M Momentum %)", font=dict(size=24)),
-        height=700
+            radialaxis=dict(visible=True, gridcolor=COLORS['grid'], range=[-10, 10]),
+            angularaxis=dict(gridcolor=COLORS['grid'])
+        )
     )
-    
     return fig
 
 def plot_risk_dashboard(start_date, end_date):
-    """Risk indicators dashboard"""
     df = get_processed_data()
     df = df[(df.index >= pd.to_datetime(start_date)) & (df.index <= pd.to_datetime(end_date))]
-    
     risk_assets = ['VIX', 'HYG', 'T10Y2Y', 'DXY', 'Gold']
     available = [a for a in risk_assets if a in df.columns]
-    
     if not available:
         return go.Figure()
     
-    fig = make_subplots(
-        rows=len(available), cols=1,
-        shared_xaxes=True,
-        subplot_titles=[a.replace('_', ' ') for a in available],
-        vertical_spacing=0.05
-    )
+    fig = make_subplots(rows=len(available), cols=1, shared_xaxes=True,
+                        subplot_titles=[a.replace('_', ' ') for a in available],
+                        vertical_spacing=0.06)
     
     for i, asset in enumerate(available, 1):
         prices = df[asset].dropna()
         if len(prices) > 0:
-            fig.add_trace(
-                go.Scatter(x=prices.index, y=prices, mode='lines', 
-                          name=asset, line=dict(color=COLORS['primary'])),
-                row=i, col=1
-            )
-    
-    fig.update_layout(
-        **create_modern_theme(),
-        title=dict(text="⚠️ Risk Indicators Dashboard", font=dict(size=24)),
-        height=250 * len(available),
-        showlegend=False,
-        hovermode='x unified'
-    )
+            fig.add_trace(go.Scatter(x=prices.index, y=prices, mode='lines', line_color=COLORS['primary']), row=i, col=1)
     
+    fig.update_layout(**modern_layout("⚠️ Risk Indicators Dashboard"), height=220 * len(available), showlegend=False)
     return fig
 
 # ======================
 # GRADIO UI
 # ======================
 
-# Custom CSS for modern dark theme
 custom_css = """
-.gradio-container {
-    background: linear-gradient(135deg, #0A0E27 0%, #1a1f3a 100%) !important;
-}
-.tabs {
-    border-radius: 10px;
-}
-button {
-    border-radius: 8px !important;
-    font-weight: 600 !important;
-}
+.gradio-container { background: linear-gradient(135deg, #0A0E27 0%, #151932 100%) !important; }
+.tabs { border-radius: 12px; margin-top: 10px; }
+button { border-radius: 8px !important; font-weight: 600 !important; }
+.group { border-radius: 12px !important; background: #1a1f3a !important; padding: 16px !important; }
 """
 
-# Get all available tickers
-df_sample = load_or_download_data()
-all_tickers = sorted([col for col in df_sample.columns if not col.endswith('_Z') and not col.endswith('_Momentum')])
+# Use static list to avoid runtime data dependency
+COMMON_TICKERS = [
+    'SP500', 'NASDAQ', 'DJI', 'VIX', 'Gold', 'Oil', 'TLT', 'HYG', 'LQD', 'DGS10', 'DGS2',
+    'DXY', 'EURUSD', 'JPYUSD', 'Bitcoin', 'China', 'Europe', 'Japan', 'India',
+    'Technology', 'Financials', 'Energy', 'Healthcare', 'Utilities', 'SMH', 'KWEB',
+    'ITA', 'URA', 'REMX', 'XLE', 'GLD', 'M2', 'UNRATE', 'CPIAUCSL', 'T10Y2Y'
+]
 
-with gr.Blocks(title="Hedge Fund Intelligence Platform", css=custom_css, theme=gr.themes.Base()) as demo:
-    
-    gr.Markdown("""
-    # 🏦 Macro-Thematic Intelligence Platform
-    ### Professional-Grade Market Analytics & Regime Detection
-    """)
+with gr.Blocks(title="Macro-Thematic Intelligence Platform", css=custom_css, theme=gr.themes.Base()) as demo:
+    gr.Markdown("# 🌐 Macro-Thematic Intelligence Platform\n### Detect Regimes • Track Themes • Monitor Risk")
     
     with gr.Tabs():
-        
-        # Regime Analysis
         with gr.Tab("🌍 Regime Dashboard"):
             with gr.Row():
                 s1 = gr.Textbox("2023-01-01", label="Start Date")
                 e1 = gr.Textbox(datetime.today().strftime('%Y-%m-%d'), label="End Date")
-            gr.Button("🔄 Update Dashboard", variant="primary").click(
-                plot_regime_dashboard, [s1, e1], gr.Plot()
-            )
+            gr.Button("🔄 Update", variant="primary").click(plot_regime_dashboard, [s1, e1], gr.Plot())
         
-        # Thematic Pulse
         with gr.Tab("🔥 Thematic Pulse"):
             with gr.Row():
                 s2 = gr.Textbox("2023-01-01", label="Start Date")
                 e2 = gr.Textbox(datetime.today().strftime('%Y-%m-%d'), label="End Date")
-            gr.Button("🔄 Analyze Themes", variant="primary").click(
-                plot_thematic_pulse, [s2, e2], gr.Plot()
-            )
+            gr.Button("🔄 Analyze", variant="primary").click(plot_thematic_pulse, [s2, e2], gr.Plot())
         
-        # Multi-Asset Performance
-        with gr.Tab("📈 Performance Tracker"):
+        with gr.Tab("📈 Performance"):
             with gr.Row():
                 s3 = gr.Textbox("2023-01-01", label="Start Date")
                 e3 = gr.Textbox(datetime.today().strftime('%Y-%m-%d'), label="End Date")
-            assets1 = gr.Dropdown(
-                all_tickers, 
-                value=['SP500', 'NASDAQ', 'Gold', 'Oil', 'TLT'],
-                multiselect=True,
-                label="Select Assets"
-            )
-            gr.Button("📊 Plot Performance", variant="primary").click(
-                plot_multi_asset_performance, [s3, e3, assets1], gr.Plot()
-            )
+            assets1 = gr.Dropdown(COMMON_TICKERS, value=['SP500', 'Gold', 'TLT', 'Bitcoin'], multiselect=True, label="Assets")
+            gr.Button("📊 Plot", variant="primary").click(plot_multi_asset_performance, [s3, e3, assets1], gr.Plot())
         
-        # Correlation Analysis
-        with gr.Tab("🔗 Correlation Matrix"):
+        with gr.Tab("🔗 Correlations"):
             with gr.Row():
                 s4 = gr.Textbox("2023-01-01", label="Start Date")
                 e4 = gr.Textbox(datetime.today().strftime('%Y-%m-%d'), label="End Date")
-            assets2 = gr.Dropdown(
-                all_tickers,
-                value=['SP500', 'Gold', 'Oil', 'DXY', 'TLT', 'VIX'],
-                multiselect=True,
-                label="Select Assets"
-            )
-            gr.Button("🔍 Calculate Correlations", variant="primary").click(
-                plot_correlation_heatmap, [s4, e4, assets2], gr.Plot()
-            )
+            assets2 = gr.Dropdown(COMMON_TICKERS, value=['SP500', 'Gold', 'TLT', 'DXY', 'VIX'], multiselect=True, label="Assets")
+            gr.Button("🔍 Analyze", variant="primary").click(plot_correlation_heatmap, [s4, e4, assets2], gr.Plot())
         
-        # Drawdown Analysis
-        with gr.Tab("📉 Drawdown Analysis"):
+        with gr.Tab("📉 Drawdowns"):
             with gr.Row():
                 s5 = gr.Textbox("2023-01-01", label="Start Date")
                 e5 = gr.Textbox(datetime.today().strftime('%Y-%m-%d'), label="End Date")
-            assets3 = gr.Dropdown(
-                all_tickers,
-                value=['SP500', 'NASDAQ', 'Gold', 'Oil'],
-                multiselect=True,
-                label="Select Assets"
-            )
-            gr.Button("📉 Analyze Drawdowns", variant="primary").click(
-                plot_drawdown_analysis, [s5, e5, assets3], gr.Plot()
-            )
+            assets3 = gr.Dropdown(COMMON_TICKERS, value=['SP500', 'NASDAQ', 'Gold', 'Bitcoin'], multiselect=True, label="Assets")
+            gr.Button("📉 Analyze", variant="primary").click(plot_drawdown_analysis, [s5, e5, assets3], gr.Plot())
         
-        # Rolling Sharpe
         with gr.Tab("📊 Sharpe Ratio"):
             with gr.Row():
                 s6 = gr.Textbox("2023-01-01", label="Start Date")
                 e6 = gr.Textbox(datetime.today().strftime('%Y-%m-%d'), label="End Date")
-            assets4 = gr.Dropdown(
-                all_tickers,
-                value=['SP500', 'Gold', 'TLT'],
-                multiselect=True,
-                label="Select Assets"
-            )
+            assets4 = gr.Dropdown(COMMON_TICKERS, value=['SP500', 'TLT', 'Gold'], multiselect=True, label="Assets")
             window = gr.Slider(60, 504, value=252, step=21, label="Rolling Window (days)")
-            gr.Button("📈 Calculate Sharpe", variant="primary").click(
-                plot_rolling_sharpe, [s6, e6, assets4, window], gr.Plot()
-            )
+            gr.Button("📈 Calculate", variant="primary").click(plot_rolling_sharpe, [s6, e6, assets4, window], gr.Plot())
         
-        # Sector Rotation
-        with gr.Tab("🎯 Sector Rotation"):
+        with gr.Tab("🎯 Sectors"):
             with gr.Row():
                 s7 = gr.Textbox("2023-01-01", label="Start Date")
                 e7 = gr.Textbox(datetime.today().strftime('%Y-%m-%d'), label="End Date")
-            gr.Button("🔄 Analyze Sectors", variant="primary").click(
-                plot_sector_rotation, [s7, e7], gr.Plot()
-            )
+            gr.Button("🔄 Analyze", variant="primary").click(plot_sector_rotation, [s7, e7], gr.Plot())
         
-        # Risk Dashboard
         with gr.Tab("⚠️ Risk Monitor"):
             with gr.Row():
                 s8 = gr.Textbox("2023-01-01", label="Start Date")
                 e8 = gr.Textbox(datetime.today().strftime('%Y-%m-%d'), label="End Date")
-            gr.Button("🚨 Load Risk Indicators", variant="primary").click(
-                plot_risk_dashboard, [s8, e8], gr.Plot()
-            )
+            gr.Button("🚨 Load", variant="primary").click(plot_risk_dashboard, [s8, e8], gr.Plot())
     
-    gr.Markdown("""
-    ---
-    **Data Sources:** Yahoo Finance, FRED  
-    **Refresh Rate:** 24 hours  
-    **Last Updated:** Real-time market data
-    """)
+    gr.Markdown("---\n**Data**: Yahoo Finance + FRED | **Theme**: Nonlinear Regime Detection")
 
 if __name__ == "__main__":
     demo.launch()