Update app.py

app.py

@@ -8,348 +8,434 @@ from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
 import yfinance as yf
-import warnings
 from prophet import Prophet
 import plotly.express as px
+import warnings
+import json
+from typing import List, Dict, Tuple, Optional
 
+# Ignore common warnings from Prophet and yfinance
 warnings.filterwarnings('ignore')
 
 # ============================================================================
-# CONFIGURATION (FIXED DATES)
+# ⚙️ CONFIGURATION & SETUP
 # ============================================================================
+class Config:
+    """Central configuration for the application."""
+    # API key hardcoded as in the original script
+    FINNHUB_API_KEY = "cuj17q1r01qm7p9n307gcuj17q1r01qm7p9n3080"
+    DATA_DIR = "data_cache"
+    CACHE_TTL_HOURS = 12  # Time-to-live for cache files
+    SENTIMENT_DAYS = 90   # How many days back to fetch news for
+    TECH_DATA_YEARS = 3   # How many years of historical data for technicals
 
-TECH_START = "2022-01-01"
-TECH_END = "2026-01-01"
-SENTIMENT_DAYS = 90  # Always last 90 days
+    # Plotting styles
+    PLOT_TEMPLATE = "plotly_dark"
+    PRIMARY_COLOR = "#00BFFF"  # DeepSkyBlue
+    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')
 
-class Config:
-    FINNHUB_API_KEY = "cuj17q1r01qm7p9n307gcuj17q1r01qm7p9n3080"  # Replace with your key
-    DATA_DIR = "data"
-    
     @classmethod
     def initialize(cls):
+        """Create the data directory if it doesn't exist."""
         os.makedirs(cls.DATA_DIR, exist_ok=True)
 
 Config.initialize()
 
 # ============================================================================
-# SENTIMENT ANALYSIS (90 DAYS ONLY)
+# 📦 DATA CACHING
 # ============================================================================
+class CacheManager:
+    """Handles saving and loading of dataframes to avoid redundant API calls."""
+    @staticmethod
+    def get_path(filename: str) -> str:
+        return os.path.join(Config.DATA_DIR, filename)
+
+    @staticmethod
+    def save_df(df: pd.DataFrame, filename: str):
+        """Saves a pandas DataFrame to a CSV file."""
+        df.to_csv(CacheManager.get_path(filename))
+
+    @staticmethod
+    def load_df(filename: str) -> Optional[pd.DataFrame]:
+        """
+        Loads a DataFrame from a CSV file if it exists and is not stale.
+        Returns None if the file is invalid, missing, or too old.
+        """
+        path = CacheManager.get_path(filename)
+        if not os.path.exists(path):
+            return None
+
+        # Check if cache is stale
+        file_mod_time = datetime.fromtimestamp(os.path.getmtime(path))
+        if datetime.now() - file_mod_time > timedelta(hours=Config.CACHE_TTL_HOURS):
+            return None
 
-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_file_path(self, file_type):
-        return os.path.join(Config.DATA_DIR, f"{self.symbol}_{file_type}.csv")
-    
-    def get_news(self, force_refresh=False):
-        file_path = self.get_file_path("news")
-        if os.path.exists(file_path) and not force_refresh:
-            try:
-                return pd.read_csv(file_path, parse_dates=['datetime'])
-            except Exception:
-                pass
-        
-        end_date = datetime.now()
-        start_date = end_date - timedelta(days=SENTIMENT_DAYS)
-        
-        url = "https://finnhub.io/api/v1/company-news"  # FIXED: no trailing spaces
-        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)
-            data = response.json()
-            if not data or not isinstance(data, list):
+            df = pd.read_csv(path)
+            # Convert date columns back to datetime objects
+            for col in df.columns:
+                if 'date' in col.lower():
+                    df[col] = pd.to_datetime(df[col])
+            # If the first column is the index, set it
+            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
+# ============================================================================
+class StockAnalyzer:
+    """A comprehensive analyzer for a single stock ticker."""
+    _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.news_df = 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:
+        """Fetches and processes technical indicator data for the stock."""
+        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 = pd.DataFrame(data)
-            if 'datetime' in df.columns:
-                df['datetime'] = pd.to_datetime(df['datetime'], unit='s')
-                df.to_csv(file_path, index=False)
-                return df
-            return pd.DataFrame()
-        except Exception as e:
-            print(f"Error fetching news: {e}")
-            return pd.DataFrame()
-    
-    def get_sentiment_data(self):
-        news_df = self.get_news()
-        if news_df.empty or 'headline' not in news_df.columns:
+            df = self._calculate_indicators(df)
+            CacheManager.save_df(df.reset_index(), cache_file)
+        return df
+
+    def _get_sentiment_data(self) -> Tuple[Optional[pd.DataFrame], Optional[pd.DataFrame]]:
+        """Fetches and analyzes news sentiment."""
+        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 # Detailed news_df not needed from cache
+
+        end_date = datetime.now()
+        start_date = end_date - timedelta(days=Config.SENTIMENT_DAYS)
+        try:
+            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
-        
-        news_df['sentiment_score'] = news_df['headline'].apply(self.sentiment_analyzer.analyze)
+
+        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']
+        )
         news_df['date'] = pd.to_datetime(news_df['datetime'].dt.date)
-        
-        daily = news_df.groupby('date').agg(
-            avg_sentiment=('sentiment_score', 'mean'),
-            article_count=('sentiment_score', 'count'),
-            positive_count=('sentiment_score', lambda x: sum(x > 0.05)),
-            negative_count=('sentiment_score', lambda x: sum(x < -0.05)),
-            neutral_count=('sentiment_score', lambda x: sum((x >= -0.05) & (x <= 0.05)))
+
+        daily_sentiment = 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
 
-# ============================================================================
-# TECHNICAL INDICATORS (ULTRA-STRICT, FIXED DATES)
-# ============================================================================
+        CacheManager.save_df(daily_sentiment, cache_file)
+        return daily_sentiment, news_df
 
-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):
-    mfv = ((df['Close'] - df['Low']) - (df['High'] - df['Close'])) / (df['High'] - df['Low']) * df['Volume']
-    return mfv.rolling(window).sum() / df['Volume'].rolling(window).sum()
-
-def generate_signals(df):
-    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)
-    
-    # Ultra-strict thresholds
-    df['RSI_Signal'] = np.where(df['RSI'] < 15, 1, np.where(df['RSI'] > 90, -1, 0))
-    df['BB_Signal'] = np.where(df['Close'] < df['LowerBB'] * 0.97, 1, np.where(df['Close'] > df['UpperBB'] * 1.03, -1, 0))
-    df['Stochastic_Signal'] = np.where((df['SlowK'] < 10) & (df['SlowD'] < 10), 1, np.where((df['SlowK'] > 95) & (df['SlowD'] > 95), -1, 0))
-    df['CMF_Signal'] = np.where(df['CMF'] < -0.4, 1, np.where(df['CMF'] > 0.4, -1, 0))
-    
-    df['Technical_Score'] = df[['RSI_Signal', 'BB_Signal', 'Stochastic_Signal', 'CMF_Signal']].sum(axis=1)
-    return df
+    def _get_forecast(self) -> Tuple[float, float, Optional[pd.DataFrame]]:
+        """Generates a 30-day price forecast using Prophet."""
+        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
 
-# ============================================================================
-# FORECASTING (PROPHET, FIXED DATES)
-# ============================================================================
+    def _calculate_decision(self) -> Tuple[Dict, str, int]:
+        """Calculates scores and a final investment decision."""
+        # Technical Score
+        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
+        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
+        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:
+        """Calculates a suite of technical indicators."""
+        # 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))
 
-def prophet_forecast(df):
-    try:
-        prophet_df = df.reset_index()[['Date', 'Close']].rename(columns={'Date': 'ds', 'Close': 'y'})
-        prophet_df['ds'] = pd.to_datetime(prophet_df['ds'])
-        model = Prophet()
-        model.fit(prophet_df)
-        future = model.make_future_dataframe(periods=30)
-        forecast = model.predict(future)
-        current = prophet_df['y'].iloc[-1]
-        future_price = forecast['yhat'].iloc[-1]
-        pct_change = ((future_price - current) / current) * 100
-        return pct_change, future_price, forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']]
-    except Exception as e:
-        print(f"Forecast error: {e}")
-        return 0, 0, None
+        # 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 Oscillator
+        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()
+
+        # Chaikin Money Flow (CMF)
+        mfv = ((df['Close'] - df['Low']) - (df['High'] - df['Close'])) / (df['High'] - df['Low']) * df['Volume']
+        df['CMF'] = mfv.rolling(20).sum() / df['Volume'].rolling(20).sum()
+
+        # Signals (using stricter thresholds)
+        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
 
 # ============================================================================
-# VISUALIZATIONS
+# 📈 PLOTTING FUNCTIONS
 # ============================================================================
+class Plotter:
+    """Handles the creation of all Plotly figures."""
+    @staticmethod
+    def create_multi_ticker_plot(data_dict: Dict[str, pd.DataFrame], show_bollinger: bool, time_range: str) -> go.Figure:
+        fig = go.Figure()
+        colors = px.colors.qualitative.Plotly
+
+        # Determine overall date range
+        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)
 
-def create_multi_ticker_plot(data_dict, show_bollinger, time_range):
-    fig = go.Figure()
-    COLORS = px.colors.qualitative.Plotly
-    all_dates = pd.concat([df.index.to_series() for df in data_dict.values()], ignore_index=True)
-    if all_dates.empty:
+        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=10), 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=8, line=dict(color=color, width=2)), 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"
+        )
+        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], 'tickwidth': 1, 'tickcolor': "darkblue"},
+                '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"
+        )
+        return fig
+
+    @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)")
         return fig
-    end = all_dates.max()
-    start = {
-        "1M": end - pd.DateOffset(months=1),
-        "3M": end - pd.DateOffset(months=3),
-        "6M": end - pd.DateOffset(months=6),
-        "1Y": end - pd.DateOffset(years=1),
-        "YTD": pd.to_datetime(f"{end.year}-01-01"),
-        "All": all_dates.min()
-    }[time_range]
-    
-    buy_points, sell_points = [], []
-    for i, (ticker, df) in enumerate(data_dict.items()):
-        df_plot = df[df.index >= start]
-        if df_plot.empty:
-            continue
-        color = COLORS[i % len(COLORS)]
-        fig.add_trace(go.Scatter(x=df_plot.index, y=df_plot['Close'], mode='lines', line=dict(color=color, width=1.8), name=ticker))
-        if show_bollinger:
-            fig.add_trace(go.Scatter(x=df_plot.index, y=df_plot['UpperBB'], mode='lines', line=dict(color='rgba(150,150,150,0.4)', width=1, dash='dot'), showlegend=False, hoverinfo='skip'))
-            fig.add_trace(go.Scatter(x=df_plot.index, y=df_plot['LowerBB'], mode='lines', line=dict(color='rgba(150,150,150,0.4)', width=1, dash='dot'), fill='tonexty', fillcolor='rgba(150,150,150,0.05)', showlegend=False, hoverinfo='skip'))
-        for date in df_plot.index:
-            signals = [('RSI', df_plot.loc[date, 'RSI_Signal']), ('BB', df_plot.loc[date, 'BB_Signal']), ('Stochastic', df_plot.loc[date, 'Stochastic_Signal']), ('CMF', df_plot.loc[date, 'CMF_Signal'])]
-            total = sum(sig for _, sig in signals)
-            price = df_plot.loc[date, 'Close']
-            if total > 0:
-                active = [name for name, sig in signals if sig == 1]
-                hover = f"<b>{ticker}</b><br>Buy: {', '.join(active)}<br>{date.strftime('%Y-%m-%d')}<br>${price:.2f}"
-                buy_points.append((date, price * 0.997, hover))
-            elif total < 0:
-                active = [name for name, sig in signals if sig == -1]
-                hover = f"<b>{ticker}</b><br>Sell: {', '.join(active)}<br>{date.strftime('%Y-%m-%d')}<br>${price:.2f}"
-                sell_points.append((date, price * 1.003, hover))
-    
-    if buy_points:
-        x, y, text = zip(*buy_points)
-        fig.add_trace(go.Scatter(x=x, y=y, mode='markers', marker=dict(symbol='triangle-up', size=9, color='white', line=dict(color='black', width=0.8)), hovertext=text, hoverinfo='text', showlegend=False))
-    if sell_points:
-        x, y, text = zip(*sell_points)
-        fig.add_trace(go.Scatter(x=x, y=y, mode='markers', marker=dict(symbol='triangle-down', size=9, color='black', line=dict(color='white', width=0.8)), hovertext=text, hoverinfo='text', showlegend=False))
-    
-    fig.update_layout(
-        plot_bgcolor='black', paper_bgcolor='black', font=dict(color='white'),
-        xaxis=dict(showgrid=False, zeroline=False, showline=False, ticks=''),
-        yaxis=dict(showgrid=False, zeroline=False, showline=False, ticks='', tickprefix='$'),
-        legend=dict(orientation='h', yanchor='bottom', y=1.02, xanchor='center', x=0.5, bgcolor='rgba(0,0,0,0.6)'),
-        margin=dict(l=20, r=20, t=30, b=30), height=700, width=1100, hovermode='x unified'
-    )
-    return fig
-
-def create_sentiment_plot(sentiment_daily, stock_data, symbol):
-    if sentiment_daily is None:
-        return None
-    fig = make_subplots(rows=2, cols=1, specs=[[{"secondary_y": True}], [{}]], row_heights=[0.7, 0.3])
-    if not stock_data.empty:
-        fig.add_trace(go.Scatter(x=stock_data.index, y=stock_data['Close'], name='Price', line=dict(color='#1f77b4')), row=1, col=1, secondary_y=False)
-    fig.add_trace(go.Scatter(x=sentiment_daily['date'], y=sentiment_daily['avg_sentiment'], name='Sentiment', line=dict(color='#ff7f0e')), row=1, col=1, secondary_y=True)
-    fig.add_trace(go.Bar(x=sentiment_daily['date'], y=sentiment_daily['article_count'], name='Articles', marker_color='rgba(135,206,235,0.5)'), row=2, col=1)
-    fig.add_trace(go.Bar(x=sentiment_daily['date'], y=sentiment_daily['positive_count'], name='Positive', marker_color='rgba(0,128,0,0.7)'), row=2, col=1)
-    fig.add_trace(go.Bar(x=sentiment_daily['date'], y=sentiment_daily['negative_count'], name='Negative', marker_color='rgba(255,0,0,0.7)'), row=2, col=1)
-    fig.add_trace(go.Bar(x=sentiment_daily['date'], y=sentiment_daily['neutral_count'], name='Neutral', marker_color='rgba(128,128,128,0.7)'), row=2, col=1)
-    fig.update_layout(title=f"{symbol} News Sentiment (Last {SENTIMENT_DAYS} Days)", template='plotly_white', barmode='stack', height=600)
-    return fig
-
-def create_decision_gauge(decision, total_score):
-    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': f"{decision}", 'font': {'size': 24}},
-        gauge={'axis': {'range': [-6, 6]}, 'bar': {'color': colors.get(decision, '#FFD700')},
-               'steps': [{'range': [-6, -2], 'color': 'red'}, {'range': [-2, 2], 'color': 'gray'}, {'range': [2, 6], 'color': 'green'}]}
-    ))
-    fig.update_layout(paper_bgcolor='black', plot_bgcolor='black', font=dict(color='white', size=16), height=300)
-    return fig
 
 # ============================================================================
-# MAIN ANALYSIS FUNCTION
+# 🖥️ GRADIO INTERFACE & APP LOGIC
 # ============================================================================
+def run_full_analysis(tickers_str: str, time_range: str, show_bollinger: bool, force_refresh: bool, progress=gr.Progress()):
+    """Main function triggered by the Gradio button."""
+    tickers = [t.strip().upper() for t in tickers_str.split(',') if t.strip()][:5] # Limit to 5 tickers
+    if not tickers:
+        return "Please enter at least one ticker.", None, gr.Accordion(visible=False)
 
-def run_analysis(tickers_str, show_bollinger, time_range, refresh_sentiment):
-    try:
-        tickers = [t.strip().upper() for t in tickers_str.split(',') if t.strip()][:8]
-        if not tickers:
-            return "Enter at least one ticker", None, None, None, None, "No ticker provided"
-        
-        # === TECHNICAL ANALYSIS (FIXED DATES) ===
-        data_dict = {}
-        for t in tickers:
-            df = yf.download(t, start=TECH_START, end=TECH_END)
-            if not df.empty:
-                if isinstance(df.columns, pd.MultiIndex):
-                    df.columns = df.columns.droplevel(1)
-                data_dict[t] = generate_signals(df)
-        
-        if not data_dict:
-            return "No technical data found", None, None, None, None, "No data"
-        
-        # === SENTIMENT & FORECAST (FIRST TICKER ONLY) ===
-        first_ticker = tickers[0]
-        news_analyzer = StockNewsAnalyzer(first_ticker)
-        sentiment_daily, _ = news_analyzer.get_sentiment_data()
-        
-        # Get stock data for sentiment plot (last 90 days)
-        end_now = datetime.now()
-        start_90 = end_now - timedelta(days=90)
-        stock_90d = yf.download(first_ticker, start=start_90, end=end_now)
-        if isinstance(stock_90d.columns, pd.MultiIndex):
-            stock_90d.columns = stock_90d.columns.droplevel(1)
-        
-        # Forecast
-        tech_df = data_dict[first_ticker]
-        forecast_change, forecast_price, _ = prophet_forecast(tech_df)
-        
-        # Scoring
-        current_technical = tech_df['Technical_Score'].iloc[-1]
-        avg_sentiment = sentiment_daily['avg_sentiment'].mean() if sentiment_daily is not None else 0
-        scores = {
-            'technical': 2 if current_technical >= 3 else 1 if current_technical >= 1 else -1 if current_technical <= -1 else -2 if current_technical <= -3 else 0,
-            'sentiment': 2 if avg_sentiment > 0.3 else 1 if avg_sentiment > 0.1 else -1 if avg_sentiment < -0.1 else -2 if avg_sentiment < -0.3 else 0,
-            'forecast': 2 if forecast_change > 8 else 1 if forecast_change > 3 else -1 if forecast_change < -3 else -2 if forecast_change < -8 else 0
-        }
-        total_score = sum(scores.values())
-        decision = "STRONG BUY" if total_score >= 4 else "BUY" if total_score >= 2 else "SELL" if total_score <= -2 else "STRONG SELL" if total_score <= -4 else "HOLD"
-        
-        # === PLOTS ===
-        technical_plot = create_multi_ticker_plot(data_dict, show_bollinger, time_range)
-        sentiment_plot = create_sentiment_plot(sentiment_daily, stock_90d, first_ticker) if sentiment_daily is not None else None
-        decision_gauge = create_decision_gauge(decision, total_score)
-        
-        summary = f"""
-## 🎯 Decision: **{decision}**
-- **Ticker**: {first_ticker}
-- **Current Price**: ${tech_df['Close'].iloc[-1]:.2f}
-- **Total Score**: {total_score}/6
-- **Sentiment**: {avg_sentiment:.2f} ({sentiment_daily['article_count'].sum() if sentiment_daily is not None else 0} articles)
-- **Forecast**: {forecast_change:.1f}% → ${forecast_price:.2f}
+    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 analyzer.tech_df.empty:
+                continue # Skip if no data
+            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 the entered tickers.", None, gr.Accordion(visible=False)
+
+    # 1. Create the comparative multi-ticker plot
+    multi_plot = Plotter.create_multi_ticker_plot(
+        {t: r.tech_df for t, r in all_results.items()},
+        show_bollinger, time_range
+    )
+
+    # 2. Create the dynamic accordion with results for each ticker
+    accordion_items = []
+    for ticker, analyzer in all_results.items():
+        # Summary Tab Content
+        summary_md = f"""
+        ### 🎯 Decision: **{analyzer.decision}** (Score: {analyzer.total_score}/6)
+        - **Current Price:** `${analyzer.tech_df['Close'].iloc[-1]:.2f}`
+        - **Technical Score:** `{analyzer.scores['Technical']}`
+        - **Sentiment Score:** `{analyzer.scores['Sentiment']}` (Avg: {analyzer.sentiment_daily['avg_sentiment'].mean():.2f})
+        - **Forecast Score:** `{analyzer.scores['Forecast']}` ({analyzer.forecast_pct:.1f}% change to `${analyzer.forecast_price:.2f}`)
         """
-        
-        return summary, technical_plot, sentiment_plot, decision_gauge, None, "Success"
-    
-    except Exception as e:
-        return f"Error: {str(e)}", None, None, None, None, "Failed"
+        gauge_plot = Plotter.create_decision_gauge(analyzer.decision, analyzer.total_score)
+        summary_col = gr.Column(
+            gr.Markdown(summary_md),
+            gr.Plot(gauge_plot)
+        )
 
-# ============================================================================
-# GRADIO INTERFACE
-# ============================================================================
+        # Sentiment Tab Content
+        sentiment_plot = Plotter.create_sentiment_plot(analyzer.sentiment_daily, ticker) if analyzer.sentiment_daily is not None else gr.Markdown("Sentiment data not available.")
 
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
+        # Forecast Tab Content
+        forecast_plot = Plotter.create_forecast_plot(analyzer.forecast_df, ticker) if analyzer.forecast_df is not None else gr.Markdown("Forecast could not be generated.")
+
+        # Assemble the accordion item
+        ticker_accordion = gr.Accordion(
+            label=f"📊 {ticker} Analysis",
+            open=ticker == tickers[0] # Open the first one by default
+        )
+        with ticker_accordion:
+            with gr.Tabs():
+                with gr.TabItem("📈 Summary & Decision"):
+                    summary_col.render()
+                with gr.TabItem("😊 Sentiment Analysis"):
+                    gr.Plot(sentiment_plot).render() if isinstance(sentiment_plot, go.Figure) else sentiment_plot.render()
+                with gr.TabItem("🔮 Forecast"):
+                    gr.Plot(forecast_plot).render() if isinstance(forecast_plot, go.Figure) else forecast_plot.render()
+        accordion_items.append(ticker_accordion)
+
+    progress(1, "Analysis complete!")
+    return "Analysis complete!", multi_plot, gr.Column(*accordion_items, visible=True)
+
+
+# --- Build the Gradio App ---
+with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="blue"), title="Stock Intelligence Dashboard") as demo:
     gr.Markdown("# 📊 Unified Stock Intelligence Dashboard")
-    gr.Markdown(f"**Technical Data**: {TECH_START} to {TECH_END} | **Sentiment**: Last {SENTIMENT_DAYS} days")
-    
-    with gr.Row():
-        with gr.Column():
-            tickers_input = gr.Textbox(label="Tickers (comma-separated, max 8)", value="NVDA, AAPL, MSFT")
-            with gr.Row():
-                show_bb = gr.Checkbox(label="Show Bollinger Bands", value=False)
-                time_range = gr.Radio(choices=["1M", "3M", "6M", "1Y", "YTD", "All"], value="1Y", label="Time Range")
-            refresh_sentiment = gr.Checkbox(label="Refresh News Data", value=False)
-            analyze_btn = gr.Button("Analyze", variant="primary")
-    
-    status = gr.Textbox(label="Status", interactive=False)
-    summary = gr.Markdown()
-    
+    gr.Markdown("An advanced tool for technical, sentiment, and predictive analysis of stocks.")
+
     with gr.Row():
-        decision_gauge = gr.Plot(label="Decision")
-        sentiment_plot = gr.Plot(label="Sentiment Analysis")
-    
-    technical_plot = gr.Plot(label="Multi-Ticker Technical Signals")
-    
+        with gr.Column(scale=1, min_width=300):
+            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 (ignore cache)", value=False)
+            analyze_btn = gr.Button("Analyze Stocks", variant="primary")
+            status_output = gr.Textbox(label="Status", interactive=False)
+            progress_bar = gr.Progress(track_tqdm=True)
+
+        with gr.Column(scale=4):
+            gr.Markdown("### Comparative Analysis")
+            technical_plot_output = gr.Plot()
+            results_accordion_output = gr.Column(visible=False)
+
     analyze_btn.click(
-        run_analysis,
-        inputs=[tickers_input, show_bb, time_range, refresh_sentiment],
-        outputs=[summary, technical_plot, sentiment_plot, decision_gauge, gr.Plot(), status]
+        fn=run_full_analysis,
+        inputs=[tickers_input, time_range, show_bb, force_refresh],
+        outputs=[status_output, technical_plot_output, results_accordion_output]
     )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(debug=True)