Update app.py

app.py

@@ -11,27 +11,23 @@ import yfinance as yf
 from prophet import Prophet
 import plotly.express as px
 import warnings
-import json
-from typing import List, Dict, Tuple, Optional
+from typing import Optional
 
-# Ignore common warnings from Prophet and yfinance
+# Ignore common warnings
 warnings.filterwarnings('ignore')
 
 # ============================================================================
 # ⚙️ 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
+    CACHE_TTL_HOURS = 12
+    SENTIMENT_DAYS = 90
+    TECH_DATA_YEARS = 3
 
-    # Plotting styles
     PLOT_TEMPLATE = "plotly_dark"
-    PRIMARY_COLOR = "#00BFFF"  # DeepSkyBlue
+    PRIMARY_COLOR = "#00BFFF"
     SENTIMENT_POSITIVE_COLOR = "rgba(0, 204, 102, 0.7)"
     SENTIMENT_NEGATIVE_COLOR = "rgba(255, 51, 51, 0.7)"
     SENTIMENT_NEUTRAL_COLOR = "rgba(128, 128, 128, 0.6)"
@@ -40,7 +36,6 @@ class Config:
 
     @classmethod
     def initialize(cls):
-        """Create the data directory if it doesn't exist."""
         os.makedirs(cls.DATA_DIR, exist_ok=True)
 
 Config.initialize()
@@ -49,38 +44,29 @@ Config.initialize()
 # 📦 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
 
         try:
             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
@@ -91,19 +77,17 @@ class CacheManager:
 # 🧠 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.sentiment_daily, _ = self._get_sentiment_data()
         self.forecast_pct, self.forecast_price, self.forecast_df = self._get_forecast()
         self.scores, self.decision, self.total_score = self._calculate_decision()
 
     def _get_technical_data(self) -> pd.DataFrame:
-        """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:
@@ -116,16 +100,16 @@ class StockAnalyzer:
             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."""
+    def _get_sentiment_data(self):
         cache_file = f"{self.ticker}_sentiment.csv"
         df_daily = CacheManager.load_df(cache_file)
         if df_daily is not None and not self.force_refresh:
-            return df_daily, None  # Detailed news_df not needed from cache
+            return df_daily, None
 
         end_date = datetime.now()
         start_date = end_date - timedelta(days=Config.SENTIMENT_DAYS)
         try:
+            # FIXED: Removed trailing spaces in URL!
             res = requests.get(
                 "https://finnhub.io/api/v1/company-news",
                 params={
@@ -161,8 +145,7 @@ class StockAnalyzer:
         CacheManager.save_df(daily_sentiment, cache_file)
         return daily_sentiment, news_df
 
-    def _get_forecast(self) -> Tuple[float, float, Optional[pd.DataFrame]]:
-        """Generates a 30-day price forecast using Prophet."""
+    def _get_forecast(self):
         if self.tech_df.empty:
             return 0, 0, None
         try:
@@ -178,9 +161,7 @@ class StockAnalyzer:
         except Exception:
             return 0, 0, None
 
-    def _calculate_decision(self) -> Tuple[Dict, str, int]:
-        """Calculates scores and a final investment decision."""
-        # Technical Score
+    def _calculate_decision(self):
         tech_score = 0
         if not self.tech_df.empty:
             last_signal = self.tech_df['Technical_Score'].iloc[-1]
@@ -189,7 +170,6 @@ class StockAnalyzer:
             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()
@@ -198,7 +178,6 @@ class StockAnalyzer:
             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
@@ -218,9 +197,7 @@ class StockAnalyzer:
 
     @staticmethod
     def _calculate_indicators(df: pd.DataFrame) -> pd.DataFrame:
-        """Calculates a suite of technical indicators."""
-        df = df.copy()  # Avoid modifying original
-
+        df = df.copy()
         # RSI
         delta = df['Close'].diff()
         gain = (delta.where(delta > 0, 0)).rolling(14).mean()
@@ -234,28 +211,23 @@ class StockAnalyzer:
         df['UpperBB'] = ma + 2 * std
         df['LowerBB'] = ma - 2 * std
 
-        # Stochastic Oscillator
+        # Stochastic
         ll = df['Low'].rolling(14).min()
         hh = df['High'].rolling(14).max()
         df['SlowK'] = ((df['Close'] - ll) / (hh - ll)) * 100
         df['SlowD'] = df['SlowK'].rolling(3).mean()
 
-        # Chaikin Money Flow (CMF) — FIXED SECTION
+        # CMF
         price_range = df['High'] - df['Low']
-        # Avoid division by zero
         price_range = price_range.replace(0, np.nan)
         mfv = ((df['Close'] - df['Low']) - (df['High'] - df['Close'])) / price_range * df['Volume']
-
         mfv_sum = mfv.rolling(20).sum()
         vol_sum = df['Volume'].rolling(20).sum()
-
-        # Use .values to prevent pandas alignment errors
         cmf_raw = mfv_sum.values / vol_sum.values
-        # Replace inf/-inf with NaN
         cmf_clean = np.where(np.isfinite(cmf_raw), cmf_raw, np.nan)
         df['CMF'] = cmf_clean
 
-        # Signals (using stricter thresholds)
+        # Signals
         df['RSI_Signal'] = np.where(df['RSI'] < 20, 1, np.where(df['RSI'] > 80, -1, 0))
         df['BB_Signal'] = np.where(df['Close'] < df['LowerBB'], 1, np.where(df['Close'] > df['UpperBB'], -1, 0))
         df['Stochastic_Signal'] = np.where((df['SlowK'] < 15) & (df['SlowD'] < 15), 1, np.where((df['SlowK'] > 85) & (df['SlowD'] > 85), -1, 0))
@@ -268,23 +240,24 @@ class StockAnalyzer:
 # 📈 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:
+    def create_multi_ticker_plot(data_dict, show_bollinger, time_range):
         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()
+            "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)
+        start_date = range_map.get(time_range, all_dates.min())
 
         for i, (ticker, df) in enumerate(data_dict.items()):
             df_plot = df[df.index >= start_date]
@@ -297,13 +270,16 @@ class Plotter:
 
             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.add_trace(go.Scatter(x=buy_signals.index, y=buy_signals['Close'], mode='markers', name=f'{ticker} Buy', marker=dict(symbol='triangle-up', color=color, size=8), hoverinfo='skip'))
+            fig.add_trace(go.Scatter(x=sell_signals.index, y=sell_signals['Close'], mode='markers', name=f'{ticker} Sell', marker=dict(symbol='triangle-down', color='white', size=6, line=dict(color=color, width=1)), hoverinfo='skip'))
 
         fig.update_layout(
-            title="Comparative Technical Analysis", template=Config.PLOT_TEMPLATE, height=600,
+            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"
+            yaxis_title="Stock Price (USD)",
+            hovermode="x unified"
         )
         return fig
 
@@ -314,7 +290,7 @@ class Plotter:
             mode="gauge+number", value=total_score,
             title={'text': decision, 'font': {'size': 24, 'color': 'white'}},
             gauge={
-                'axis': {'range': [-6, 6], 'tickwidth': 1, 'tickcolor': "darkblue"},
+                'axis': {'range': [-6, 6]},
                 'bar': {'color': colors.get(decision, '#FFD700')},
                 'steps': [
                     {'range': [-6, -4], 'color': 'rgba(255, 0, 0, 0.8)'},
@@ -352,13 +328,15 @@ class Plotter:
         return fig
 
 # ============================================================================
-# 🖥️ GRADIO INTERFACE & APP LOGIC
+# 🖥️ GRADIO INTERFACE
 # ============================================================================
 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
+    tickers = [t.strip().upper() for t in tickers_str.split(',') if t.strip()][:5]
     if not tickers:
-        return "Please enter at least one ticker.", None, gr.Column(visible=False)
+        return (
+            "Please enter at least one ticker.",
+            None, None, None, None
+        )
 
     progress(0, desc="Starting analysis...")
     all_results = {}
@@ -366,114 +344,91 @@ def run_full_analysis(tickers_str: str, time_range: str, show_bollinger: bool, f
         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
+            if not analyzer.tech_df.empty:
+                all_results[ticker] = analyzer
         except Exception as e:
             print(f"Error analyzing {ticker}: {e}")
             continue
 
     if not all_results:
-        return "Could not retrieve data for the entered tickers.", None, gr.Column(visible=False)
+        return (
+            "Could not retrieve data for any ticker.",
+            None, None, None, None
+        )
 
-    # 1. Create the comparative multi-ticker plot
+    # Multi-ticker price plot
     multi_plot = Plotter.create_multi_ticker_plot(
         {t: r.tech_df for t, r in all_results.items()},
         show_bollinger, time_range
     )
 
-    # 2. Create the dynamic accordion with results for each ticker
-    accordion_items = []
-    for ticker, analyzer in all_results.items():
-        # Summary Tab Content
-        current_price = analyzer.tech_df['Close'].iloc[-1] if not analyzer.tech_df.empty else 0.0
-        avg_sent = analyzer.sentiment_daily['avg_sentiment'].mean() if analyzer.sentiment_daily is not None else 0.0
-        summary_md = f"""
-        ### 🎯 Decision: **{analyzer.decision}** (Score: {analyzer.total_score}/6)
-        - **Current Price:** `${current_price:.2f}`
-        - **Technical Score:** `{analyzer.scores['Technical']}`
-        - **Sentiment Score:** `{analyzer.scores['Sentiment']}` (Avg: {avg_sent:.2f})
-        - **Forecast Score:** `{analyzer.scores['Forecast']}` ({analyzer.forecast_pct:.1f}% change to `${analyzer.forecast_price:.2f}`)
-        """
-        gauge_plot = Plotter.create_decision_gauge(analyzer.decision, analyzer.total_score)
-        summary_col = gr.Column(
-            gr.Markdown(summary_md),
-            gr.Plot(gauge_plot)
-        )
+    # Detailed analysis for FIRST ticker only
+    primary_ticker = tickers[0]
+    primary_analyzer = all_results.get(primary_ticker)
+    if not primary_analyzer:
+        primary_ticker = list(all_results.keys())[0]
+        primary_analyzer = all_results[primary_ticker]
+
+    # Summary
+    current_price = primary_analyzer.tech_df['Close'].iloc[-1]
+    avg_sent = primary_analyzer.sentiment_daily['avg_sentiment'].mean() if primary_analyzer.sentiment_daily is not None else 0.0
+    summary_md = f"""
+### 🎯 Decision: **{primary_analyzer.decision}** (Score: {primary_analyzer.total_score}/6)
+- **Ticker**: {primary_ticker}
+- **Current Price**: ${current_price:.2f}
+- **Technical Score**: `{primary_analyzer.scores['Technical']}`
+- **Sentiment Score**: `{primary_analyzer.scores['Sentiment']}` (Avg: {avg_sent:.2f})
+- **Forecast Score**: `{primary_analyzer.scores['Forecast']}` ({primary_analyzer.forecast_pct:.1f}% → ${primary_analyzer.forecast_price:.2f})
+"""
 
-        # 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.")
+    # Plots
+    gauge_plot = Plotter.create_decision_gauge(primary_analyzer.decision, primary_analyzer.total_score)
+    sentiment_plot = Plotter.create_sentiment_plot(primary_analyzer.sentiment_daily, primary_ticker) if primary_analyzer.sentiment_daily is not None else None
+    forecast_plot = Plotter.create_forecast_plot(primary_analyzer.forecast_df, primary_ticker) if primary_analyzer.forecast_df is not None else None
 
-        # 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.")
+    progress(1.0, "Done!")
+    return summary_md, multi_plot, gauge_plot, sentiment_plot, forecast_plot
 
-        # 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"):
-                    if isinstance(sentiment_plot, go.Figure):
-                        gr.Plot(sentiment_plot).render()
-                    else:
-                        sentiment_plot.render()
-                with gr.TabItem("🔮 Forecast"):
-                    if isinstance(forecast_plot, go.Figure):
-                        gr.Plot(forecast_plot).render()
-                    else:
-                        forecast_plot.render()
-        accordion_items.append(ticker_accordion)
-
-    progress(1, "Analysis complete!")
-    return "Analysis complete!", multi_plot, gr.Column(*accordion_items, visible=True)
-
-
-# Custom CSS for better appearance
+# Custom CSS
 custom_css = """
-.gradio-container {
-    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
-}
-.container {
-    max-width: 1200px;
-    margin: auto;
-}
-button#analyze-btn {
-    background-color: #003366;
-    color: white;
-    border: none;
-}
+.gradio-container { font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; }
 """
 
-# --- Build the Gradio App ---
+# Build App
 with gr.Blocks(theme=gr.themes.Monochrome(), css=custom_css) as demo:
     gr.Markdown("# 📊 Unified Stock Intelligence Dashboard")
-    gr.Markdown("An advanced tool for technical, sentiment, and predictive analysis of stocks.")
+    gr.Markdown("Technical, sentiment, and predictive analysis for up to 5 stocks.")
 
     with gr.Row():
-        with gr.Column(scale=1, min_width=300):
+        with gr.Column(scale=1):
             gr.Markdown("### Controls")
             tickers_input = gr.Textbox(label="Tickers (comma-separated, max 5)", value="NVDA,TSLA,MSFT")
             time_range = gr.Radio(choices=["1M", "3M", "6M", "1Y", "YTD", "All"], value="1Y", label="Chart Time Range")
             show_bb = gr.Checkbox(label="Show Bollinger Bands", value=True)
-            force_refresh = gr.Checkbox(label="Force Refresh Data (ignore cache)", value=False)
+            force_refresh = gr.Checkbox(label="Force Refresh Data", value=False)
             analyze_btn = gr.Button("Analyze Stocks", variant="primary")
             status_output = gr.Textbox(label="Status", interactive=False)
-            progress_bar = gr.Progress(track_tqdm=True)
 
         with gr.Column(scale=4):
-            gr.Markdown("### Comparative Analysis")
+            gr.Markdown("### Comparative Price Chart")
             technical_plot_output = gr.Plot()
-            results_accordion_output = gr.Column(visible=False)
 
+    # Detailed Analysis for Primary Ticker
+    gr.Markdown("### 🔍 Detailed Analysis (First Ticker)")
+    with gr.Row():
+        summary_output = gr.Markdown()
+        decision_gauge_output = gr.Plot()
+
+    with gr.Row():
+        sentiment_output = gr.Plot()
+        forecast_output = gr.Plot()
+
+    # NO gr.Progress() in layout!
     analyze_btn.click(
         fn=run_full_analysis,
         inputs=[tickers_input, time_range, show_bb, force_refresh],
-        outputs=[status_output, technical_plot_output, results_accordion_output]
+        outputs=[status_output, technical_plot_output, decision_gauge_output, sentiment_output, forecast_output]
     )
 
 if __name__ == "__main__":
-    demo.launch(debug=True)
+    demo.launch()