Update app.py

app.py

@@ -14,10 +14,16 @@ import plotly.express as px
 
 warnings.filterwarnings('ignore')
 
-# Configuration
+# ============================================================================
+# CONFIGURATION (FIXED DATES)
+# ============================================================================
+
+TECH_START = "2022-01-01"
+TECH_END = "2026-01-01"
+SENTIMENT_DAYS = 90  # Always last 90 days
+
 class Config:
-    FINNHUB_API_KEY = "cuj17q1r01qm7p9n307gcuj17q1r01qm7p9n3080"
-    DEFAULT_DAYS = 30
+    FINNHUB_API_KEY = "cuj17q1r01qm7p9n307gcuj17q1r01qm7p9n3080"  # Replace with your key
     DATA_DIR = "data"
     
     @classmethod
@@ -27,7 +33,7 @@ class Config:
 Config.initialize()
 
 # ============================================================================
-# SENTIMENT ANALYSIS COMPONENTS
+# SENTIMENT ANALYSIS (90 DAYS ONLY)
 # ============================================================================
 
 class SentimentAnalyzer:
@@ -47,9 +53,8 @@ class StockNewsAnalyzer:
     def get_file_path(self, file_type):
         return os.path.join(Config.DATA_DIR, f"{self.symbol}_{file_type}.csv")
     
-    def get_news(self, days=Config.DEFAULT_DAYS, force_refresh=False):
+    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'])
@@ -57,9 +62,9 @@ class StockNewsAnalyzer:
                 pass
         
         end_date = datetime.now()
-        start_date = end_date - timedelta(days=days)
+        start_date = end_date - timedelta(days=SENTIMENT_DAYS)
         
-        url = "https://finnhub.io/api/v1/company-news"
+        url = "https://finnhub.io/api/v1/company-news"  # FIXED: no trailing spaces
         params = {
             "symbol": self.symbol,
             "from": start_date.strftime('%Y-%m-%d'),
@@ -70,10 +75,8 @@ class StockNewsAnalyzer:
         try:
             response = requests.get(url, params=params, timeout=10)
             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')
@@ -84,488 +87,269 @@ class StockNewsAnalyzer:
             print(f"Error fetching news: {e}")
             return pd.DataFrame()
     
-    def get_sentiment_score(self, days=30):
-        news_df = self.get_news(days)
-        if news_df.empty:
-            return 0, 0
+    def get_sentiment_data(self):
+        news_df = self.get_news()
+        if news_df.empty or 'headline' not in news_df.columns:
+            return None, None
+        
+        news_df['sentiment_score'] = news_df['headline'].apply(self.sentiment_analyzer.analyze)
+        news_df['date'] = pd.to_datetime(news_df['datetime'].dt.date)
         
-        if 'headline' in news_df.columns:
-            news_df['sentiment_score'] = news_df['headline'].apply(self.sentiment_analyzer.analyze)
-            avg_sentiment = news_df['sentiment_score'].mean()
-            article_count = len(news_df)
-            return avg_sentiment, article_count
-        return 0, 0
+        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)))
+        ).reset_index()
+        
+        return daily, news_df
 
 # ============================================================================
-# TECHNICAL ANALYSIS COMPONENTS
+# TECHNICAL INDICATORS (ULTRA-STRICT, FIXED DATES)
 # ============================================================================
 
-def calculate_rsi(df, window=14):
+def calculate_rsi(df):
     delta = df['Close'].diff()
-    gain = (delta.where(delta > 0, 0)).rolling(window=window).mean()
-    loss = (-delta.where(delta < 0, 0)).rolling(window=window).mean()
+    gain = (delta.where(delta > 0, 0)).rolling(14).mean()
+    loss = (-delta.where(delta < 0, 0)).rolling(14).mean()
     rs = gain / loss
-    rsi = 100 - (100 / (1 + rs))
-    return rsi
-
-def calculate_macd(df):
-    short_ema = df['Close'].ewm(span=12, adjust=False).mean()
-    long_ema = df['Close'].ewm(span=26, adjust=False).mean()
-    macd = short_ema - long_ema
-    signal = macd.ewm(span=9, adjust=False).mean()
-    return macd, signal
+    return 100 - (100 / (1 + rs))
 
-def calculate_bollinger_bands(df, window=20):
-    middle_bb = df['Close'].rolling(window=window).mean()
-    upper_bb = middle_bb + 2 * df['Close'].rolling(window=window).std()
-    lower_bb = middle_bb - 2 * df['Close'].rolling(window=window).std()
-    return middle_bb, upper_bb, lower_bb
+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):
-    lowest_low = df['Low'].rolling(window=14).min()
-    highest_high = df['High'].rolling(window=14).max()
-    slowk = ((df['Close'] - lowest_low) / (highest_high - lowest_low)) * 100
-    slowd = slowk.rolling(window=3).mean()
-    return slowk, slowd
+    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']
-    cmf = mfv.rolling(window=window).sum() / df['Volume'].rolling(window=window).sum()
-    return cmf
+    return mfv.rolling(window).sum() / df['Volume'].rolling(window).sum()
 
-def calculate_technical_signals(df):
-    """Calculate all technical indicators and generate signals"""
+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)
     
-    macd, signal = calculate_macd(df)
-    
-    # Generate signals (1 = buy, -1 = sell, 0 = neutral)
-    df['RSI_Signal'] = np.where(df['RSI'] < 30, 1, np.where(df['RSI'] > 70, -1, 0))
-    df['MACD_Signal'] = np.where((macd > signal) & (macd.shift(1) <= signal.shift(1)), 1, 
-                                np.where((macd < signal) & (macd.shift(1) >= signal.shift(1)), -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'] < 20) & (df['SlowD'] < 20), 1, 
-                                      np.where((df['SlowK'] > 80) & (df['SlowD'] > 80), -1, 0))
-    df['CMF_Signal'] = np.where(df['CMF'] > 0.2, 1, np.where(df['CMF'] < -0.2, -1, 0))
-    
-    # Combined technical signal
-    technical_signals = ['RSI_Signal', 'MACD_Signal', 'BB_Signal', 'Stochastic_Signal', 'CMF_Signal']
-    df['Technical_Score'] = df[technical_signals].sum(axis=1)
+    # 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
 
 # ============================================================================
-# FORECASTING COMPONENTS
+# FORECASTING (PROPHET, FIXED DATES)
 # ============================================================================
 
-def prophet_forecast_simple(df, days=30):
-    """Simple Prophet forecast returning just the trend direction"""
+def prophet_forecast(df):
     try:
-        # Prepare data for Prophet
         prophet_df = df.reset_index()[['Date', 'Close']].rename(columns={'Date': 'ds', 'Close': 'y'})
         prophet_df['ds'] = pd.to_datetime(prophet_df['ds'])
-        
-        # Fit model
-        model = Prophet(daily_seasonality=False, yearly_seasonality=False, weekly_seasonality=False)
+        model = Prophet()
         model.fit(prophet_df)
-        
-        # Make future dataframe
-        future = model.make_future_dataframe(periods=days)
+        future = model.make_future_dataframe(periods=30)
         forecast = model.predict(future)
-        
-        # Get current price and forecasted price
-        current_price = prophet_df['y'].iloc[-1]
+        current = prophet_df['y'].iloc[-1]
         future_price = forecast['yhat'].iloc[-1]
-        
-        # Calculate percentage change
-        pct_change = ((future_price - current_price) / current_price) * 100
-        
-        return pct_change, future_price
-        
+        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
+        return 0, 0, None
 
 # ============================================================================
-# INTEGRATED DECISION ENGINE
+# VISUALIZATIONS
 # ============================================================================
 
-class TradingDecisionEngine:
-    def __init__(self, symbol):
-        self.symbol = symbol.upper()
-        self.news_analyzer = StockNewsAnalyzer(symbol)
-    
-    def fetch_stock_data(self, start_date, end_date):
-        """Fetch stock data"""
-        try:
-            stock_data = yf.download(self.symbol, start=start_date, end=end_date)
-            if isinstance(stock_data.columns, pd.MultiIndex):
-                stock_data.columns = stock_data.columns.droplevel(1)
-            return stock_data
-        except Exception as e:
-            print(f"Error fetching stock data: {e}")
-            return pd.DataFrame()
-    
-    def analyze_comprehensive(self, days_back=90):
-        """Comprehensive analysis combining all factors"""
-        try:
-            # Fetch stock data
-            end_date = datetime.now()
-            start_date = end_date - timedelta(days=days_back)
-            
-            df = self.fetch_stock_data(start_date, end_date)
-            if df.empty:
-                return None
-            
-            # Technical analysis
-            df = calculate_technical_signals(df)
-            
-            # Sentiment analysis
-            sentiment_score, article_count = self.news_analyzer.get_sentiment_score(days=30)
-            
-            # Forecast
-            forecast_change, forecast_price = prophet_forecast_simple(df, days=30)
-            
-            # Current metrics
-            current_price = df['Close'].iloc[-1]
-            current_technical = df['Technical_Score'].iloc[-1]
-            current_rsi = df['RSI'].iloc[-1]
-            current_macd, current_signal = calculate_macd(df)
-            
-            # Decision scoring
-            scores = {
-                'sentiment': self._score_sentiment(sentiment_score),
-                'technical': self._score_technical(current_technical),
-                'forecast': self._score_forecast(forecast_change),
-                'rsi': self._score_rsi(current_rsi),
-                'momentum': self._score_momentum(df)
-            }
-            
-            # Calculate final decision
-            total_score = sum(scores.values())
-            decision = self._make_decision(total_score)
-            
-            return {
-                'symbol': self.symbol,
-                'current_price': current_price,
-                'decision': decision,
-                'total_score': total_score,
-                'scores': scores,
-                'sentiment_score': sentiment_score,
-                'article_count': article_count,
-                'technical_score': current_technical,
-                'forecast_change': forecast_change,
-                'forecast_price': forecast_price,
-                'rsi': current_rsi,
-                'dataframe': df
-            }
-            
-        except Exception as e:
-            print(f"Analysis error: {e}")
-            return None
-    
-    def _score_sentiment(self, sentiment):
-        """Score sentiment from -2 to +2"""
-        if sentiment > 0.3: return 2
-        elif sentiment > 0.1: return 1
-        elif sentiment > -0.1: return 0
-        elif sentiment > -0.3: return -1
-        else: return -2
-    
-    def _score_technical(self, technical_score):
-        """Score technical indicators from -2 to +2"""
-        if technical_score >= 3: return 2
-        elif technical_score >= 1: return 1
-        elif technical_score <= -3: return -2
-        elif technical_score <= -1: return -1
-        else: return 0
-    
-    def _score_forecast(self, forecast_change):
-        """Score forecast from -2 to +2"""
-        if forecast_change > 10: return 2
-        elif forecast_change > 5: return 1
-        elif forecast_change < -10: return -2
-        elif forecast_change < -5: return -1
-        else: return 0
-    
-    def _score_rsi(self, rsi):
-        """Score RSI from -2 to +2"""
-        if rsi < 20: return 2  # Very oversold - strong buy
-        elif rsi < 30: return 1  # Oversold - buy
-        elif rsi > 80: return -2  # Very overbought - strong sell
-        elif rsi > 70: return -1  # Overbought - sell
-        else: return 0
-    
-    def _score_momentum(self, df):
-        """Score price momentum"""
-        if len(df) < 10:
-            return 0
-        
-        current = df['Close'].iloc[-1]
-        week_ago = df['Close'].iloc[-5] if len(df) >= 5 else current
-        
-        change = ((current - week_ago) / week_ago) * 100
-        
-        if change > 5: return 1
-        elif change < -5: return -1
-        else: return 0
-    
-    def _make_decision(self, total_score):
-        """Make final trading decision"""
-        if total_score >= 5:
-            return "STRONG BUY"
-        elif total_score >= 2:
-            return "BUY"
-        elif total_score <= -5:
-            return "STRONG SELL"
-        elif total_score <= -2:
-            return "SELL"
-        else:
-            return "HOLD"
-
-# ============================================================================
-# VISUALIZATION FUNCTIONS
-# ============================================================================
-
-def create_decision_dashboard(analysis_result):
-    """Create comprehensive dashboard"""
-    if not analysis_result:
-        return None, None, None
-    
-    # Extract data
-    symbol = analysis_result['symbol']
-    decision = analysis_result['decision']
-    scores = analysis_result['scores']
-    df = analysis_result['dataframe']
-    
-    # 1. Decision Summary Chart
-    fig_summary = create_summary_chart(analysis_result)
-    
-    # 2. Technical Analysis Chart
-    fig_technical = create_technical_chart(df, symbol)
-    
-    # 3. Score Breakdown Chart
-    fig_scores = create_scores_chart(scores, analysis_result['total_score'])
-    
-    return fig_summary, fig_technical, fig_scores
-
-def create_summary_chart(analysis):
-    """Create summary dashboard"""
+def create_multi_ticker_plot(data_dict, show_bollinger, time_range):
     fig = go.Figure()
-    
-    # Decision color mapping
-    decision_colors = {
-        'STRONG BUY': '#00FF00',
-        'BUY': '#90EE90',
-        'HOLD': '#FFD700',
-        'SELL': '#FFA500',
-        'STRONG SELL': '#FF0000'
-    }
-    
-    decision = analysis['decision']
-    color = decision_colors.get(decision, '#FFD700')
-    
-    # Create gauge chart for decision strength
-    fig.add_trace(go.Indicator(
-        mode="gauge+number+delta",
-        value=analysis['total_score'],
-        domain={'x': [0, 1], 'y': [0, 1]},
-        title={'text': f"{analysis['symbol']} - {decision}"},
-        delta={'reference': 0},
-        gauge={
-            'axis': {'range': [None, 10]},
-            'bar': {'color': color},
-            'steps': [
-                {'range': [-10, -2], 'color': "lightgray"},
-                {'range': [-2, 2], 'color': "gray"},
-                {'range': [2, 10], 'color': "lightgreen"}
-            ],
-            'threshold': {
-                'line': {'color': "red", 'width': 4},
-                'thickness': 0.75,
-                'value': 90
-            }
-        }
-    ))
+    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:
+        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(
-        paper_bgcolor='#111111',
-        plot_bgcolor='#111111',
-        font={'color': "white"},
-        height=400
+        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_technical_chart(df, symbol):
-    """Create technical analysis chart"""
-    fig = make_subplots(rows=3, cols=1, 
-                       subplot_titles=('Price & Bollinger Bands', 'RSI', 'MACD'),
-                       vertical_spacing=0.05,
-                       row_heights=[0.6, 0.2, 0.2])
-    
-    # Price and Bollinger Bands
-    fig.add_trace(go.Scatter(x=df.index, y=df['Close'], name='Close Price', 
-                           line=dict(color='#00FFFF', width=2)), row=1, col=1)
-    fig.add_trace(go.Scatter(x=df.index, y=df['UpperBB'], name='Upper BB', 
-                           line=dict(color='red', dash='dash')), row=1, col=1)
-    fig.add_trace(go.Scatter(x=df.index, y=df['LowerBB'], name='Lower BB', 
-                           line=dict(color='red', dash='dash')), row=1, col=1)
-    
-    # RSI
-    fig.add_trace(go.Scatter(x=df.index, y=df['RSI'], name='RSI', 
-                           line=dict(color='#FF6B6B')), row=2, col=1)
-    fig.add_hline(y=70, line_dash="dash", line_color="red", row=2, col=1)
-    fig.add_hline(y=30, line_dash="dash", line_color="green", row=2, col=1)
-    
-    # MACD
-    macd, signal = calculate_macd(df)
-    fig.add_trace(go.Scatter(x=df.index, y=macd, name='MACD', 
-                           line=dict(color='#4ECDC4')), row=3, col=1)
-    fig.add_trace(go.Scatter(x=df.index, y=signal, name='Signal', 
-                           line=dict(color='#FFE66D')), row=3, col=1)
-    
-    fig.update_layout(
-        title=f'{symbol} Technical Analysis',
-        plot_bgcolor='#111111',
-        paper_bgcolor='#111111',
-        font=dict(color='white'),
-        height=800,
-        showlegend=False
-    )
-    
+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_scores_chart(scores, total_score):
-    """Create score breakdown chart"""
-    categories = list(scores.keys())
-    values = list(scores.values())
-    colors = ['#00FF00' if v > 0 else '#FF0000' if v < 0 else '#FFD700' for v in values]
-    
-    fig = go.Figure(data=[
-        go.Bar(x=categories, y=values, marker_color=colors, text=values, textposition='auto')
-    ])
-    
-    fig.update_layout(
-        title=f'Score Breakdown (Total: {total_score})',
-        plot_bgcolor='#111111',
-        paper_bgcolor='#111111',
-        font=dict(color='white'),
-        yaxis=dict(range=[-3, 3]),
-        height=400
-    )
-    
+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
 
 # ============================================================================
-# GRADIO INTERFACE
+# MAIN ANALYSIS FUNCTION
 # ============================================================================
 
-def analyze_stock_comprehensive(symbol, days_back):
-    """Main analysis function for Gradio"""
+def run_analysis(tickers_str, show_bollinger, time_range, refresh_sentiment):
     try:
-        if not symbol:
-            return "Please enter a valid stock symbol.", None, None, None, "No data available."
+        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"
         
-        # Create decision engine
-        engine = TradingDecisionEngine(symbol)
+        # === 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)
         
-        # Run comprehensive analysis
-        analysis = engine.analyze_comprehensive(days_back)
+        if not data_dict:
+            return "No technical data found", None, None, None, None, "No data"
         
-        if not analysis:
-            return "Unable to analyze this stock. Please check the symbol and try again.", None, None, None, "No data available."
+        # === SENTIMENT & FORECAST (FIRST TICKER ONLY) ===
+        first_ticker = tickers[0]
+        news_analyzer = StockNewsAnalyzer(first_ticker)
+        sentiment_daily, _ = news_analyzer.get_sentiment_data()
         
-        # Create visualizations
-        fig_summary, fig_technical, fig_scores = create_decision_dashboard(analysis)
+        # 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)
         
-        # Create summary text
-        summary = f"""
-# {analysis['symbol']} Trading Analysis
-
-## 🎯 RECOMMENDATION: {analysis['decision']}
-**Current Price:** ${analysis['current_price']:.2f}
-**Overall Score:** {analysis['total_score']}/10
-
-### 📊 Analysis Breakdown:
-- **Sentiment Score:** {analysis['sentiment_score']:.3f} ({analysis['article_count']} articles)
-- **Technical Score:** {analysis['technical_score']}
-- **Forecast:** {analysis['forecast_change']:.1f}% (Target: ${analysis['forecast_price']:.2f})
-- **RSI:** {analysis['rsi']:.1f}
-
-### 🔍 Individual Scores:
-- **Sentiment:** {analysis['scores']['sentiment']}/2
-- **Technical:** {analysis['scores']['technical']}/2  
-- **Forecast:** {analysis['scores']['forecast']}/2
-- **RSI:** {analysis['scores']['rsi']}/2
-- **Momentum:** {analysis['scores']['momentum']}/2
-
-### 📈 Decision Logic:
-- **Strong Buy (≥5):** Multiple positive signals align
-- **Buy (≥2):** More positive than negative signals  
-- **Hold (-1 to 1):** Mixed or neutral signals
-- **Sell (≤-2):** More negative than positive signals
-- **Strong Sell (≤-5):** Multiple negative signals align
-        """
-        
-        return summary, fig_summary, fig_technical, fig_scores, "Analysis completed successfully!"
-        
-    except Exception as e:
-        return f"Error during analysis: {str(e)}", None, None, None, "Analysis failed."
-
-# Build Gradio interface
-def build_interface():
-    """Create the integrated Gradio interface"""
-    with gr.Blocks(title="Integrated Trading Decision App", theme=gr.themes.Soft()) as app:
-        gr.Markdown("# 📈 Integrated Stock Trading Decision System")
-        gr.Markdown("**Combines sentiment analysis, technical indicators, and AI forecasting for comprehensive trading decisions**")
-        
-        with gr.Row():
-            with gr.Column(scale=1):
-                symbol_input = gr.Textbox(
-                    label="Stock Symbol", 
-                    value="AAPL", 
-                    placeholder="e.g., AAPL, MSFT, GOOGL, TSLA"
-                )
-                days_input = gr.Slider(
-                    label="Analysis Period (Days)", 
-                    minimum=30, 
-                    maximum=365, 
-                    value=90, 
-                    step=1
-                )
-                analyze_button = gr.Button("🔍 Analyze Stock", variant="primary", size="lg")
+        # Forecast
+        tech_df = data_dict[first_ticker]
+        forecast_change, forecast_price, _ = prophet_forecast(tech_df)
         
-        # Status
-        status = gr.Textbox(label="Status", interactive=False)
-        
-        # Summary
-        summary_text = gr.Markdown()
+        # 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"
         
-        # Charts
-        with gr.Row():
-            decision_chart = gr.Plot(label="📊 Decision Summary")
-            scores_chart = gr.Plot(label="📈 Score Breakdown")
+        # === 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)
         
-        technical_chart = gr.Plot(label="📉 Technical Analysis")
+        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}
+        """
         
-        # Set up event handler
-        analyze_button.click(
-            fn=analyze_stock_comprehensive,
-            inputs=[symbol_input, days_input],
-            outputs=[summary_text, decision_chart, technical_chart, scores_chart, status]
-        )
+        return summary, technical_plot, sentiment_plot, decision_gauge, None, "Success"
     
-    return app
+    except Exception as e:
+        return f"Error: {str(e)}", None, None, None, None, "Failed"
 
-# Main function
-def main():
-    app = build_interface()
-    app.launch(share=True, debug=True)
+# ============================================================================
+# GRADIO INTERFACE
+# ============================================================================
+
+with gr.Blocks(theme=gr.themes.Soft()) 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()
+    
+    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")
+    
+    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]
+    )
 
 if __name__ == "__main__":
-    main()
+    demo.launch()