Update app.py

app.py

@@ -4,22 +4,58 @@ 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
 
 # ======================
-# DATA LOADING & CACHING
+# CONFIGURATION
 # ======================
 
+DATA_FILE = 'unified_market_data.csv'
+CACHE_HOURS = 24
+
+# Color scheme for modern dark theme
+COLORS = {
+    'primary': '#00D9FF',
+    'secondary': '#FF6B9D',
+    'accent': '#C0FF00',
+    'warning': '#FFB800',
+    'danger': '#FF3864',
+    'success': '#00FF88',
+    'bg_dark': '#0A0E27',
+    'bg_card': '#151932'
+}
 
-def load_or_download_data():
+# ======================
+# DATA LOADING & CACHING
+# ======================
 
+@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:
+        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
+    
+    # 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')
-    df.to_csv(data_file)
-    print(f"💾 Saved to {data_file}")
+    df.to_csv(DATA_FILE)
+    print(f"💾 Saved to {DATA_FILE}")
     return df
 
 # ======================
@@ -27,51 +63,114 @@ def load_or_download_data():
 # ======================
 
 def add_thematic_features(df):
+    """Add thematic momentum and z-scores"""
     THEMES = {
-        "AI & Datacenters": ["XLK", "SMH", "SKYY", "BOTZ", "FINX"],
-        "Defense & Security": ["ITA", "XAR", "HACK", "URA", "Aerospace_Defense"],
-        "Nuclear Renaissance": ["URA", "XLE", "Utilities"],
-        "China Stress": ["KWEB", "FXI", "CNY=X"],
-        "Commodity Inflation": ["DBA", "DBB", "Oil", "Copper", "Gold"],
-        "Gold & Safe Havens": ["GLD", "TLT", "JPY=X", "CHF=X", "Gold"],
-        "Early Cycle": ["IWN", "XHB", "Staffing", "Small_Cap_Value"],
-        "Late Cycle": ["VYM", "XLU", "Consumer_Staples", "High_Dividend"],
-        "Credit Stress": ["EMB", "HYG", "BKLN", "JNK", "Preferred_Stock"],
-        "Liquidity Conditions": ["M2", "WALCL", "Short_Term_Treasuries"]
+        "AI & Datacenters": ["Technology", "SMH", "SKYY", "BOTZ", "Cloud_Computing"],
+        "Defense & Security": ["ITA", "XAR", "HACK", "Aerospace_Defense", "Defense_Stocks"],
+        "Nuclear Renaissance": ["URA", "Energy", "Utilities", "Energy_Security"],
+        "China Stress": ["KWEB", "FXI", "CNY", "China", "China_Tech"],
+        "Commodity Inflation": ["DBA", "DBB", "Oil", "Copper", "Gold", "Agricultural"],
+        "Gold & Safe Havens": ["Gold", "Gold_Safe_Haven", "TLT", "JPY", "CHF", "Gold_Miners"],
+        "Early Cycle": ["Small_Cap_Value", "XHB", "Homebuilders", "Regional_Banks"],
+        "Late Cycle": ["High_Dividend", "Utilities", "Consumer_Staples", "Value_Stocks"],
+        "Credit Stress": ["Emerging_Market_Debt", "HYG", "Leveraged_Loans", "JNK"],
+        "Liquidity Conditions": ["M2", "WALCL", "Short_Term_Treasuries", "Preferred_Stock"]
     }
 
     df = df.copy()
     for name, assets in THEMES.items():
         available = [a for a in assets if a in df.columns]
         if available:
-            # Equal-weight momentum
-            mom = df[available].pct_change().mean(axis=1)
-            df[f"{name}_Momentum"] = mom.rolling(60).sum()
+            # 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 = df[f"{name}_Momentum"].rolling(500, min_periods=100).mean()
-            std = df[f"{name}_Momentum"].rolling(500, min_periods=100).std()
-            df[f"{name}_Z"] = (df[f"{name}_Momentum"] - mean) / std
+            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
 
-# ======================
-# PLOT FUNCTIONS (same as before, but use cached data)
-# ======================
-
-SHOCK_EVENTS = {
-    "2020-03-16 (Pandemic Crash)": "2020-03-16",
-    "2022-02-24 (Ukraine Invasion)": "2022-02-24",
-    "2023-03-10 (SVB Collapse)": "2023-03-10",
-    "2024-01-15 (Debt Ceiling)": "2024-01-15",
-    "2025-04-01 (Middle East Escalation)": "2025-04-01"
-}
+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
+# ======================
+
+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"""
+    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),
+    )
+
 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))]
     
@@ -86,13 +185,25 @@ def plot_regime_dashboard(start_date, end_date):
         z=heatmap_data.T.values,
         x=heatmap_data.index,
         y=clean_names,
-        colorscale='RdBu',
-        zmid=0
+        colorscale='RdBu_r',
+        zmid=0,
+        zmin=-3,
+        zmax=3,
+        colorbar=dict(title="Z-Score", titleside='right')
     ))
-    fig.update_layout(title="🌍 Thematic Regime Heatmap", height=500)
+    
+    fig.update_layout(
+        **create_modern_theme(),
+        title=dict(text="🌍 Thematic Regime Heatmap", font=dict(size=24)),
+        height=600,
+        xaxis_title="Date",
+        yaxis_title="Themes"
+    )
+    
     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))]
     
@@ -109,93 +220,391 @@ def plot_thematic_pulse(start_date, end_date):
     clean_names = [col.replace('_Z', '').replace('_', ' ') for col in latest.index]
     latest.index = clean_names
     
-    colors = ['red' if x < -1.5 else 'green' if x > 1.5 else 'lightgray' for x in latest]
-    fig = go.Figure(go.Bar(x=latest.values, y=latest.index, orientation='h', marker_color=colors))
-    fig.update_layout(title="🔥 Thematic Pulse", height=500)
+    # 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'
+        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],
+        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"
+    )
+    
+    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'
+    )
+    
+    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(
+        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")
+    ))
+    
+    fig.update_layout(
+        **create_modern_theme(),
+        title=dict(text="🔗 Asset Correlation Matrix", font=dict(size=24)),
+        height=700,
+        width=800
+    )
+    
     return fig
 
-def plot_divergence(start_date, end_date):
+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))]
     
-    if 'KWEB' in df.columns and 'SMH' in df.columns:
-        ratio = df['KWEB'] / df['SMH']
-        ratio_norm = (ratio - ratio.rolling(200).mean()) / ratio.rolling(200).std()
-        fig = go.Figure()
-        fig.add_trace(go.Scatter(x=ratio.index, y=ratio, name='KWEB/SMH'))
-        fig.add_trace(go.Scatter(x=ratio_norm.index, y=ratio_norm, name='Z-Score', yaxis='y2'))
-        fig.update_layout(
-            title="🔄 China Tech vs Global Semis",
-            yaxis2=dict(overlaying='y', side='right')
-        )
-        return fig
-    return go.Figure()
-
-def plot_shock_response(event_name, custom_date=None):
+    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])
+    
+    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'
+    )
+    
+    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="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
+            ))
     
-    if event_name != "Custom Date":
-        event_date = pd.to_datetime(SHOCK_EVENTS[event_name])
-    else:
-        if not custom_date:
-            return go.Figure()
-        event_date = pd.to_datetime(custom_date)
+    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")
     
-    window = 30
-    start = event_date - timedelta(days=window)
-    end = event_date + timedelta(days=window)
-    df_win = df[(df.index >= start) & (df.index <= end)]
+    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'
+    )
+    
+    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))]
     
-    if df_win.empty:
+    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()
     
-    assets = ['SP500', 'Gold', 'TLT', 'VIX', 'Oil', 'KWEB', 'SMH', 'ITA']
+    # Calculate 3-month momentum
+    momentum = {}
+    for sector in available:
+        ret = df[sector].pct_change(60).iloc[-1] * 100
+        momentum[sector] = ret
+    
     fig = go.Figure()
-    event_idx = df_win.index.get_indexer([event_date], method='nearest')[0]
     
-    for asset in assets:
-        if asset in df_win.columns:
-            prices = df_win[asset].dropna()
-            if len(prices) > 5:
-                norm = (prices / prices.iloc[event_idx]) * 100
-                fig.add_trace(go.Scatter(x=norm.index, y=norm, mode='lines', name=asset))
+    fig.add_trace(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(),
+        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
+    )
+    
+    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
+    )
+    
+    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_vline(x=event_date, line_dash="dash", line_color="red")
-    fig.update_layout(title=f"📅 Shock: {event_name}", yaxis_title="Normalized to 100")
     return fig
 
 # ======================
 # GRADIO UI
 # ======================
 
-with gr.Blocks(title="Macro-Thematic Intelligence") as demo:
-    gr.Markdown("## 🌐 Top-Down Thematic Intelligence Platform")
+# 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;
+}
+"""
+
+# 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')])
+
+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.Tabs():
+        
+        # Regime Analysis
         with gr.Tab("🌍 Regime Dashboard"):
-            s1 = gr.Textbox("2022-01-01", label="Start")
-            e1 = gr.Textbox(datetime.today().strftime('%Y-%m-%d'), label="End")
-            p1 = gr.Plot()
-            gr.Button("Update").click(plot_regime_dashboard, [s1, e1], p1)
+            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()
+            )
         
+        # Thematic Pulse
         with gr.Tab("🔥 Thematic Pulse"):
-            s2 = gr.Textbox("2022-01-01", label="Start")
-            e2 = gr.Textbox(datetime.today().strftime('%Y-%m-%d'), label="End")
-            p2 = gr.Plot()
-            gr.Button("Update").click(plot_thematic_pulse, [s2, e2], p2)
+            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()
+            )
+        
+        # Multi-Asset Performance
+        with gr.Tab("📈 Performance Tracker"):
+            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()
+            )
+        
+        # Correlation Analysis
+        with gr.Tab("🔗 Correlation Matrix"):
+            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()
+            )
         
-        with gr.Tab("🔄 Divergence"):
-            s3 = gr.Textbox("2022-01-01", label="Start")
-            e3 = gr.Textbox(datetime.today().strftime('%Y-%m-%d'), label="End")
-            p3 = gr.Plot()
-            gr.Button("Update").click(plot_divergence, [s3, e3], p3)
+        # Drawdown Analysis
+        with gr.Tab("📉 Drawdown Analysis"):
+            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()
+            )
         
-        with gr.Tab("📅 Shock Explorer"):
-            evt = gr.Dropdown(list(SHOCK_EVENTS.keys()) + ["Custom Date"], value=list(SHOCK_EVENTS.keys())[0])
-            cdt = gr.Textbox("", visible=False)
-            evt.change(lambda x: gr.update(visible=x=="Custom Date"), evt, cdt)
-            p4 = gr.Plot()
-            gr.Button("Plot").click(plot_shock_response, [evt, cdt], p4)
+        # 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"
+            )
+            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()
+            )
+        
+        # Sector Rotation
+        with gr.Tab("🎯 Sector Rotation"):
+            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()
+            )
+        
+        # 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.Markdown("""
+    ---
+    **Data Sources:** Yahoo Finance, FRED  
+    **Refresh Rate:** 24 hours  
+    **Last Updated:** Real-time market data
+    """)
 
 if __name__ == "__main__":
     demo.launch()