Update app.py

app.py

@@ -1,39 +1,45 @@
 import os
 import pandas as pd
-import requests
 import numpy as np
 import gradio as gr
-from datetime import datetime, timedelta
-from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
+import plotly.express as px
 import yfinance as yf
+import requests
+from datetime import datetime, timedelta
+from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
 from prophet import Prophet
-import plotly.express as px
 import warnings
-from typing import Optional
-
-# Ignore common warnings
-warnings.filterwarnings('ignore')
+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 & SETUP
+# CONFIGURATION
 # ============================================================================
 class Config:
-    FINNHUB_API_KEY = "cuj17q1r01qm7p9n307gcuj17q1r01qm7p9n3080"
+    FINNHUB_API_KEY = os.getenv("FINNHUB_API_KEY", "cuj17q1r01qm7p9n307gcuj17q1r01qm7p9n3080")
     DATA_DIR = "data_cache"
     CACHE_TTL_HOURS = 12
     SENTIMENT_DAYS = 90
     TECH_DATA_YEARS = 3
 
-    PLOT_TEMPLATE = "plotly_dark"
-    PRIMARY_COLOR = "#00BFFF"
-    SENTIMENT_POSITIVE_COLOR = "rgba(0, 204, 102, 0.7)"
-    SENTIMENT_NEGATIVE_COLOR = "rgba(255, 51, 51, 0.7)"
-    SENTIMENT_NEUTRAL_COLOR = "rgba(128, 128, 128, 0.6)"
-    BOLLINGER_FILL_COLOR = "rgba(255, 255, 255, 0.1)"
-    BOLLINGER_LINE_STYLE = dict(color="rgba(255, 255, 255, 0.3)", width=1, dash='dot')
-
     @classmethod
     def initialize(cls):
         os.makedirs(cls.DATA_DIR, exist_ok=True)
@@ -41,7 +47,7 @@ class Config:
 Config.initialize()
 
 # ============================================================================
-# 📦 DATA CACHING
+# CACHING UTILS
 # ============================================================================
 class CacheManager:
     @staticmethod
@@ -50,384 +56,452 @@ class CacheManager:
 
     @staticmethod
     def save_df(df: pd.DataFrame, filename: str):
-        df.to_csv(CacheManager.get_path(filename))
+        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])
-            if 'Date' in df.columns and df.columns[0] == 'Date':
-                df.set_index('Date', inplace=True)
             return df
         except Exception:
             return None
 
 # ============================================================================
-# 🧠 CORE ANALYSIS LOGIC
+# FUNDAMENTALS MODULE
 # ============================================================================
-class StockAnalyzer:
-    _sentiment_analyzer = SentimentIntensityAnalyzer()
-
-    def __init__(self, ticker: str, force_refresh: bool = False):
-        self.ticker = ticker.upper()
-        self.force_refresh = force_refresh
-        self.tech_df = self._get_technical_data()
-        self.sentiment_daily, _ = self._get_sentiment_data()
-        self.forecast_pct, self.forecast_price, self.forecast_df = self._get_forecast()
-        self.scores, self.decision, self.total_score = self._calculate_decision()
-
-    def _get_technical_data(self) -> pd.DataFrame:
-        cache_file = f"{self.ticker}_technical.csv"
-        df = CacheManager.load_df(cache_file)
-        if df is None or self.force_refresh:
-            end_date = datetime.now()
-            start_date = end_date - timedelta(days=365 * Config.TECH_DATA_YEARS)
-            df = yf.download(self.ticker, start=start_date, end=end_date)
-            if df.empty:
-                return pd.DataFrame()
-            df = self._calculate_indicators(df)
-            CacheManager.save_df(df.reset_index(), cache_file)
-        return df
+@lru_cache(maxsize=100)
+def get_financial_data(ticker: str) -> Optional[Dict[str, Any]]:
+    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)
+    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
 
-    def _get_sentiment_data(self):
-        cache_file = f"{self.ticker}_sentiment.csv"
-        df_daily = CacheManager.load_df(cache_file)
-        if df_daily is not None and not self.force_refresh:
-            return df_daily, None
+# ============================================================================
+# 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=Config.SENTIMENT_DAYS)
+        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:
-            # FIXED: Removed trailing spaces in URL!
-            res = requests.get(
-                "https://finnhub.io/api/v1/company-news",
-                params={
-                    "symbol": self.ticker,
-                    "from": start_date.strftime('%Y-%m-%d'),
-                    "to": end_date.strftime('%Y-%m-%d'),
-                    "token": Config.FINNHUB_API_KEY
-                },
-                timeout=10
-            )
-            res.raise_for_status()
-            news = res.json()
-            if not news or not isinstance(news, list):
-                return None, None
-        except requests.RequestException:
-            return None, None
+            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()
 
-        news_df = pd.DataFrame(news)
-        news_df['datetime'] = pd.to_datetime(news_df['datetime'], unit='s')
-        news_df['sentiment'] = news_df['headline'].apply(
-            lambda text: self._sentiment_analyzer.polarity_scores(text)['compound']
-        )
+    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_sentiment = news_df.groupby('date').agg(
+        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
 
-        CacheManager.save_df(daily_sentiment, cache_file)
-        return daily_sentiment, news_df
-
-    def _get_forecast(self):
-        if self.tech_df.empty:
-            return 0, 0, None
-        try:
-            prophet_df = self.tech_df.reset_index()[['Date', 'Close']].rename(columns={'Date': 'ds', 'Close': 'y'})
-            model = Prophet(daily_seasonality=True)
-            model.fit(prophet_df)
-            future = model.make_future_dataframe(periods=30)
-            forecast = model.predict(future)
-            current_price = prophet_df['y'].iloc[-1]
-            future_price = forecast['yhat'].iloc[-1]
-            pct_change = ((future_price - current_price) / current_price) * 100
-            return pct_change, future_price, forecast
-        except Exception:
-            return 0, 0, None
-
-    def _calculate_decision(self):
-        tech_score = 0
-        if not self.tech_df.empty:
-            last_signal = self.tech_df['Technical_Score'].iloc[-1]
-            if last_signal >= 3: tech_score = 2
-            elif last_signal >= 1: tech_score = 1
-            elif last_signal <= -1: tech_score = -1
-            elif last_signal <= -3: tech_score = -2
-
-        sentiment_score = 0
-        if self.sentiment_daily is not None:
-            avg_sentiment = self.sentiment_daily['avg_sentiment'].mean()
-            if avg_sentiment > 0.3: sentiment_score = 2
-            elif avg_sentiment > 0.1: sentiment_score = 1
-            elif avg_sentiment < -0.1: sentiment_score = -1
-            elif avg_sentiment < -0.3: sentiment_score = -2
-
-        forecast_score = 0
-        if self.forecast_pct > 8: forecast_score = 2
-        elif self.forecast_pct > 3: forecast_score = 1
-        elif self.forecast_pct < -3: forecast_score = -1
-        elif self.forecast_pct < -8: forecast_score = -2
-
-        scores = {'Technical': tech_score, 'Sentiment': sentiment_score, 'Forecast': forecast_score}
-        total_score = sum(scores.values())
-
-        if total_score >= 4: decision = "STRONG BUY"
-        elif total_score >= 2: decision = "BUY"
-        elif total_score <= -2: decision = "SELL"
-        elif total_score <= -4: decision = "STRONG SELL"
-        else: decision = "HOLD"
-
-        return scores, decision, total_score
-
-    @staticmethod
-    def _calculate_indicators(df: pd.DataFrame) -> pd.DataFrame:
-        df = df.copy()
-        # RSI
-        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
-        df['RSI'] = 100 - (100 / (1 + rs))
-
-        # Bollinger Bands
-        ma = df['Close'].rolling(20).mean()
-        std = df['Close'].rolling(20).std()
-        df['UpperBB'] = ma + 2 * std
-        df['LowerBB'] = ma - 2 * std
-
-        # Stochastic
-        ll = df['Low'].rolling(14).min()
-        hh = df['High'].rolling(14).max()
-        df['SlowK'] = ((df['Close'] - ll) / (hh - ll)) * 100
-        df['SlowD'] = df['SlowK'].rolling(3).mean()
-
-        # CMF
-        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(20).sum()
-        vol_sum = df['Volume'].rolling(20).sum()
-        cmf_raw = mfv_sum.values / vol_sum.values
-        cmf_clean = np.where(np.isfinite(cmf_raw), cmf_raw, np.nan)
-        df['CMF'] = cmf_clean
-
-        # Signals
-        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)
-
-        return 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
 
 # ============================================================================
-# 📈 PLOTTING FUNCTIONS
+# TECHNICAL & FORECASTING MODULES
 # ============================================================================
-class Plotter:
-    @staticmethod
-    def create_multi_ticker_plot(data_dict, show_bollinger, time_range):
+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)
+
+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)
+    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")
+
+        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 timesfm_forecast(ticker, start_date, end_date):
+    if not TIMESFM_AVAILABLE:
         fig = go.Figure()
-        colors = px.colors.qualitative.Plotly
-
-        all_dates = pd.concat([df.index.to_series() for df in data_dict.values()]).unique()
-        if len(all_dates) == 0:
-            return fig
-        max_date = all_dates.max()
-        range_map = {
-            "1M": max_date - pd.DateOffset(months=1),
-            "3M": max_date - pd.DateOffset(months=3),
-            "6M": max_date - pd.DateOffset(months=6),
-            "1Y": max_date - pd.DateOffset(years=1),
-            "YTD": pd.to_datetime(f"{max_date.year}-01-01"),
-            "All": all_dates.min()
-        }
-        start_date = range_map.get(time_range, all_dates.min())
-
-        for i, (ticker, df) in enumerate(data_dict.items()):
-            df_plot = df[df.index >= start_date]
-            color = colors[i % len(colors)]
-            fig.add_trace(go.Scatter(x=df_plot.index, y=df_plot['Close'], mode='lines', name=ticker, line=dict(color=color, width=2)))
-
-            if show_bollinger:
-                fig.add_trace(go.Scatter(x=df_plot.index, y=df_plot['UpperBB'], mode='lines', line=Config.BOLLINGER_LINE_STYLE, showlegend=False, hoverinfo='skip'))
-                fig.add_trace(go.Scatter(x=df_plot.index, y=df_plot['LowerBB'], mode='lines', line=Config.BOLLINGER_LINE_STYLE, fill='tonexty', fillcolor=Config.BOLLINGER_FILL_COLOR, showlegend=False, hoverinfo='skip'))
-
-            buy_signals = df_plot[df_plot['Technical_Score'] > 0]
-            sell_signals = df_plot[df_plot['Technical_Score'] < 0]
-            fig.add_trace(go.Scatter(x=buy_signals.index, y=buy_signals['Close'], mode='markers', name=f'{ticker} Buy', marker=dict(symbol='triangle-up', color=color, size=8), hoverinfo='skip'))
-            fig.add_trace(go.Scatter(x=sell_signals.index, y=sell_signals['Close'], mode='markers', name=f'{ticker} Sell', marker=dict(symbol='triangle-down', color='white', size=6, line=dict(color=color, width=1)), hoverinfo='skip'))
-
-        fig.update_layout(
-            title="Comparative Technical Analysis",
-            template=Config.PLOT_TEMPLATE,
-            height=600,
-            legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1),
-            yaxis_title="Stock Price (USD)",
-            hovermode="x unified"
-        )
+        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
-
-    @staticmethod
-    def create_decision_gauge(decision: str, total_score: int) -> go.Figure:
-        colors = {'STRONG BUY': '#00FF00', 'BUY': '#90EE90', 'HOLD': '#FFD700', 'SELL': '#FFA500', 'STRONG SELL': '#FF0000'}
-        fig = go.Figure(go.Indicator(
-            mode="gauge+number", value=total_score,
-            title={'text': decision, 'font': {'size': 24, 'color': 'white'}},
-            gauge={
-                'axis': {'range': [-6, 6]},
-                'bar': {'color': colors.get(decision, '#FFD700')},
-                'steps': [
-                    {'range': [-6, -4], 'color': 'rgba(255, 0, 0, 0.8)'},
-                    {'range': [-4, -2], 'color': 'rgba(255, 165, 0, 0.7)'},
-                    {'range': [-2, 2], 'color': 'rgba(255, 215, 0, 0.6)'},
-                    {'range': [2, 4], 'color': 'rgba(144, 238, 144, 0.7)'},
-                    {'range': [4, 6], 'color': 'rgba(0, 255, 0, 0.8)'},
-                ],
-            }
-        ))
-        fig.update_layout(template=Config.PLOT_TEMPLATE, height=250, margin=dict(t=40, b=40))
-        return fig
-
-    @staticmethod
-    def create_sentiment_plot(daily_sentiment: pd.DataFrame, ticker: str) -> go.Figure:
-        fig = make_subplots(rows=2, cols=1, shared_xaxes=True, row_heights=[0.7, 0.3], vertical_spacing=0.1)
-        fig.add_trace(go.Scatter(x=daily_sentiment['date'], y=daily_sentiment['avg_sentiment'], name='Avg. Sentiment', line=dict(color=Config.PRIMARY_COLOR, width=2)), row=1, col=1)
-        fig.add_trace(go.Bar(x=daily_sentiment['date'], y=daily_sentiment['positive_count'], name='Positive', marker_color=Config.SENTIMENT_POSITIVE_COLOR), row=2, col=1)
-        fig.add_trace(go.Bar(x=daily_sentiment['date'], y=daily_sentiment['negative_count'], name='Negative', marker_color=Config.SENTIMENT_NEGATIVE_COLOR), row=2, col=1)
-        fig.add_trace(go.Bar(x=daily_sentiment['date'], y=daily_sentiment['neutral_count'], name='Neutral', marker_color=Config.SENTIMENT_NEUTRAL_COLOR), row=2, col=1)
-        fig.update_layout(
-            title=f"News Sentiment & Article Volume (Last {Config.SENTIMENT_DAYS} Days)",
-            template=Config.PLOT_TEMPLATE, barmode='stack', height=450, showlegend=False,
-            yaxis1_title="Sentiment Score", yaxis2_title="Article Count"
+    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")
         )
-        return fig
+        forecast_df = tfm.forecast_on_df(inputs=df, freq="D", value_name="y")
+        forecast_df.rename(columns={"timesfm": "forecast"}, inplace=True)
 
-    @staticmethod
-    def create_forecast_plot(forecast_df: pd.DataFrame, ticker: str) -> go.Figure:
         fig = go.Figure()
-        fig.add_trace(go.Scatter(x=forecast_df['ds'], y=forecast_df['yhat'], name='Forecast', line=dict(color=Config.PRIMARY_COLOR, width=2)))
-        fig.add_trace(go.Scatter(x=forecast_df['ds'], y=forecast_df['yhat_upper'], fill=None, mode='lines', line=dict(color='rgba(0, 191, 255, 0.3)'), showlegend=False))
-        fig.add_trace(go.Scatter(x=forecast_df['ds'], y=forecast_df['yhat_lower'], fill='tonexty', mode='lines', line=dict(color='rgba(0, 191, 255, 0.3)'), showlegend=False))
-        fig.update_layout(title="30-Day Price Forecast", template=Config.PLOT_TEMPLATE, height=450, yaxis_title="Predicted Price (USD)")
+        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
 
+def plot_technical_signals(df, ticker):
+    df = generate_signals(df)
+    df_120 = df.tail(120)
+    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")
+    return fig
+
 # ============================================================================
-# 🖥️ GRADIO INTERFACE
+# MAIN ANALYSIS FUNCTION
 # ============================================================================
-def run_full_analysis(tickers_str: str, time_range: str, show_bollinger: bool, force_refresh: bool, progress=gr.Progress()):
-    tickers = [t.strip().upper() for t in tickers_str.split(',') if t.strip()][:5]
+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:
-        return (
-            "Please enter at least one ticker.",
-            None, None, None, None
-        )
-
-    progress(0, desc="Starting analysis...")
-    all_results = {}
-    for i, ticker in enumerate(tickers):
-        progress((i + 1) / len(tickers), desc=f"Analyzing {ticker}...")
-        try:
-            analyzer = StockAnalyzer(ticker, force_refresh)
-            if not analyzer.tech_df.empty:
-                all_results[ticker] = analyzer
-        except Exception as e:
-            print(f"Error analyzing {ticker}: {e}")
-            continue
-
-    if not all_results:
-        return (
-            "Could not retrieve data for any ticker.",
-            None, None, None, None
-        )
-
-    # Multi-ticker price plot
-    multi_plot = Plotter.create_multi_ticker_plot(
-        {t: r.tech_df for t, r in all_results.items()},
-        show_bollinger, time_range
+        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
     )
 
-    # Detailed analysis for FIRST ticker only
-    primary_ticker = tickers[0]
-    primary_analyzer = all_results.get(primary_ticker)
-    if not primary_analyzer:
-        primary_ticker = list(all_results.keys())[0]
-        primary_analyzer = all_results[primary_ticker]
-
-    # Summary
-    current_price = primary_analyzer.tech_df['Close'].iloc[-1]
-    avg_sent = primary_analyzer.sentiment_daily['avg_sentiment'].mean() if primary_analyzer.sentiment_daily is not None else 0.0
-    summary_md = f"""
-### 🎯 Decision: **{primary_analyzer.decision}** (Score: {primary_analyzer.total_score}/6)
-- **Ticker**: {primary_ticker}
-- **Current Price**: ${current_price:.2f}
-- **Technical Score**: `{primary_analyzer.scores['Technical']}`
-- **Sentiment Score**: `{primary_analyzer.scores['Sentiment']}` (Avg: {avg_sent:.2f})
-- **Forecast Score**: `{primary_analyzer.scores['Forecast']}` ({primary_analyzer.forecast_pct:.1f}% → ${primary_analyzer.forecast_price:.2f})
-"""
-
-    # Plots
-    gauge_plot = Plotter.create_decision_gauge(primary_analyzer.decision, primary_analyzer.total_score)
-    sentiment_plot = Plotter.create_sentiment_plot(primary_analyzer.sentiment_daily, primary_ticker) if primary_analyzer.sentiment_daily is not None else None
-    forecast_plot = Plotter.create_forecast_plot(primary_analyzer.forecast_df, primary_ticker) if primary_analyzer.forecast_df is not None else None
-
-    progress(1.0, "Done!")
-    return summary_md, multi_plot, gauge_plot, sentiment_plot, forecast_plot
-
-# Custom CSS
-custom_css = """
-.gradio-container { font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; }
-"""
-
-# Build App
-with gr.Blocks(theme=gr.themes.Monochrome(), css=custom_css) as demo:
-    gr.Markdown("# 📊 Unified Stock Intelligence Dashboard")
-    gr.Markdown("Technical, sentiment, and predictive analysis for up to 5 stocks.")
+# ============================================================================
+# 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():
-        with gr.Column(scale=1):
-            gr.Markdown("### Controls")
-            tickers_input = gr.Textbox(label="Tickers (comma-separated, max 5)", value="NVDA,TSLA,MSFT")
-            time_range = gr.Radio(choices=["1M", "3M", "6M", "1Y", "YTD", "All"], value="1Y", label="Chart Time Range")
-            show_bb = gr.Checkbox(label="Show Bollinger Bands", value=True)
-            force_refresh = gr.Checkbox(label="Force Refresh Data", value=False)
-            analyze_btn = gr.Button("Analyze Stocks", variant="primary")
-            status_output = gr.Textbox(label="Status", interactive=False)
-
-        with gr.Column(scale=4):
-            gr.Markdown("### Comparative Price Chart")
-            technical_plot_output = gr.Plot()
-
-    # Detailed Analysis for Primary Ticker
-    gr.Markdown("### 🔍 Detailed Analysis (First Ticker)")
-    with gr.Row():
-        summary_output = gr.Markdown()
-        decision_gauge_output = gr.Plot()
+        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():
-        sentiment_output = gr.Plot()
-        forecast_output = gr.Plot()
-
-    # NO gr.Progress() in layout!
-    analyze_btn.click(
-        fn=run_full_analysis,
-        inputs=[tickers_input, time_range, show_bb, force_refresh],
-        outputs=[status_output, technical_plot_output, decision_gauge_output, sentiment_output, forecast_output]
+        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")
+
+    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
+        ]
     )
 
 if __name__ == "__main__":