Update app.py

app.py

@@ -10,372 +10,358 @@ import os
 
 warnings.filterwarnings('ignore')
 
-# Import data engine (ensure file is named `geo_macro.py`)
+# Assume geo_macro.py exists and works as intended.
 from geo_macro import UnifiedMarketDataDownloader
 
 # ======================
 # CONFIGURATION
 # ======================
-
 DATA_FILE = 'unified_market_data.csv'
 CACHE_HOURS = 24
 
-# Modern dark theme
 COLORS = {
-    'primary': '#00D9FF',
-    'secondary': '#FF6B9D',
-    'accent': '#00FFAA',
-    'warning': '#FFB800',
-    'danger': '#FF3864',
-    'success': '#00FF88',
-    'bg_dark': '#0A0E27',
-    'bg_card': '#151932',
-    'grid': '#2a2e45'
+    '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
 }
 
-# Securely load FRED API key from environment (set as Secret in HF Spaces)
+# 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 will be skipped.")
+    print("⚠️ Warning: FRED_API_KEY not set. Economic data might be limited.")
 
 # ======================
-# DATA LOADING (File-based only)
+# DATA LOADING & MOCKING (if geo_macro.py is not available)
 # ======================
-
 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}")
-            return pd.read_csv(DATA_FILE, index_col=0, parse_dates=True)
-    
-    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}")
+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
 
 # ======================
-# FEATURE ENGINEERING
+# 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()
 
-def add_thematic_features(df):
+    # 1. Thematic Baskets (Momentum Z-Score)
     THEMES = {
-        "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"]
+        "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"],
     }
-
-    df = df.copy()
     for name, assets in THEMES.items():
-        available = [a for a in assets if a in df.columns]
+        available = [a for a in assets if a in df_out.columns]
         if available:
-            returns = df[available].pct_change()
-            mom = returns.mean(axis=1).rolling(60, min_periods=30).sum()
-            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
+            # 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_features(df)
+    return add_thematic_and_factor_features(df)
 
 # ======================
-# PLOT THEME
+# PLOTTING & AESTHETICS
 # ======================
-
-def modern_layout(title):
-    return dict(
-        plot_bgcolor=COLORS['bg_dark'],
-        paper_bgcolor=COLORS['bg_card'],
-        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'
+def monochrome_layout(title, height=500):
+    """Creates a professional, monochrome 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']),
+        hovermode='x unified',
+        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1),
+        height=height
     )
 
-# ======================
-# PLOT FUNCTIONS (FIXED)
-# ======================
-
-def plot_regime_dashboard(start_date, end_date):
-    df = get_processed_data()
-    df = df[(df.index >= pd.to_datetime(start_date)) & (df.index <= pd.to_datetime(end_date))]
-    
-    z_cols = [col for col in df.columns if col.endswith('_Z')]
-    if not z_cols:
-        return go.Figure()
-    
-    clean_names = [col.replace('_Z', '').replace('_', ' ') for col in z_cols]
-    heatmap_data = df[z_cols].fillna(0)
-    
+def plot_heatmap(df, title, colorscale='RdBu_r', zmid=0):
+    """Generic heatmap plotting function."""
     fig = go.Figure(go.Heatmap(
-        z=heatmap_data.T.values,
-        x=heatmap_data.index,
-        y=clean_names,
-        colorscale='RdBu_r',
-        zmid=0,
-        zmin=-3,
-        zmax=3,
-        colorbar=dict(title="Z-Score")  # ✅ FIXED: removed 'titleside'
+        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")
     ))
-    fig.update_layout(**modern_layout("🌍 Thematic Regime Heatmap"), height=600)
+    fig.update_layout(monochrome_layout(title, height=500))
     return fig
 
-def plot_thematic_pulse(start_date, end_date):
-    df = get_processed_data()
-    df = df[(df.index >= pd.to_datetime(start_date)) & (df.index <= pd.to_datetime(end_date))]
-    
-    theme_names = [
-        "AI & Datacenters", "Defense & Security", "Nuclear Renaissance",
-        "China Stress", "Commodity Inflation", "Gold & Safe Havens",
-        "Early Cycle", "Late Cycle", "Credit Stress", "Liquidity Conditions"
-    ]
-    z_cols = [f"{name}_Z" for name in theme_names if f"{name}_Z" in df.columns]
-    
-    if not z_cols:
-        return go.Figure()
-    
-    latest = df[z_cols].iloc[-1].dropna()
-    clean_names = [col.replace('_Z', '').replace('_', ' ') for col in latest.index]
-    latest.index = clean_names
-    
-    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
-        '#555'
-        for x in latest
-    ]
+# --- 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'}
+    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)
+    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"))
     
-    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(**modern_layout("🔥 Current Thematic Pulse"), height=600, xaxis_title="60-Day Momentum Z-Score")
+    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")
     return fig
 
 def plot_multi_asset_performance(start_date, end_date, assets):
-    df = get_processed_data()
-    df = df[(df.index >= pd.to_datetime(start_date)) & (df.index <= pd.to_datetime(end_date))]
+    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()
-    
+    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 len(prices) > 0:
+        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(**modern_layout("📈 Multi-Asset Performance (Normalized)"), height=600, yaxis_title="Index (Base = 100)")
+    fig.update_layout(monochrome_layout("📊 Multi-Asset Performance (Normalized)"),
+                      yaxis_title="Index (Base = 100)")
     return fig
 
 def plot_correlation_heatmap(start_date, end_date, assets):
-    df = get_processed_data()
-    df = df[(df.index >= pd.to_datetime(start_date)) & (df.index <= pd.to_datetime(end_date))]
+    df = get_processed_data().loc[start_date:end_date]
     available = [a for a in assets if a in df.columns]
-    if len(available) < 2:
-        return go.Figure()
-    
+    if len(available) < 2: return go.Figure().update_layout(monochrome_layout("Select 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}',
-        colorbar=dict(title="Correlation")  # ✅ FIXED: removed 'titleside'
+        z=corr.values, x=corr.columns, y=corr.columns,
+        colorscale='RdBu_r', zmid=0,
+        text=np.round(corr.values, 2), texttemplate='%{text}',
+        colorbar=dict(title="Correlation")
     ))
-    fig.update_layout(**modern_layout("🔗 Asset Correlation Matrix"), height=650, width=750)
+    fig.update_layout(monochrome_layout("🔗 Asset Correlation Matrix", height=600))
     return fig
 
 def plot_drawdown_analysis(start_date, end_date, assets):
-    df = get_processed_data()
-    df = df[(df.index >= pd.to_datetime(start_date)) & (df.index <= pd.to_datetime(end_date))]
+    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()
-    
-    fig = make_subplots(rows=2, cols=1, shared_xaxes=True,
-                        subplot_titles=('Cumulative Performance', 'Drawdown'),
-                        vertical_spacing=0.08, row_heights=[0.6, 0.4])
+    if not available: return go.Figure().update_layout(monochrome_layout("Select assets to plot"))
     
+    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 len(prices) > 0:
+        if not prices.empty:
             cum = (prices / prices.iloc[0]) * 100
-            drawdown = ((cum - cum.expanding().max()) / cum.expanding().max()) * 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', 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="Index (Base = 100)", 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)
     return fig
 
-def plot_rolling_sharpe(start_date, end_date, assets, window=252):
-    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:
-        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'])
-    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):
-    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']
+    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()
-    
-    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',
-        line_color=COLORS['primary']
+    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(
-        **modern_layout("🎯 Sector Rotation (3M Momentum %)"),
-        height=650,
+        monochrome_layout("🎯 Sector Rotation (3M Momentum %)"),
         polar=dict(
-            radialaxis=dict(visible=True, gridcolor=COLORS['grid'], range=[-10, 10]),
+            radialaxis=dict(visible=True, gridcolor=COLORS['grid']),
             angularaxis=dict(gridcolor=COLORS['grid'])
         )
     )
     return fig
 
-def plot_risk_dashboard(start_date, end_date):
-    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.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', 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
+# GRADIO UI DEFINITION
 # ======================
-
 custom_css = """
-.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; }
+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 }
 """
 
-# 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="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():
-        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", variant="primary").click(plot_regime_dashboard, [s1, e1], gr.Plot())
-        
-        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", variant="primary").click(plot_thematic_pulse, [s2, e2], gr.Plot())
-        
-        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(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())
-        
-        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(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())
-        
-        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(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())
-        
-        with gr.Tab("📊 Sharpe Ratio"):
+    '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")
+
+    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.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(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", variant="primary").click(plot_rolling_sharpe, [s6, e6, assets4, window], gr.Plot())
-        
-        with gr.Tab("🎯 Sectors"):
+                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
+            
+            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
+            ).then(
+                fn=plot_geopolitical_risk, inputs=[start_date_1, end_date_1], outputs=plot3
+            )
+
+        # --- 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")
             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", variant="primary").click(plot_sector_rotation, [s7, e7], gr.Plot())
-        
-        with gr.Tab("⚠️ Risk Monitor"):
+                plot4 = gr.Plot() # Performance
+                plot5 = gr.Plot() # Correlation
+            plot6 = gr.Plot() # Drawdown
+            
+            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
+            ).then(
+                fn=plot_drawdown_analysis, inputs=[start_date_2, end_date_2, assets], outputs=plot6
+            )
+
+        # --- 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")
             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", variant="primary").click(plot_risk_dashboard, [s8, e8], gr.Plot())
-    
-    gr.Markdown("---\n**Data**: Yahoo Finance + FRED | **Theme**: Nonlinear Regime Detection")
+                plot7 = gr.Plot() # Factor Regime
+                plot8 = gr.Plot() # Sector Rotation
+            
+            update_btn_3.click(
+                fn=plot_factor_regime, inputs=[start_date_3, end_date_3], outputs=plot7
+            ).then(
+                fn=plot_sector_rotation, inputs=[start_date_3, end_date_3], outputs=plot8
+            )
+
+    # Initial load trigger
+    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
+    )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(debug=True)