Update app.py

app.py

@@ -1,508 +1,209 @@
-import os
+# app.py
+import gradio as gr
 import pandas as pd
 import numpy as np
-import gradio as gr
-import plotly.graph_objects as go
-from plotly.subplots import make_subplots
 import plotly.express as px
-import yfinance as yf
-import requests
+import plotly.graph_objects as go
 from datetime import datetime, timedelta
-from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
-from prophet import Prophet
-import warnings
-import logging
-import asyncio
-import concurrent.futures
-import tempfile
-from functools import lru_cache
-from typing import Dict, List, Optional, Any, Tuple
-
-warnings.filterwarnings("ignore")
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger("unified_stock_app")
-
-# Optional: Try importing TimesFM
-TIMESFM_AVAILABLE = False
-try:
-    import timesfm
-    TIMESFM_AVAILABLE = True
-except ImportError:
-    pass
-
-# ============================================================================
-# CONFIGURATION
-# ============================================================================
-class Config:
-    FINNHUB_API_KEY = os.getenv("FINNHUB_API_KEY", "cuj17q1r01qm7p9n307gcuj17q1r01qm7p9n3080")
-    DATA_DIR = "data_cache"
-    CACHE_TTL_HOURS = 12
-    SENTIMENT_DAYS = 90
-    TECH_DATA_YEARS = 3
-
-    @classmethod
-    def initialize(cls):
-        os.makedirs(cls.DATA_DIR, exist_ok=True)
 
-Config.initialize()
+# Import your data engine
+from geo_macro import UnifiedMarketDataDownloader, FRED_API_KEY
 
-# ============================================================================
-# CACHING UTILS
-# ============================================================================
-class CacheManager:
-    @staticmethod
-    def get_path(filename: str) -> str:
-        return os.path.join(Config.DATA_DIR, filename)
+# ======================
+# DATA LOADING & CACHING
+# ======================
 
-    @staticmethod
-    def save_df(df: pd.DataFrame, filename: str):
-        df.to_csv(CacheManager.get_path(filename), index=False)
-
-    @staticmethod
-    def load_df(filename: str) -> Optional[pd.DataFrame]:
-        path = CacheManager.get_path(filename)
-        if not os.path.exists(path):
-            return None
-        file_mod_time = datetime.fromtimestamp(os.path.getmtime(path))
-        if datetime.now() - file_mod_time > timedelta(hours=Config.CACHE_TTL_HOURS):
-            return None
-        try:
-            df = pd.read_csv(path)
-            for col in df.columns:
-                if 'date' in col.lower():
-                    df[col] = pd.to_datetime(df[col])
-            return df
-        except Exception:
-            return None
-
-# ============================================================================
-# FUNDAMENTALS MODULE
-# ============================================================================
-@lru_cache(maxsize=100)
-def get_financial_data(ticker: str) -> Optional[Dict[str, Any]]:
+@gr.cache
+def load_or_download_data():
+    """
+    Load from CSV if exists, else download fresh data.
+    """
+    data_file = "unified_market_data.csv"
     try:
-        stock = yf.Ticker(ticker)
-        info = stock.info
-        return {
-            'Ticker': ticker,
-            'PE_Ratio': info.get('forwardPE'),
-            'Debt_to_Equity': info.get('debtToEquity'),
-            'Revenue_Growth': info.get('revenueGrowth'),
-            'ROE': info.get('returnOnEquity'),
-            'ROA': info.get('returnOnAssets'),
-            'Gross_Margin': info.get('grossMargins'),
-            'EBITDA': info.get('ebitda'),
-            'Market_Cap': info.get('marketCap'),
-            'Dividend_Yield': info.get('dividendYield'),
-            'Profit_Margin': info.get('profitMargins'),
-            'EPS_Growth': info.get('earningsGrowth'),
-            'Price_to_Book': info.get('priceToBook'),
-            'Current_Price': info.get('currentPrice')
-        }
-    except Exception as e:
-        logger.error(f"Error fetching data for {ticker}: {e}")
-        return None
-
-async def fetch_data_concurrently(tickers: List[str]) -> List[Dict[str, Any]]:
-    loop = asyncio.get_event_loop()
-    with concurrent.futures.ThreadPoolExecutor() as executor:
-        tasks = [loop.run_in_executor(executor, get_financial_data, ticker) for ticker in tickers]
-        results = await asyncio.gather(*tasks)
-    return [r for r in results if r is not None]
-
-def sanitize_financial_data(df: pd.DataFrame) -> pd.DataFrame:
-    df = df.copy()
-    for col in ['ROE', 'ROA', 'Profit_Margin', 'Gross_Margin']:
-        if col in df.columns:
-            df[col] = df[col].where((df[col] >= -2) & (df[col] <= 2), np.nan)
-    for col in ['Revenue_Growth', 'EPS_Growth']:
-        if col in df.columns:
-            df[col] = df[col].where((df[col] >= -1) & (df[col] <= 5), np.nan)
-    for col in ['Debt_to_Equity', 'Dividend_Yield']:
-        if col in df.columns:
-            df[col] = df[col].where(df[col] >= 0, np.nan)
-    for col in ['PE_Ratio', 'Price_to_Book']:
-        if col in df.columns:
-            df[col] = df[col].where((df[col] > 0) & (df[col] < 1000), np.nan)
-    for col in ['Market_Cap', 'EBITDA']:
-        if col in df.columns:
-            df[col] = df[col].where(df[col] > 0, np.nan)
-    if 'Current_Price' in df.columns:
-        df['Current_Price'] = df['Current_Price'].where(df['Current_Price'] > 0, np.nan)
+        df = pd.read_csv(data_file, index_col=0, parse_dates=True)
+        print("✅ Loaded data from CSV")
+    except FileNotFoundError:
+        print("🔄 CSV not found. Downloading fresh 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}")
     return df
 
-def normalize(series: pd.Series, reverse: bool = False, lower_percentile: float = 0.10, upper_percentile: float = 0.90) -> pd.Series:
-    valid_series = series.dropna()
-    if len(valid_series) == 0 or len(valid_series.unique()) <= 1:
-        return pd.Series(5.0, index=series.index, dtype=float)
-    q_low = valid_series.quantile(lower_percentile)
-    q_high = valid_series.quantile(upper_percentile)
-    if q_high <= q_low:
-        return pd.Series(5.0, index=series.index, dtype=float)
-    clipped = series.clip(q_low, q_high)
-    normalized = (clipped - q_low) / (q_high - q_low)
-    normalized = normalized.clip(0, 1)
-    result = 10 * (1 - normalized) if reverse else 10 * normalized
-    return result
-
-def calculate_scores(df: pd.DataFrame, growth_weight: float, value_weight: float, risk_weight: float) -> pd.DataFrame:
-    scored_df = df.copy()
-    scored_df['Revenue_Growth_Score'] = normalize(df['Revenue_Growth'])
-    scored_df['EPS_Growth_Score'] = normalize(df['EPS_Growth'])
-    scored_df['ROE_Score'] = normalize(df['ROE'])
-    scored_df['ROA_Score'] = normalize(df['ROA'])
-    scored_df['Growth_Score'] = scored_df[['Revenue_Growth_Score', 'EPS_Growth_Score', 'ROE_Score', 'ROA_Score']].mean(axis=1)
-
-    scored_df['PE_Ratio_Score'] = normalize(df['PE_Ratio'], reverse=True)
-    scored_df['Price_to_Book_Score'] = normalize(df['Price_to_Book'], reverse=True)
-    scored_df['Dividend_Yield_Score'] = normalize(df['Dividend_Yield'])
-    scored_df['Value_Score'] = scored_df[['PE_Ratio_Score', 'Price_to_Book_Score', 'Dividend_Yield_Score']].mean(axis=1)
-
-    scored_df['Debt_to_Equity_No_Risk_Score'] = normalize(df['Debt_to_Equity'], reverse=True)
-    scored_df['Profit_Margin_No_Risk_Score'] = normalize(df['Profit_Margin'])
-    scored_df['Market_Cap_No_Risk_Score'] = normalize(df['Market_Cap'])
-    scored_df['No_Risk_Score'] = scored_df[['Debt_to_Equity_No_Risk_Score', 'Profit_Margin_No_Risk_Score', 'Market_Cap_No_Risk_Score']].mean(axis=1)
-
-    total = growth_weight + value_weight + risk_weight
-    if total == 0:
-        gw = vw = rw = 1/3
-    else:
-        gw, vw, rw = growth_weight/total, value_weight/total, risk_weight/total
-    scored_df['Total_Score'] = gw * scored_df['Growth_Score'] + vw * scored_df['Value_Score'] + rw * scored_df['No_Risk_Score']
-    return scored_df
-
-def create_metrics_table(df: pd.DataFrame) -> pd.DataFrame:
-    metrics_df = df[['Ticker', 'Current_Price', 'PE_Ratio', 'Price_to_Book', 
-                     'Debt_to_Equity', 'ROE', 'ROA', 'Revenue_Growth', 
-                     'EPS_Growth', 'Profit_Margin', 'Dividend_Yield']].copy()
-    for col in ['ROE', 'ROA', 'Revenue_Growth', 'EPS_Growth', 'Profit_Margin', 'Dividend_Yield']:
-        metrics_df[col] = metrics_df[col].apply(lambda x: f"{x*100:.2f}%" if pd.notnull(x) else "N/A")
-    for col in ['PE_Ratio', 'Price_to_Book', 'Debt_to_Equity']:
-        metrics_df[col] = metrics_df[col].apply(lambda x: f"{x:.2f}" if pd.notnull(x) else "N/A")
-    metrics_df['Current_Price'] = metrics_df['Current_Price'].apply(lambda x: f"${x:.2f}" if pd.notnull(x) else "N/A")
-    return metrics_df
-
-# ============================================================================
-# SENTIMENT MODULE
-# ============================================================================
-class SentimentAnalyzer:
-    def __init__(self):
-        self.analyzer = SentimentIntensityAnalyzer()
-    def analyze(self, text):
-        if not isinstance(text, str) or not text.strip():
-            return 0
-        return self.analyzer.polarity_scores(text)['compound']
-
-class StockNewsAnalyzer:
-    def __init__(self, symbol):
-        self.symbol = symbol
-        self.sentiment_analyzer = SentimentAnalyzer()
-
-    def get_news(self, days=Config.SENTIMENT_DAYS, force_refresh=False):
-        cache_file = f"{self.symbol}_news.csv"
-        df = CacheManager.load_df(cache_file)
-        if df is not None and not force_refresh:
-            return df
-
-        end_date = datetime.now()
-        start_date = end_date - timedelta(days=days)
-        # FIXED URL: NO TRAILING SPACES!
-        url = "https://finnhub.io/api/v1/company-news"
-        params = {
-            "symbol": self.symbol,
-            "from": start_date.strftime('%Y-%m-%d'),
-            "to": end_date.strftime('%Y-%m-%d'),
-            "token": Config.FINNHUB_API_KEY,
-        }
-        try:
-            response = requests.get(url, params=params, timeout=10)
-            response.raise_for_status()
-            data = response.json()
-            if not data or not isinstance(data, list):
-                return pd.DataFrame()
-            df = pd.DataFrame(data)
-            if 'datetime' in df.columns:
-                df['datetime'] = pd.to_datetime(df['datetime'], unit='s')
-                CacheManager.save_df(df, cache_file)
-                return df
-            return pd.DataFrame()
-        except Exception as e:
-            print(f"Error fetching news: {e}")
-            return pd.DataFrame()
-
-    def get_sentiment_data(self, days=Config.SENTIMENT_DAYS, force_refresh=False):
-        news_df = self.get_news(days, force_refresh)
-        if news_df.empty or 'headline' not in news_df.columns:
-            return None, None
-        news_df['sentiment'] = news_df['headline'].apply(self.sentiment_analyzer.analyze)
-        news_df['date'] = pd.to_datetime(news_df['datetime'].dt.date)
-        daily = news_df.groupby('date').agg(
-            avg_sentiment=('sentiment', 'mean'),
-            article_count=('sentiment', 'count'),
-            positive_count=('sentiment', lambda x: (x > 0.05).sum()),
-            negative_count=('sentiment', lambda x: (x < -0.05).sum()),
-            neutral_count=('sentiment', lambda x: ((x >= -0.05) & (x <= 0.05)).sum())
-        ).reset_index()
-        return daily, news_df
-
-def create_sentiment_plot(daily_sentiment: pd.DataFrame, symbol: str) -> go.Figure:
-    fig = make_subplots(rows=2, cols=1, shared_xaxes=True, row_heights=[0.7, 0.3])
-    fig.add_trace(go.Scatter(x=daily_sentiment['date'], y=daily_sentiment['avg_sentiment'], name='Avg Sentiment', line=dict(color='#ff7f0e')), row=1, col=1)
-    fig.add_trace(go.Bar(x=daily_sentiment['date'], y=daily_sentiment['positive_count'], name='Positive', marker_color='rgba(0,200,0,0.7)'), row=2, col=1)
-    fig.add_trace(go.Bar(x=daily_sentiment['date'], y=daily_sentiment['negative_count'], name='Negative', marker_color='rgba(255,0,0,0.7)'), row=2, col=1)
-    fig.add_trace(go.Bar(x=daily_sentiment['date'], y=daily_sentiment['neutral_count'], name='Neutral', marker_color='rgba(128,128,128,0.6)'), row=2, col=1)
-    fig.update_layout(title=f"{symbol} News Sentiment (Last {Config.SENTIMENT_DAYS} Days)", template="plotly_dark", barmode='stack', height=500)
-    return fig
-
-# ============================================================================
-# TECHNICAL & FORECASTING MODULES
-# ============================================================================
-def calculate_rsi(df):
-    delta = df['Close'].diff()
-    gain = (delta.where(delta > 0, 0)).rolling(14).mean()
-    loss = (-delta.where(delta < 0, 0)).rolling(14).mean()
-    rs = gain / loss
-    return 100 - (100 / (1 + rs))
-
-def calculate_bollinger_bands(df):
-    ma = df['Close'].rolling(20).mean()
-    std = df['Close'].rolling(20).std()
-    return ma, ma + 2*std, ma - 2*std
-
-def calculate_stochastic_oscillator(df):
-    ll = df['Low'].rolling(14).min()
-    hh = df['High'].rolling(14).max()
-    k = ((df['Close'] - ll) / (hh - ll)) * 100
-    d = k.rolling(3).mean()
-    return k, d
-
-def calculate_cmf(df, window=20):
-    price_range = df['High'] - df['Low']
-    price_range = price_range.replace(0, np.nan)
-    mfv = ((df['Close'] - df['Low']) - (df['High'] - df['Close'])) / price_range * df['Volume']
-    mfv_sum = mfv.rolling(window).sum()
-    vol_sum = df['Volume'].rolling(window).sum()
-    return np.where(vol_sum > 0, mfv_sum / vol_sum, np.nan)
+# ======================
+# FEATURE ENGINEERING
+# ======================
+
+def add_thematic_features(df):
+    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"]
+    }
 
-def generate_signals(df):
     df = df.copy()
-    df['RSI'] = calculate_rsi(df)
-    df['MiddleBB'], df['UpperBB'], df['LowerBB'] = calculate_bollinger_bands(df)
-    df['SlowK'], df['SlowD'] = calculate_stochastic_oscillator(df)
-    df['CMF'] = calculate_cmf(df)
-
-    df['RSI_Signal'] = np.where(df['RSI'] < 20, 1, np.where(df['RSI'] > 80, -1, 0))
-    df['BB_Signal'] = np.where(df['Close'] < df['LowerBB'], 1, np.where(df['Close'] > df['UpperBB'], -1, 0))
-    df['Stochastic_Signal'] = np.where((df['SlowK'] < 15) & (df['SlowD'] < 15), 1, np.where((df['SlowK'] > 85) & (df['SlowD'] > 85), -1, 0))
-    df['CMF_Signal'] = np.where(df['CMF'] < -0.25, 1, np.where(df['CMF'] > 0.25, -1, 0))
-    df['Technical_Score'] = df[['RSI_Signal', 'BB_Signal', 'Stochastic_Signal', 'CMF_Signal']].sum(axis=1)
+    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()
+            # 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
+        else:
+            df[f"{name}_Z"] = np.nan
     return df
 
-def prophet_forecast(ticker, start_date, end_date):
-    try:
-        df = yf.download(ticker, start=start_date, end=end_date)
-        if isinstance(df.columns, pd.MultiIndex):
-            df.columns = df.columns.droplevel(1)
-        df_plot = df.reset_index()[['Date', 'Close']].rename(columns={'Date': 'ds', 'Close': 'y'})
-        model = Prophet()
-        model.fit(df_plot)
-        future = model.make_future_dataframe(periods=30)
-        forecast = model.predict(future)
-        fig1 = go.Figure()
-        fig1.add_trace(go.Scatter(x=df_plot['ds'], y=df_plot['y'], mode='lines', name='Actual'))
-        fig1.add_trace(go.Scatter(x=forecast['ds'], y=forecast['trend'], mode='lines', name='Trend'))
-        fig1.update_layout(title=f"{ticker} Price & Trend", template="plotly_dark")
+# ======================
+# 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 get_processed_data():
+    df = load_or_download_data()
+    return add_thematic_features(df)
+
+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)
+    
+    fig = go.Figure(data=go.Heatmap(
+        z=heatmap_data.T.values,
+        x=heatmap_data.index,
+        y=clean_names,
+        colorscale='RdBu',
+        zmid=0
+    ))
+    fig.update_layout(title="🌍 Thematic Regime Heatmap", height=500)
+    return fig
 
-        fig2 = go.Figure()
-        tail = forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail(40)
-        fig2.add_trace(go.Scatter(x=tail['ds'], y=tail['yhat'], mode='lines', name='Forecast'))
-        fig2.add_trace(go.Scatter(x=list(tail['ds']) + list(tail['ds'])[::-1],
-                                 y=list(tail['yhat_upper']) + list(tail['yhat_lower'])[::-1],
-                                 fill='toself', name='Confidence'))
-        fig2.update_layout(title=f"{ticker} 30-Day Forecast", template="plotly_dark")
-        return fig1, fig2
-    except Exception as e:
-        empty = go.Figure()
-        empty.add_annotation(text=f"Error: {e}", x=0.5, y=0.5, xref="paper", yref="paper")
-        return empty, empty
+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))]
+    
+    z_cols = [f"{name}_Z" for name in [
+        "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]
+    
+    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 = ['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)
+    return fig
 
-def timesfm_forecast(ticker, start_date, end_date):
-    if not TIMESFM_AVAILABLE:
+def plot_divergence(start_date, end_date):
+    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_annotation(text="TimesFM not installed", x=0.5, y=0.5, xref="paper", yref="paper")
-        fig.update_layout(template="plotly_dark")
-        return fig
-    try:
-        df = yf.download(ticker, start=start_date, end=end_date)
-        if isinstance(df.columns, pd.MultiIndex):
-            df.columns = df.columns.droplevel(1)
-        df = df.reset_index()[['Date', 'Close']].rename(columns={'Date': 'ds', 'Close': 'y'})
-        df['ds'] = pd.to_datetime(df['ds'])
-        df['unique_id'] = ticker
-
-        tfm = timesfm.TimesFm(
-            hparams=timesfm.TimesFmHparams(
-                backend="pytorch",
-                per_core_batch_size=32,
-                horizon_len=30,
-                input_patch_len=32,
-                output_patch_len=128,
-                num_layers=50,
-                model_dims=1280,
-            ),
-            checkpoint=timesfm.TimesFmCheckpoint(huggingface_repo_id="google/timesfm-2.0-500m-pytorch")
+        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')
         )
-        forecast_df = tfm.forecast_on_df(inputs=df, freq="D", value_name="y")
-        forecast_df.rename(columns={"timesfm": "forecast"}, inplace=True)
-
-        fig = go.Figure()
-        fig.add_trace(go.Scatter(x=df["ds"], y=df["y"], mode="lines", name="Actual"))
-        fig.add_trace(go.Scatter(x=forecast_df["ds"], y=forecast_df["forecast"], mode="lines", name="Forecast"))
-        fig.update_layout(title=f"{ticker} TimesFM Forecast", template="plotly_dark")
-        return fig
-    except Exception as e:
-        fig = go.Figure()
-        fig.add_annotation(text=f"TimesFM Error: {e}", x=0.5, y=0.5, xref="paper", yref="paper")
-        fig.update_layout(template="plotly_dark")
         return fig
+    return go.Figure()
 
-def plot_technical_signals(df, ticker):
-    df = generate_signals(df)
-    df_120 = df.tail(120)
+def plot_shock_response(event_name, custom_date=None):
+    df = get_processed_data()
+    
+    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)
+    
+    window = 30
+    start = event_date - timedelta(days=window)
+    end = event_date + timedelta(days=window)
+    df_win = df[(df.index >= start) & (df.index <= end)]
+    
+    if df_win.empty:
+        return go.Figure()
+    
+    assets = ['SP500', 'Gold', 'TLT', 'VIX', 'Oil', 'KWEB', 'SMH', 'ITA']
     fig = go.Figure()
-    fig.add_trace(go.Scatter(x=df_120.index, y=df_120['Close'], mode='lines', name='Price'))
-    buy = df_120[df_120['Technical_Score'] > 0]
-    sell = df_120[df_120['Technical_Score'] < 0]
-    fig.add_trace(go.Scatter(x=buy.index, y=buy['Close'], mode='markers', name='Buy', marker=dict(symbol='triangle-up', color='green')))
-    fig.add_trace(go.Scatter(x=sell.index, y=sell['Close'], mode='markers', name='Sell', marker=dict(symbol='triangle-down', color='red')))
-    fig.update_layout(title=f"{ticker} Technical Signals", template="plotly_dark")
+    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_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
 
-# ============================================================================
-# MAIN ANALYSIS FUNCTION
-# ============================================================================
-async def run_unified_analysis(
-    tickers_str: str,
-    start_date: str,
-    end_date: str,
-    days_sentiment: int,
-    refresh_news: bool,
-    growth_w: float,
-    value_w: float,
-    risk_w: float
-):
-    tickers = [t.strip().upper() for t in tickers_str.split(",") if t.strip()][:5]
-    if not tickers:
-        empty = go.Figure()
-        empty.add_annotation(text="Enter tickers", x=0.5, y=0.5, xref="paper", yref="paper")
-        return ("No tickers",) + (empty,) * 8 + (pd.DataFrame(), pd.DataFrame())
-
-    primary = tickers[0]
-
-    # Fundamentals
-    scores_df, metrics_df = pd.DataFrame(), pd.DataFrame()
-    try:
-        fund_data = await fetch_data_concurrently(tickers)
-        if fund_data:
-            df = pd.DataFrame(fund_data)
-            df = sanitize_financial_data(df)
-            numerical_cols = df.select_dtypes(include=[np.number]).columns
-            for col in numerical_cols:
-                df[col] = df[col].fillna(df[col].median() if not pd.isna(df[col].median()) else 0)
-            df = calculate_scores(df, growth_w, value_w, risk_w)
-            df = df.sort_values('Total_Score', ascending=False).reset_index(drop=True)
-            scores_df = df[['Ticker', 'Total_Score', 'Growth_Score', 'Value_Score', 'No_Risk_Score']].round(2)
-            metrics_df = create_metrics_table(df)
-    except Exception as e:
-        logger.error(f"Fundamentals error: {e}")
-
-    # Sentiment
-    sentiment_plot = go.Figure()
-    try:
-        analyzer = StockNewsAnalyzer(primary)
-        daily_sent, _ = analyzer.get_sentiment_data(days=days_sentiment, force_refresh=refresh_news)
-        if daily_sent is not None:
-            sentiment_plot = create_sentiment_plot(daily_sent, primary)
-    except Exception as e:
-        logger.error(f"Sentiment error: {e}")
-
-    # Technicals
-    tech_plot = go.Figure()
-    try:
-        tech_df = yf.download(primary, start=start_date, end=end_date)
-        if not tech_df.empty:
-            if isinstance(tech_df.columns, pd.MultiIndex):
-                tech_df.columns = tech_df.columns.droplevel(1)
-            tech_plot = plot_technical_signals(tech_df, primary)
-    except Exception as e:
-        logger.error(f"Technical error: {e}")
-
-    # Forecasting
-    prophet_price, prophet_forecast = prophet_forecast(primary, start_date, end_date)
-    timesfm_plot = timesfm_forecast(primary, start_date, end_date)
-
-    return (
-        f"Analysis for: {', '.join(tickers)}",
-        scores_df,
-        metrics_df,
-        sentiment_plot,
-        tech_plot,
-        timesfm_plot,
-        prophet_price,
-        prophet_forecast
-    )
-
-# ============================================================================
-# GRADIO INTERFACE
-# ============================================================================
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🚀 Unified Stock Intelligence Platform")
-    gr.Markdown("Fundamentals + Sentiment + Technicals + AI Forecasting")
-
-    with gr.Row():
-        tickers = gr.Textbox(label="Tickers (comma-separated)", value="NVDA, AAPL, MSFT")
-        start_date = gr.Textbox(label="Start Date", value="2022-01-01")
-        end_date = gr.Textbox(label="End Date", value="2026-01-01")
-
-    with gr.Row():
-        days_sentiment = gr.Slider(7, 90, value=90, label="Sentiment Days")
-        refresh_news = gr.Checkbox(label="Refresh News", value=False)
-        growth_w = gr.Slider(0, 1, 0.4, label="Growth Weight")
-        value_w = gr.Slider(0, 1, 0.4, label="Value Weight")
-        risk_w = gr.Slider(0, 1, 0.2, label="Risk Weight")
-
-    run_btn = gr.Button("Analyze", variant="primary")
+# ======================
+# GRADIO UI
+# ======================
 
+with gr.Blocks(title="Macro-Thematic Intelligence") as demo:
+    gr.Markdown("## 🌐 Top-Down Thematic Intelligence Platform")
+    
     with gr.Tabs():
-        with gr.Tab("📊 Fundamentals"):
-            scores_table = gr.Dataframe()
-            metrics_table = gr.Dataframe()
-
-        with gr.Tab("📰 Sentiment"):
-            sentiment_plot = gr.Plot()
-
-        with gr.Tab("📈 Technicals"):
-            tech_plot = gr.Plot()
-
-        with gr.Tab("🔮 Forecasting"):
-            with gr.Row():
-                timesfm_plot = gr.Plot()
-                prophet_price = gr.Plot()
-            prophet_forecast = gr.Plot()
-
-    run_btn.click(
-        lambda *args: asyncio.run(run_unified_analysis(*args)),
-        inputs=[tickers, start_date, end_date, days_sentiment, refresh_news, growth_w, value_w, risk_w],
-        outputs=[
-            gr.Textbox(label="Status"),
-            scores_table, metrics_table,
-            sentiment_plot,
-            tech_plot,
-            timesfm_plot,
-            prophet_price,
-            prophet_forecast
-        ]
-    )
+        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.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.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)
+        
+        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)
 
 if __name__ == "__main__":
     demo.launch()