Update app.py

app.py

@@ -1,267 +1,571 @@
-import gradio as gr
+import os
 import pandas as pd
-import yfinance as yf
+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 yfinance as yf
+import warnings
+from prophet import Prophet
 import plotly.express as px
-import numpy as np
-from datetime import datetime
 
-# Fixed high thresholds (strict = fewer, stronger signals)
-THRESHOLDS = {
-    'RSI_lower': 15,        # Buy only if RSI < 15
-    'RSI_upper': 85,        # Sell only if RSI > 85
-    'Stochastic_lower': 15, # Buy only if Stochastic < 15
-    'Stochastic_upper': 85, # Sell only if Stochastic > 85
-    'CMF': 0.4,             # Buy if CMF < -0.4, Sell if CMF > 0.4
-    'BB': 5.0               # Require price 5% beyond Bollinger Band
-}
+warnings.filterwarnings('ignore')
+
+# Configuration
+class Config:
+    FINNHUB_API_KEY = "cuj17q1r01qm7p9n307gcuj17q1r01qm7p9n3080"
+    DEFAULT_DAYS = 30
+    DATA_DIR = "data"
+    
+    @classmethod
+    def initialize(cls):
+        os.makedirs(cls.DATA_DIR, exist_ok=True)
+
+Config.initialize()
+
+# ============================================================================
+# SENTIMENT ANALYSIS COMPONENTS
+# ============================================================================
+
+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']
 
-# 8 distinct colors for tickers
-COLORS = px.colors.qualitative.Plotly
+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, days=Config.DEFAULT_DAYS, 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=days)
+        
+        url = "https://finnhub.io/api/v1/company-news"
+        params = {
+            "symbol": self.symbol,
+            "from": start_date.strftime('%Y-%m-%d'),
+            "to": end_date.strftime('%Y-%m-%d'),
+            "token": Config.FINNHUB_API_KEY,
+        }
+        
+        try:
+            response = requests.get(url, params=params, timeout=10)
+            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')
+                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_score(self, days=30):
+        news_df = self.get_news(days)
+        if news_df.empty:
+            return 0, 0
+        
+        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
 
-# ======================
-# Indicator Functions
-# ======================
+# ============================================================================
+# TECHNICAL ANALYSIS COMPONENTS
+# ============================================================================
 
-def calculate_rsi(df):
+def calculate_rsi(df, window=14):
     delta = df['Close'].diff()
-    gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
-    loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
+    gain = (delta.where(delta > 0, 0)).rolling(window=window).mean()
+    loss = (-delta.where(delta < 0, 0)).rolling(window=window).mean()
     rs = gain / loss
     rsi = 100 - (100 / (1 + rs))
     return rsi
 
-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_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
+
+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_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
+    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
 
 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()
-
-# ======================
-# Signal Logic (Fixed Thresholds)
-# ======================
+    cmf = mfv.rolling(window=window).sum() / df['Volume'].rolling(window=window).sum()
+    return cmf
 
-def generate_signals(df):
+def calculate_technical_signals(df):
+    """Calculate all technical indicators and generate signals"""
     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)
-
-    t = THRESHOLDS
-    df['RSI_Signal'] = np.where(df['RSI'] < t['RSI_lower'], 1,
-                      np.where(df['RSI'] > t['RSI_upper'], -1, 0))
     
-    bb_buffer = t['BB'] / 100
-    below = df['Close'] < df['LowerBB'] * (1 - bb_buffer)
-    above = df['Close'] > df['UpperBB'] * (1 + bb_buffer)
-    df['BB_Signal'] = np.where(below & below.shift(1), 1,
-                     np.where(above & above.shift(1), -1, 0))
+    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))
     
-    df['Stochastic_Signal'] = np.where((df['SlowK'] < t['Stochastic_lower']) & (df['SlowD'] < t['Stochastic_lower']), 1,
-                             np.where((df['SlowK'] > t['Stochastic_upper']) & (df['SlowD'] > t['Stochastic_upper']), -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)
     
-    df['CMF_Signal'] = np.where(df['CMF'] < -t['CMF'], 1,
-                      np.where(df['CMF'] > t['CMF'], -1, 0))
     return df
 
-# ======================
-# Ultra-Minimal Plot
-# ======================
+# ============================================================================
+# FORECASTING COMPONENTS
+# ============================================================================
 
-def plot_chart(data_dict, show_bollinger, time_range):
-    fig = go.Figure()
-    
-    # Determine date range
-    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]
+def prophet_forecast_simple(df, days=30):
+    """Simple Prophet forecast returning just the trend direction"""
+    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.fit(prophet_df)
+        
+        # Make future dataframe
+        future = model.make_future_dataframe(periods=days)
+        forecast = model.predict(future)
+        
+        # Get current price and forecasted price
+        current_price = 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
+        
+    except Exception as e:
+        print(f"Forecast error: {e}")
+        return 0, 0
 
-    buy_points = []
-    sell_points = []
+# ============================================================================
+# INTEGRATED DECISION ENGINE
+# ============================================================================
 
-    for i, (ticker, df) in enumerate(data_dict.items()):
-        df = df[df.index >= start]
-        if df.empty:
-            continue
-        color = COLORS[i % len(COLORS)]
+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
         
-        # Price line
-        fig.add_trace(go.Scatter(
-            x=df.index, y=df['Close'],
-            mode='lines',
-            line=dict(color=color, width=1.8),
-            name=ticker,
-            showlegend=True
-        ))
+        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"
 
-        # Optional Bollinger Bands (gray, subtle)
-        if show_bollinger:
-            fig.add_trace(go.Scatter(
-                x=df.index, y=df['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.index, y=df['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'
-            ))
+# ============================================================================
+# VISUALIZATION FUNCTIONS
+# ============================================================================
 
-        # Collect signals
-        for date in df.index:
-            signals = [
-                ('RSI', df.loc[date, 'RSI_Signal']),
-                ('BB', df.loc[date, 'BB_Signal']),
-                ('Stochastic', df.loc[date, 'Stochastic_Signal']),
-                ('CMF', df.loc[date, 'CMF_Signal'])
-            ]
-            total = sum(sig for _, sig in signals)
-            price = df.loc[date, 'Close']
-            active = [name for name, sig in signals if sig == (1 if total > 0 else -1)]
-            if total > 0:
-                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:
-                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))
+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
 
-    # White ▲ Buy
-    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
-        ))
+def create_summary_chart(analysis):
+    """Create summary dashboard"""
+    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
+            }
+        }
+    ))
+    
+    fig.update_layout(
+        paper_bgcolor='#111111',
+        plot_bgcolor='#111111',
+        font={'color': "white"},
+        height=400
+    )
+    
+    return fig
 
-    # Black ▼ Sell
-    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
-        ))
+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
+    )
+    
+    return fig
 
-    # Ultra-minimal black theme
+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(
-        xaxis=dict(showgrid=False, zeroline=False, showline=False, ticks='', showticklabels=True),
-        yaxis=dict(showgrid=False, zeroline=False, showline=False, ticks='', showticklabels=True, tickprefix='$'),
-        plot_bgcolor='black',
-        paper_bgcolor='black',
-        font=dict(color='white', size=12),
-        showlegend=True,
-        legend=dict(
-            orientation='h',
-            yanchor='bottom',
-            y=1.02,
-            xanchor='center',
-            x=0.5,
-            bgcolor='rgba(0,0,0,0.6)',
-            font=dict(size=11)
-        ),
-        margin=dict(l=20, r=20, t=30, b=30),
-        height=700,
-        width=1100,
-        hovermode='x unified'
+        title=f'Score Breakdown (Total: {total_score})',
+        plot_bgcolor='#111111',
+        paper_bgcolor='#111111',
+        font=dict(color='white'),
+        yaxis=dict(range=[-3, 3]),
+        height=400
     )
+    
     return fig
 
-# ======================
-# Main Function
-# ======================
+# ============================================================================
+# GRADIO INTERFACE
+# ============================================================================
 
-def run_analysis(tickers_str, start_date, end_date, show_bollinger, time_range):
+def analyze_stock_comprehensive(symbol, days_back):
+    """Main analysis function for Gradio"""
     try:
-        tickers = [t.strip().upper() for t in tickers_str.split(',') if t.strip()][:8]
-        if not tickers:
-            raise ValueError("Enter at least one ticker symbol")
+        if not symbol:
+            return "Please enter a valid stock symbol.", None, None, None, "No data available."
+        
+        # Create decision engine
+        engine = TradingDecisionEngine(symbol)
+        
+        # Run comprehensive analysis
+        analysis = engine.analyze_comprehensive(days_back)
+        
+        if not analysis:
+            return "Unable to analyze this stock. Please check the symbol and try again.", None, None, None, "No data available."
+        
+        # Create visualizations
+        fig_summary, fig_technical, fig_scores = create_decision_dashboard(analysis)
+        
+        # Create summary text
+        summary = f"""
+# {analysis['symbol']} Trading Analysis
 
-        data = {}
-        for t in tickers:
-            df = yf.download(t, start=start_date, end=end_date)
-            if not df.empty:
-                if isinstance(df.columns, pd.MultiIndex):
-                    df.columns = df.columns.droplevel(1)
-                data[t] = generate_signals(df)
+## 🎯 RECOMMENDATION: {analysis['decision']}
+**Current Price:** ${analysis['current_price']:.2f}
+**Overall Score:** {analysis['total_score']}/10
 
-        if not data:
-            raise ValueError("No data found for the given tickers and date range")
+### 📊 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}
 
-        return plot_chart(data, show_bollinger, time_range)
+### 🔍 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:
-        fig = go.Figure()
-        fig.add_annotation(text=f"Error: {str(e)}", x=0.5, y=0.5, showarrow=False, font=dict(color="red", size=16))
-        fig.update_layout(plot_bgcolor='black', paper_bgcolor='black', height=700, width=1100)
-        return fig
+        return f"Error during analysis: {str(e)}", None, None, None, "Analysis failed."
 
-# ======================
-# Gradio UI (No Threshold Sliders!)
-# ======================
-
-with gr.Blocks(theme=gr.themes.Default()) as demo:
-    gr.Markdown("### 🔍 Strict Multi-Ticker Signal Viewer (Fixed High Thresholds)")
-    
-    with gr.Row():
-        with gr.Column(scale=1):
-            tickers_input = gr.Textbox(
-                label="Tickers (comma-separated, max 8)",
-                value="NVDA, AAPL, MSFT, TSLA"
-            )
-            start_input = gr.Textbox(label="Start Date", value="2022-01-01")
-            end_input = gr.Textbox(label="End Date", value="2026-01-01")
-            
-            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"
-            )
-            
-            btn = gr.Button("Analyze", variant="primary")
+# 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**")
         
-        chart = gr.Plot()
+        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")
+        
+        # Status
+        status = gr.Textbox(label="Status", interactive=False)
+        
+        # Summary
+        summary_text = gr.Markdown()
+        
+        # Charts
+        with gr.Row():
+            decision_chart = gr.Plot(label="📊 Decision Summary")
+            scores_chart = gr.Plot(label="📈 Score Breakdown")
+        
+        technical_chart = gr.Plot(label="📉 Technical Analysis")
+        
+        # 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]
+        )
     
-    btn.click(
-        run_analysis,
-        inputs=[tickers_input, start_input, end_input, show_bb, time_range],
-        outputs=chart
-    )
+    return app
 
-    gr.Markdown("""
-    - **▲ White** = Buy | **▼ Black** = Sell  
-    - Indicators: **RSI, Bollinger Bands, Stochastic, CMF**  
-    - Thresholds are **fixed and strict** (e.g., RSI buy < 15, sell > 85)  
-    - Toggle Bollinger Bands for context  
-    - Hover over signals to see details
-    """)
+# Main function
+def main():
+    app = build_interface()
+    app.launch(share=True, debug=True)
 
 if __name__ == "__main__":
-    demo.launch()
+    main()