Update model.py

model.py

@@ -1,678 +1,678 @@
-"""
-model.py  –  StockBuddy ML / NLP core
-========================================
-LIGHTWEIGHT CHANGES vs original:
-  [OPT-1]  Removed `transformers` pipeline (was downloading ~1.2 GB BART model at
-           runtime).  Replaced with a fast NLTK-based extractive summariser.
-  [OPT-2]  Reduced technical indicators: 11 → 6 features (kept only the ones with
-           highest predictive signal; fewer features = smaller tensors & faster fits).
-  [OPT-3]  LSTM architecture: 4 layers (64/64/32/32 units) → 2 layers (32/16 units).
-           Still accurate enough for short-horizon forecasts, ~8× fewer parameters.
-  [OPT-4]  time_step: 45 → 30  (shorter look-back window → smaller tensors).
-  [OPT-5]  Epochs: 30 → 15,  batch_size: 64 → 32 (free-tier CPU training time).
-  [OPT-6]  XGBoost n_estimators: 300 → 100, max_depth 6 → 4.
-  [OPT-7]  EarlyStopping patience reduced (5 instead of 10) so training exits fast
-           when the model has converged.
-  All public function signatures are identical to the original so app.py needs
-  only minimal changes.
-"""
-
-import numpy as np
-import pandas as pd
-import requests
-from sklearn.preprocessing import MinMaxScaler
-from tensorflow.keras.models import Sequential
-from tensorflow.keras.layers import LSTM, Dense, Dropout
-import xgboost as xgb
-import plotly.graph_objects as go
-from datetime import datetime, timedelta
-import nltk
-from nltk.sentiment.vader import SentimentIntensityAnalyzer
-# [OPT-1] No longer importing transformers – see generate_sentiment_summary below
-import time
-
-# Download VADER lexicon once (tiny file, safe on free tier)
-nltk.download("vader_lexicon", quiet=True)
-
-# =============================================================================
-#                         API Keys (Replace with your own keys)
-# =============================================================================
-ALPHAVANTAGE_API_KEY = "IELF382B4X42YRTX"
-FINNHUB_API_KEY     = "cu5gvghr01qqj8u6iau0cu5gvghr01qqj8u6iaug"
-
-# =============================================================================
-#                     STOCK PRICE PREDICTION FUNCTIONS
-# =============================================================================
-
-def fetch_stock_data(symbol, outputsize="full"):
-    url = "https://www.alphavantage.co/query"
-    params = {
-        "function":   "TIME_SERIES_DAILY",
-        "symbol":     symbol,
-        "apikey":     ALPHAVANTAGE_API_KEY,
-        "outputsize": outputsize,
-        "datatype":   "json",
-    }
-    response = requests.get(url, params=params)
-    data = response.json()
-
-    if "Time Series (Daily)" not in data:
-        if "Error Message" in data:
-            raise ValueError(
-                f"Symbol '{symbol}' not found. Please verify the stock symbol.")
-        elif "Note" in data:
-            raise ValueError("API request limit reached. Please try again in a minute.")
-        elif "Information" in data:
-            raise ValueError(f"Your application is actually working perfectly. The prediction failed exactly when it was supposed to, because your API key ({ALPHAVANTAGE_API_KEY}) has genuinely maxed out its 25 free requests for today.")
-        else:
-            raise ValueError(
-                f"Unable to fetch data for symbol '{symbol}'. Please verify the symbol.")
-
-    ts = data["Time Series (Daily)"]
-
-    df = pd.DataFrame.from_dict(ts, orient="index")
-    df.index = pd.to_datetime(df.index)
-    df.sort_index(inplace=True)
-
-    for col in ["1. open", "2. high", "3. low", "4. close", "5. volume"]:
-        if col in df.columns:
-            df[col] = df[col].astype(float)
-
-    df = df.rename(columns={
-        "1. open":   "Open",
-        "2. high":   "High",
-        "3. low":    "Low",
-        "4. close":  "Close",
-        "5. volume": "Volume",
-    })
-
-    latest_date    = df.index[-1]
-    today          = pd.Timestamp.now().normalize()
-    market_closed_days = 0
-    if today.dayofweek >= 5:
-        market_closed_days = today.dayofweek - 4
-    elif today.hour < 16:
-        market_closed_days = 1
-    expected_latest = today - pd.Timedelta(days=market_closed_days)
-    date_diff = (expected_latest - latest_date).days
-    if date_diff > 5:
-        print(f"WARNING: Latest data for {symbol} is from "
-              f"{latest_date.strftime('%Y-%m-%d')} ({date_diff} days old).")
-
-    print(f"\nLatest closing price for {symbol} "
-          f"(as of {latest_date.strftime('%Y-%m-%d')}): ${df['Close'].iloc[-1]:.2f}")
-
-    # Add lightweight technical indicators
-    df = add_technical_indicators(df)
-    return df
-
-
-# [OPT-2] Reduced feature set: 11 → 6  (Close, RSI, SMA5, MACD, Upper_Band, ROC)
-def add_technical_indicators(df):
-    """Add a compact set of technical indicators (6 features vs 11 original)."""
-    try:
-        required_cols = ["Close", "Open", "High", "Low"]
-        for col in required_cols:
-            if col not in df.columns:
-                print(f"Warning: {col} missing – falling back to Close-only.")
-                return df[["Close"]]
-
-        # RSI (14-period)
-        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))
-
-        # Short moving average
-        df["SMA5"] = df["Close"].rolling(5).mean()
-
-        # MACD line only (signal line dropped to save a feature)
-        ema12       = df["Close"].ewm(span=12).mean()
-        ema26       = df["Close"].ewm(span=26).mean()
-        df["MACD"]  = ema12 - ema26
-
-        # Upper Bollinger Band as a proxy for volatility
-        ma20              = df["Close"].rolling(20).mean()
-        df["Upper_Band"]  = ma20 + (df["Close"].rolling(20).std() * 2)
-
-        # Rate-of-change (5-period)
-        df["ROC"] = df["Close"].pct_change(periods=5) * 100
-
-        df = df.dropna()
-
-        # [OPT-2] Only 6 features returned
-        features = ["Close", "RSI", "SMA5", "MACD", "Upper_Band", "ROC"]
-        return df[features]
-
-    except Exception as e:
-        print(f"Error adding technical indicators: {e}")
-        if "Close" in df.columns:
-            return df[["Close"]]
-        return df
-
-
-def preprocess_data(data):
-    """Scale each feature independently; return scaled array + Close scaler."""
-    features    = data.columns
-    scalers     = {}
-    scaled_data = np.zeros((len(data), len(features)))
-
-    for i, feature in enumerate(features):
-        scalers[feature] = MinMaxScaler(feature_range=(0, 1))
-        scaled_data[:, i] = (
-            scalers[feature]
-            .fit_transform(data[feature].values.reshape(-1, 1))
-            .flatten()
-        )
-
-    master_scaler = scalers["Close"]
-    return scaled_data, master_scaler
-
-
-def create_sequences(data, time_step=30):
-    """Create (X, y) sequences for LSTM training."""
-    X, y = [], []
-    for i in range(len(data) - time_step - 1):
-        X.append(data[i : i + time_step, :])   # all features
-        y.append(data[i + time_step, 0])         # Close price only
-    return np.array(X), np.array(y)
-
-
-# [OPT-3] Slimmed LSTM: 2 layers (32 / 16 units) instead of 4 layers (64/64/32/32)
-# [OPT-4] time_step default lowered to 30
-# [OPT-5] epochs 30 → 15, batch_size 64 → 32, EarlyStopping patience 10 → 5
-def train_lstm(X_train, y_train, time_step=30, stop_requested_callback=None):
-    """
-    Train a lightweight LSTM model.
-
-    Architecture change (OPT-3):
-      Original : LSTM(64) → LSTM(64) → Dropout → LSTM(32) → LSTM(32) → Dropout → Dense(16) → Dense(16) → Dense(1)
-      Updated  : LSTM(32) → Dropout(0.2) → LSTM(16) → Dropout(0.2) → Dense(1)
-    Parameter count drops from ~110 k to ~14 k for a 6-feature, 30-step input.
-    """
-    from tensorflow.keras.optimizers import Adam
-    from tensorflow.keras.callbacks import ReduceLROnPlateau, EarlyStopping, Callback
-
-    n_features = X_train.shape[2]
-    X_train    = X_train.reshape(X_train.shape[0], time_step, n_features)
-
-    # [OPT-3] Lightweight architecture
-    model = Sequential([
-        LSTM(32, return_sequences=True,
-             input_shape=(time_step, n_features)),
-        Dropout(0.2),
-        LSTM(16, return_sequences=False),
-        Dropout(0.2),
-        Dense(1),
-    ])
-
-    class StopCallback(Callback):
-        def on_epoch_end(self, epoch, logs=None):
-            if stop_requested_callback and stop_requested_callback():
-                self.model.stop_training = True
-                print("Training stopped early by user request.")
-
-    optimizer = Adam(learning_rate=0.001)
-    model.compile(optimizer=optimizer, loss="mean_squared_error")
-
-    # [OPT-7] Patience 10 → 5 for faster early exit on free-tier CPU
-    reduce_lr     = ReduceLROnPlateau(monitor="val_loss", factor=0.3,
-                                      patience=3, min_lr=0.0001, verbose=0)
-    early_stop    = EarlyStopping(monitor="val_loss", patience=5,
-                                  restore_best_weights=True, verbose=1)
-    callbacks     = [reduce_lr, early_stop]
-    if stop_requested_callback:
-        callbacks.append(StopCallback())
-
-    print(f"Training lightweight LSTM: {X_train.shape[0]} samples, "
-          f"{n_features} features, time_step={time_step}")
-
-    # [OPT-5] epochs 30 → 15, batch_size 64 → 32
-    model.fit(
-        X_train, y_train,
-        epochs=15,
-        batch_size=32,
-        validation_split=0.2,
-        callbacks=callbacks,
-        verbose=1,
-    )
-    return model
-
-
-# [OPT-6] XGBoost: n_estimators 300 → 100, max_depth 6 → 4
-def train_xgboost(X_train, residuals, stop_requested_callback=None):
-    """Train a leaner XGBoost model on LSTM residuals."""
-    if stop_requested_callback and stop_requested_callback():
-        print("XGBoost training cancelled due to stop request.")
-        return None
-
-    # [OPT-6] Reduced complexity for free-tier memory / speed
-    params = {
-        "objective":        "reg:squarederror",
-        "n_estimators":     100,   # was 300
-        "learning_rate":    0.1,
-        "max_depth":        4,     # was 6
-        "subsample":        0.8,
-        "colsample_bytree": 0.8,
-        "min_child_weight": 3,
-        "gamma":            0.1,
-        "reg_alpha":        0.1,
-        "reg_lambda":       1.0,
-        "tree_method":      "hist",
-    }
-
-    if stop_requested_callback:
-        class StopCallbackHandler(xgb.callback.TrainingCallback):
-            def after_iteration(self, model, epoch, evals_log):
-                if stop_requested_callback():
-                    print("XGBoost training stopped by user request.")
-                    return True
-                return False
-
-        xgb_model = xgb.XGBRegressor(**params)
-        xgb_model.set_params(callbacks=[StopCallbackHandler()])
-        xgb_model.fit(X_train, residuals)
-    else:
-        xgb_model = xgb.XGBRegressor(**params)
-        xgb_model.fit(
-            X_train, residuals,
-            eval_metric=["rmse"],
-            early_stopping_rounds=10,   # was 20 [OPT-6]
-            verbose=False,
-            eval_set=[(X_train, residuals)],
-        )
-
-    return xgb_model
-
-
-def predict_stock_price(
-    lstm_model, xgb_model, data, scaler,
-    time_step=30, days_ahead=5, stop_requested_callback=None
-):
-    """Make predictions using both LSTM and XGBoost with price anchoring."""
-    if stop_requested_callback and stop_requested_callback():
-        return None
-
-    n_features     = data.shape[1]
-    temp_input     = data[-time_step:].tolist()
-
-    last_actual_close = scaler.inverse_transform(
-        np.array([[data[-1, 0]]]))[0][0]
-    print(f"Base price: ${last_actual_close:.2f}")
-
-    original_prices = scaler.inverse_transform(data[:, 0].reshape(-1, 1))
-    daily_returns   = np.diff(original_prices, axis=0) / original_prices[:-1]
-    volatility      = np.std(daily_returns)
-
-    # Calibrate model against actual last price
-    lstm_input       = np.array(temp_input[-time_step:]).reshape(1, time_step, n_features)
-    lstm_pred_cal    = lstm_model.predict(lstm_input, verbose=0)[0][0]
-    xgb_input_cal    = np.array(temp_input[-time_step:]).reshape(1, -1)
-    try:
-        combined_cal = lstm_pred_cal + (xgb_model.predict(xgb_input_cal)[0]
-                                        if xgb_model is not None else 0)
-    except Exception:
-        combined_cal = lstm_pred_cal
-
-    model_current   = scaler.inverse_transform(
-        np.array([[combined_cal]]))[0][0]
-    correction_factor = (last_actual_close / model_current
-                         if model_current > 0 else 1.0)
-    print(f"Calibration: model=${model_current:.2f}, "
-          f"actual=${last_actual_close:.2f}, factor={correction_factor:.4f}")
-
-    predictions    = []
-    prev_day_pred  = combined_cal
-
-    for day in range(days_ahead):
-        if stop_requested_callback and stop_requested_callback():
-            print(f"Prediction stopped at day {day}/{days_ahead}")
-            break
-
-        lstm_input = np.array(temp_input[-time_step:]).reshape(1, time_step, n_features)
-        lstm_pred  = lstm_model.predict(lstm_input, verbose=0)[0][0]
-        xgb_input  = np.array(temp_input[-time_step:]).reshape(1, -1)
-
-        try:
-            combined_pred = (lstm_pred + xgb_model.predict(xgb_input)[0]
-                             if xgb_model is not None else lstm_pred)
-        except Exception as e:
-            print(f"XGBoost predict error: {e}")
-            combined_pred = lstm_pred
-
-        prev_unscaled    = scaler.inverse_transform(
-            np.array([[prev_day_pred]]))[0][0]
-        current_unscaled = scaler.inverse_transform(
-            np.array([[combined_pred]]))[0][0]
-        price_change     = current_unscaled - prev_unscaled
-        trend_direction  = 1 if price_change >= 0 else -1
-
-        day_volatility      = volatility * (1 + day * 0.1)
-        adjusted_volatility = min(day_volatility, 0.015)
-        random_factor       = np.random.normal(0, adjusted_volatility)
-
-        if trend_direction > 0:
-            flux_factor = (abs(random_factor) * trend_direction * 0.15
-                           if np.random.random() < 0.7
-                           else -abs(random_factor) * trend_direction * 0.3)
-        else:
-            flux_factor = (abs(random_factor) * trend_direction * 0.25
-                           if np.random.random() < 0.8
-                           else -abs(random_factor) * trend_direction * 0.1)
-
-        flux_amount      = prev_unscaled * flux_factor
-        adjusted_unscaled = current_unscaled + flux_amount
-        adjusted_pred     = scaler.transform(
-            np.array([[adjusted_unscaled]]))[0][0]
-
-        next_row    = temp_input[-1].copy()
-        next_row[0] = adjusted_pred
-        prev_day_pred = adjusted_pred
-
-        predictions.append(adjusted_pred)
-        temp_input.append(next_row)
-
-    if not predictions:
-        return None
-
-    final_predictions    = scaler.inverse_transform(
-        np.array(predictions).reshape(-1, 1))
-    corrected_predictions = final_predictions * correction_factor
-
-    print("\nPredictions (original → corrected):")
-    for i in range(len(final_predictions)):
-        print(f"  Day {i+1}: ${final_predictions[i][0]:.2f} "
-              f"→ ${corrected_predictions[i][0]:.2f}")
-
-    return corrected_predictions
-
-
-def plot_prices(data, predictions, symbol, days_ahead):
-    """Plot actual + predicted prices (used in standalone main())."""
-    fig = go.Figure()
-    three_months_ago = data.index[-1] - pd.DateOffset(months=3)
-    actual_data = data.loc[three_months_ago:]
-    close_prices = (actual_data["Close"]
-                    if isinstance(actual_data, pd.DataFrame) and "Close" in actual_data.columns
-                    else actual_data.iloc[:, 0])
-
-    future_dates = []
-    last_date = data.index[-1]
-    for i in range(1, days_ahead + 1):
-        next_date = last_date + timedelta(days=i)
-        while next_date.weekday() > 4:
-            next_date += timedelta(days=1)
-        future_dates.append(next_date)
-    future_dates    = list(dict.fromkeys(future_dates))
-    prediction_data = predictions[: len(future_dates)].flatten()
-
-    fig.add_trace(go.Scatter(
-        x=future_dates, y=prediction_data,
-        mode="lines+markers", name="Predicted Price",
-        line=dict(color="orange", width=3)))
-    fig.add_trace(go.Scatter(
-        x=close_prices.index, y=close_prices.values,
-        mode="lines", name="Actual Price",
-        line=dict(color="blue", width=2)))
-    fig.add_trace(go.Scatter(
-        x=[close_prices.index[-1]], y=[close_prices.values[-1]],
-        mode="markers", name="Latest Price",
-        marker=dict(color="green", size=10, symbol="circle")))
-
-    fig.update_layout(
-        title=f"Stock Price Prediction for {symbol}",
-        xaxis_title="Date", yaxis_title="Price (USD)",
-        template="plotly_white", hovermode="x unified")
-    fig.show()
-
-
-# =============================================================================
-#                   NEWS SENTIMENT ANALYSIS FUNCTIONS
-# =============================================================================
-
-def fetch_finnhub_news(company_symbol):
-    end_date      = datetime.now()
-    start_date    = end_date - timedelta(days=28)
-    url = (f"https://finnhub.io/api/v1/company-news"
-           f"?symbol={company_symbol}"
-           f"&from={start_date.strftime('%Y-%m-%d')}"
-           f"&to={end_date.strftime('%Y-%m-%d')}"
-           f"&token={FINNHUB_API_KEY}")
-    try:
-        response = requests.get(url)
-        if response.status_code == 200:
-            articles  = response.json()
-            headlines = [a["headline"] for a in articles if "headline" in a]
-            return headlines
-        else:
-            print(f"Error fetching news: {response.status_code}")
-            return []
-    except Exception as e:
-        print(f"Error parsing news response: {e}")
-        return []
-
-
-def analyze_sentiment(headlines):
-    try:
-        sid              = SentimentIntensityAnalyzer()
-        sentiment_results = []
-        sentiment_totals  = {"positive": 0, "negative": 0, "neutral": 0}
-
-        for headline in headlines:
-            if not headline or not isinstance(headline, str):
-                continue
-            sentiment = sid.polarity_scores(headline)
-            sentiment_results.append({"headline": headline, "sentiment": sentiment})
-            if sentiment["compound"] > 0.05:
-                sentiment_totals["positive"] += 1
-            elif sentiment["compound"] < -0.05:
-                sentiment_totals["negative"] += 1
-            else:
-                sentiment_totals["neutral"] += 1
-
-        return sentiment_results, sentiment_totals
-    except Exception as e:
-        print(f"Error in sentiment analysis: {e}")
-        return [], {"positive": 0, "negative": 0, "neutral": 0}
-
-
-def plot_sentiment_pie(sentiment_totals, company_symbol):
-    fig = go.Figure(data=[go.Pie(
-        labels=["Positive", "Negative", "Neutral"],
-        values=[sentiment_totals["positive"],
-                sentiment_totals["negative"],
-                sentiment_totals["neutral"]],
-        marker=dict(colors=["#2ecc71", "#e74c3c", "#95a5a6"],
-                    line=dict(color="white", width=0)),
-        textinfo="percent+label", textfont_size=20)])
-    fig.update_layout(
-        title=f"Sentiment Distribution for {company_symbol} (Last 28 Days)",
-        showlegend=True)
-    fig.show()
-
-
-# =============================================================================
-#          AI SUMMARY FUNCTIONS  [OPT-1] Transformers removed
-# =============================================================================
-
-def _extractive_summary(headlines, n=3):
-    """
-    Lightweight extractive summariser – replaces the BART transformer pipeline.
-    [OPT-1] Picks the top-n headlines by absolute VADER compound score so the
-    most opinionated sentences surface first.  No heavy model download needed.
-    """
-    if not headlines:
-        return ""
-    try:
-        sid    = SentimentIntensityAnalyzer()
-        scored = [(h, abs(sid.polarity_scores(h)["compound"]))
-                  for h in headlines if h and isinstance(h, str)]
-        scored.sort(key=lambda x: x[1], reverse=True)
-        top    = [h for h, _ in scored[:n]]
-        return " | ".join(top)
-    except Exception as e:
-        print(f"Extractive summary error: {e}")
-        return headlines[0] if headlines else ""
-
-
-def generate_sentiment_summary(sentiment_totals, headlines, company_symbol):
-    """
-    Generate a human-readable sentiment summary.
-    [OPT-1] Uses simple NLTK-based extractive summarisation instead of a
-    Transformers pipeline (removes ~1.2 GB BART model download).
-    """
-    try:
-        total   = max(1, sum(sentiment_totals.values()))
-        pos_pct = sentiment_totals["positive"] / total * 100
-        neg_pct = sentiment_totals["negative"] / total * 100
-
-        summary = (
-            f"Over the past 28 days, {len(headlines)} news articles about "
-            f"{company_symbol} were analysed. "
-            f"{sentiment_totals['positive']} positive ({pos_pct:.0f}%), "
-            f"{sentiment_totals['negative']} negative ({neg_pct:.0f}%), "
-            f"and {sentiment_totals['neutral']} neutral articles found."
-        )
-
-        if headlines:
-            key_headlines = _extractive_summary(headlines, n=2)
-            if key_headlines:
-                summary += f" Key headlines: {key_headlines}"
-
-        return summary
-    except Exception as e:
-        print(f"Error in generate_sentiment_summary: {e}")
-        return f"Unable to generate sentiment summary for {company_symbol}."
-
-
-def generate_prediction_summary(pred_df, company_symbol):
-    first_price = pred_df["Predicted Price"].iloc[0]
-    last_price  = pred_df["Predicted Price"].iloc[-1]
-    return (
-        f"The predicted stock prices for {company_symbol} range from "
-        f"${first_price:.2f} to ${last_price:.2f} over the forecast period."
-    )
-
-
-def display_price_table(data, predictions, symbol, days_ahead):
-    """Print prediction results as a table (used in standalone main())."""
-    if isinstance(data, pd.DataFrame) and "Close" in data.columns:
-        last_price = data["Close"].iloc[-1]
-        last_date  = data.index[-1]
-    else:
-        last_price = data.iloc[-1, 0]
-        last_date  = data.index[-1]
-
-    future_dates = []
-    for i in range(1, days_ahead + 1):
-        next_date = last_date + timedelta(days=i)
-        while next_date.weekday() > 4:
-            next_date += timedelta(days=1)
-        future_dates.append(next_date)
-    future_dates    = list(dict.fromkeys(future_dates))
-    prediction_data = predictions[: len(future_dates)].flatten()
-
-    last_price_row = pd.DataFrame({
-        "Date": [last_date.strftime("%Y-%m-%d")],
-        "Price": [f"${last_price:.2f}"],
-        "Change": ["0.00%"],
-        "Note": ["Actual last closing price"],
-    })
-    pred_rows = []
-    for i, (date, price) in enumerate(zip(future_dates, prediction_data)):
-        change_pct = ((price - last_price) / last_price) * 100
-        pred_rows.append({
-            "Date": date.strftime("%Y-%m-%d"),
-            "Price": f"${price:.2f}",
-            "Change": f"{change_pct:.2f}%",
-            "Note": f"Day {i+1} prediction",
-        })
-
-    combined_df = pd.concat([last_price_row, pd.DataFrame(pred_rows)],
-                            ignore_index=True)
-    print(f"\n{symbol} Stock Price Prediction Table:")
-    print("=" * 80)
-    print(combined_df.to_string(index=False))
-    print("=" * 80)
-
-    return pd.DataFrame({
-        "Date": [d.strftime("%Y-%m-%d") for d in future_dates],
-        "Predicted Price": prediction_data,
-    })
-
-
-# =============================================================================
-#                          STANDALONE MAIN
-# =============================================================================
-
-def main():
-    symbol = input("Enter the stock symbol (e.g., AAPL): ").upper()
-    try:
-        days_ahead = int(input("Number of future days to predict (e.g., 5): "))
-    except ValueError:
-        print("Invalid input. Please enter an integer.")
-        return
-
-    print(f"\nFetching historical data for {symbol}...")
-    data = fetch_stock_data(symbol, outputsize="full")
-    if data is None or len(data) < 50:
-        print(f"Not enough data points for {symbol}.")
-        return
-
-    print("Preprocessing data...")
-    scaled_data, scaler = preprocess_data(data)
-
-    # [OPT-4] time_step 60 → 30 in standalone mode too
-    time_step = 30
-    X, y = create_sequences(scaled_data, time_step)
-    if len(X) == 0:
-        print("Could not create sequences.")
-        return
-
-    train_size       = int(len(X) * 0.8)
-    X_train, y_train = X[:train_size], y[:train_size]
-
-    print("Training LSTM model...")
-    lstm_model = train_lstm(X_train, y_train, time_step)
-
-    lstm_train_preds = lstm_model.predict(X_train, verbose=0).flatten()
-    residuals        = y_train - lstm_train_preds
-
-    print("Training XGBoost model...")
-    xgb_model = train_xgboost(X_train.reshape(X_train.shape[0], -1), residuals)
-
-    print(f"Predicting {days_ahead} days ahead...")
-    predictions = predict_stock_price(
-        lstm_model, xgb_model, scaled_data, scaler, time_step, days_ahead)
-
-    display_price_table(data, predictions, symbol, days_ahead)
-
-    future_dates = []
-    last_date    = data.index[-1]
-    for i in range(1, days_ahead + 1):
-        next_date = last_date + timedelta(days=i)
-        while next_date.weekday() > 4:
-            next_date += timedelta(days=1)
-        future_dates.append(next_date)
-    future_dates = list(dict.fromkeys(future_dates))
-
-    pred_df = pd.DataFrame({
-        "Date": [d.strftime("%Y-%m-%d") for d in future_dates[: len(predictions)]],
-        "Predicted Price": predictions.flatten()[: len(future_dates)],
-    })
-    print("\nPrediction summary:")
-    print(generate_prediction_summary(pred_df, symbol))
-
-    print("\nFetching news for sentiment analysis...")
-    headlines = fetch_finnhub_news(symbol)
-    if headlines:
-        sentiment_results, sentiment_totals = analyze_sentiment(headlines)
-        plot_sentiment_pie(sentiment_totals, symbol)
-        print(generate_sentiment_summary(sentiment_totals, headlines, symbol))
-    else:
-        print("No headlines found.")
-
-
-if __name__ == "__main__":
-    main()
+"""
+model.py  –  StockBuddy ML / NLP core
+========================================
+LIGHTWEIGHT CHANGES vs original:
+  [OPT-1]  Removed `transformers` pipeline (was downloading ~1.2 GB BART model at
+           runtime).  Replaced with a fast NLTK-based extractive summariser.
+  [OPT-2]  Reduced technical indicators: 11 → 6 features (kept only the ones with
+           highest predictive signal; fewer features = smaller tensors & faster fits).
+  [OPT-3]  LSTM architecture: 4 layers (64/64/32/32 units) → 2 layers (32/16 units).
+           Still accurate enough for short-horizon forecasts, ~8× fewer parameters.
+  [OPT-4]  time_step: 45 → 30  (shorter look-back window → smaller tensors).
+  [OPT-5]  Epochs: 30 → 15,  batch_size: 64 → 32 (free-tier CPU training time).
+  [OPT-6]  XGBoost n_estimators: 300 → 100, max_depth 6 → 4.
+  [OPT-7]  EarlyStopping patience reduced (5 instead of 10) so training exits fast
+           when the model has converged.
+  All public function signatures are identical to the original so app.py needs
+  only minimal changes.
+"""
+
+import numpy as np
+import pandas as pd
+import requests
+from sklearn.preprocessing import MinMaxScaler
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import LSTM, Dense, Dropout
+import xgboost as xgb
+import plotly.graph_objects as go
+from datetime import datetime, timedelta
+import nltk
+from nltk.sentiment.vader import SentimentIntensityAnalyzer
+# [OPT-1] No longer importing transformers – see generate_sentiment_summary below
+import time
+
+# Download VADER lexicon once (tiny file, safe on free tier)
+nltk.download("vader_lexicon", quiet=True)
+
+# =============================================================================
+#                         API Keys (Replace with your own keys)
+# =============================================================================
+ALPHAVANTAGE_API_KEY = "U4SSQJFDQHO1M2ZH"
+FINNHUB_API_KEY     = "cu5gvghr01qqj8u6iau0cu5gvghr01qqj8u6iaug"
+
+# =============================================================================
+#                     STOCK PRICE PREDICTION FUNCTIONS
+# =============================================================================
+
+def fetch_stock_data(symbol, outputsize="full"):
+    url = "https://www.alphavantage.co/query"
+    params = {
+        "function":   "TIME_SERIES_DAILY",
+        "symbol":     symbol,
+        "apikey":     ALPHAVANTAGE_API_KEY,
+        "outputsize": outputsize,
+        "datatype":   "json",
+    }
+    response = requests.get(url, params=params)
+    data = response.json()
+
+    if "Time Series (Daily)" not in data:
+        if "Error Message" in data:
+            raise ValueError(
+                f"Symbol '{symbol}' not found. Please verify the stock symbol.")
+        elif "Note" in data:
+            raise ValueError("API request limit reached. Please try again in a minute.")
+        elif "Information" in data:
+            raise ValueError(f"Your application is actually working perfectly. The prediction failed exactly when it was supposed to, because your API key ({ALPHAVANTAGE_API_KEY}) has genuinely maxed out its 25 free requests for today.")
+        else:
+            raise ValueError(
+                f"Unable to fetch data for symbol '{symbol}'. Please verify the symbol.")
+
+    ts = data["Time Series (Daily)"]
+
+    df = pd.DataFrame.from_dict(ts, orient="index")
+    df.index = pd.to_datetime(df.index)
+    df.sort_index(inplace=True)
+
+    for col in ["1. open", "2. high", "3. low", "4. close", "5. volume"]:
+        if col in df.columns:
+            df[col] = df[col].astype(float)
+
+    df = df.rename(columns={
+        "1. open":   "Open",
+        "2. high":   "High",
+        "3. low":    "Low",
+        "4. close":  "Close",
+        "5. volume": "Volume",
+    })
+
+    latest_date    = df.index[-1]
+    today          = pd.Timestamp.now().normalize()
+    market_closed_days = 0
+    if today.dayofweek >= 5:
+        market_closed_days = today.dayofweek - 4
+    elif today.hour < 16:
+        market_closed_days = 1
+    expected_latest = today - pd.Timedelta(days=market_closed_days)
+    date_diff = (expected_latest - latest_date).days
+    if date_diff > 5:
+        print(f"WARNING: Latest data for {symbol} is from "
+              f"{latest_date.strftime('%Y-%m-%d')} ({date_diff} days old).")
+
+    print(f"\nLatest closing price for {symbol} "
+          f"(as of {latest_date.strftime('%Y-%m-%d')}): ${df['Close'].iloc[-1]:.2f}")
+
+    # Add lightweight technical indicators
+    df = add_technical_indicators(df)
+    return df
+
+
+# [OPT-2] Reduced feature set: 11 → 6  (Close, RSI, SMA5, MACD, Upper_Band, ROC)
+def add_technical_indicators(df):
+    """Add a compact set of technical indicators (6 features vs 11 original)."""
+    try:
+        required_cols = ["Close", "Open", "High", "Low"]
+        for col in required_cols:
+            if col not in df.columns:
+                print(f"Warning: {col} missing – falling back to Close-only.")
+                return df[["Close"]]
+
+        # RSI (14-period)
+        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))
+
+        # Short moving average
+        df["SMA5"] = df["Close"].rolling(5).mean()
+
+        # MACD line only (signal line dropped to save a feature)
+        ema12       = df["Close"].ewm(span=12).mean()
+        ema26       = df["Close"].ewm(span=26).mean()
+        df["MACD"]  = ema12 - ema26
+
+        # Upper Bollinger Band as a proxy for volatility
+        ma20              = df["Close"].rolling(20).mean()
+        df["Upper_Band"]  = ma20 + (df["Close"].rolling(20).std() * 2)
+
+        # Rate-of-change (5-period)
+        df["ROC"] = df["Close"].pct_change(periods=5) * 100
+
+        df = df.dropna()
+
+        # [OPT-2] Only 6 features returned
+        features = ["Close", "RSI", "SMA5", "MACD", "Upper_Band", "ROC"]
+        return df[features]
+
+    except Exception as e:
+        print(f"Error adding technical indicators: {e}")
+        if "Close" in df.columns:
+            return df[["Close"]]
+        return df
+
+
+def preprocess_data(data):
+    """Scale each feature independently; return scaled array + Close scaler."""
+    features    = data.columns
+    scalers     = {}
+    scaled_data = np.zeros((len(data), len(features)))
+
+    for i, feature in enumerate(features):
+        scalers[feature] = MinMaxScaler(feature_range=(0, 1))
+        scaled_data[:, i] = (
+            scalers[feature]
+            .fit_transform(data[feature].values.reshape(-1, 1))
+            .flatten()
+        )
+
+    master_scaler = scalers["Close"]
+    return scaled_data, master_scaler
+
+
+def create_sequences(data, time_step=30):
+    """Create (X, y) sequences for LSTM training."""
+    X, y = [], []
+    for i in range(len(data) - time_step - 1):
+        X.append(data[i : i + time_step, :])   # all features
+        y.append(data[i + time_step, 0])         # Close price only
+    return np.array(X), np.array(y)
+
+
+# [OPT-3] Slimmed LSTM: 2 layers (32 / 16 units) instead of 4 layers (64/64/32/32)
+# [OPT-4] time_step default lowered to 30
+# [OPT-5] epochs 30 → 15, batch_size 64 → 32, EarlyStopping patience 10 → 5
+def train_lstm(X_train, y_train, time_step=30, stop_requested_callback=None):
+    """
+    Train a lightweight LSTM model.
+
+    Architecture change (OPT-3):
+      Original : LSTM(64) → LSTM(64) → Dropout → LSTM(32) → LSTM(32) → Dropout → Dense(16) → Dense(16) → Dense(1)
+      Updated  : LSTM(32) → Dropout(0.2) → LSTM(16) → Dropout(0.2) → Dense(1)
+    Parameter count drops from ~110 k to ~14 k for a 6-feature, 30-step input.
+    """
+    from tensorflow.keras.optimizers import Adam
+    from tensorflow.keras.callbacks import ReduceLROnPlateau, EarlyStopping, Callback
+
+    n_features = X_train.shape[2]
+    X_train    = X_train.reshape(X_train.shape[0], time_step, n_features)
+
+    # [OPT-3] Lightweight architecture
+    model = Sequential([
+        LSTM(32, return_sequences=True,
+             input_shape=(time_step, n_features)),
+        Dropout(0.2),
+        LSTM(16, return_sequences=False),
+        Dropout(0.2),
+        Dense(1),
+    ])
+
+    class StopCallback(Callback):
+        def on_epoch_end(self, epoch, logs=None):
+            if stop_requested_callback and stop_requested_callback():
+                self.model.stop_training = True
+                print("Training stopped early by user request.")
+
+    optimizer = Adam(learning_rate=0.001)
+    model.compile(optimizer=optimizer, loss="mean_squared_error")
+
+    # [OPT-7] Patience 10 → 5 for faster early exit on free-tier CPU
+    reduce_lr     = ReduceLROnPlateau(monitor="val_loss", factor=0.3,
+                                      patience=3, min_lr=0.0001, verbose=0)
+    early_stop    = EarlyStopping(monitor="val_loss", patience=5,
+                                  restore_best_weights=True, verbose=1)
+    callbacks     = [reduce_lr, early_stop]
+    if stop_requested_callback:
+        callbacks.append(StopCallback())
+
+    print(f"Training lightweight LSTM: {X_train.shape[0]} samples, "
+          f"{n_features} features, time_step={time_step}")
+
+    # [OPT-5] epochs 30 → 15, batch_size 64 → 32
+    model.fit(
+        X_train, y_train,
+        epochs=15,
+        batch_size=32,
+        validation_split=0.2,
+        callbacks=callbacks,
+        verbose=1,
+    )
+    return model
+
+
+# [OPT-6] XGBoost: n_estimators 300 → 100, max_depth 6 → 4
+def train_xgboost(X_train, residuals, stop_requested_callback=None):
+    """Train a leaner XGBoost model on LSTM residuals."""
+    if stop_requested_callback and stop_requested_callback():
+        print("XGBoost training cancelled due to stop request.")
+        return None
+
+    # [OPT-6] Reduced complexity for free-tier memory / speed
+    params = {
+        "objective":        "reg:squarederror",
+        "n_estimators":     100,   # was 300
+        "learning_rate":    0.1,
+        "max_depth":        4,     # was 6
+        "subsample":        0.8,
+        "colsample_bytree": 0.8,
+        "min_child_weight": 3,
+        "gamma":            0.1,
+        "reg_alpha":        0.1,
+        "reg_lambda":       1.0,
+        "tree_method":      "hist",
+    }
+
+    if stop_requested_callback:
+        class StopCallbackHandler(xgb.callback.TrainingCallback):
+            def after_iteration(self, model, epoch, evals_log):
+                if stop_requested_callback():
+                    print("XGBoost training stopped by user request.")
+                    return True
+                return False
+
+        xgb_model = xgb.XGBRegressor(**params)
+        xgb_model.set_params(callbacks=[StopCallbackHandler()])
+        xgb_model.fit(X_train, residuals)
+    else:
+        xgb_model = xgb.XGBRegressor(**params)
+        xgb_model.fit(
+            X_train, residuals,
+            eval_metric=["rmse"],
+            early_stopping_rounds=10,   # was 20 [OPT-6]
+            verbose=False,
+            eval_set=[(X_train, residuals)],
+        )
+
+    return xgb_model
+
+
+def predict_stock_price(
+    lstm_model, xgb_model, data, scaler,
+    time_step=30, days_ahead=5, stop_requested_callback=None
+):
+    """Make predictions using both LSTM and XGBoost with price anchoring."""
+    if stop_requested_callback and stop_requested_callback():
+        return None
+
+    n_features     = data.shape[1]
+    temp_input     = data[-time_step:].tolist()
+
+    last_actual_close = scaler.inverse_transform(
+        np.array([[data[-1, 0]]]))[0][0]
+    print(f"Base price: ${last_actual_close:.2f}")
+
+    original_prices = scaler.inverse_transform(data[:, 0].reshape(-1, 1))
+    daily_returns   = np.diff(original_prices, axis=0) / original_prices[:-1]
+    volatility      = np.std(daily_returns)
+
+    # Calibrate model against actual last price
+    lstm_input       = np.array(temp_input[-time_step:]).reshape(1, time_step, n_features)
+    lstm_pred_cal    = lstm_model.predict(lstm_input, verbose=0)[0][0]
+    xgb_input_cal    = np.array(temp_input[-time_step:]).reshape(1, -1)
+    try:
+        combined_cal = lstm_pred_cal + (xgb_model.predict(xgb_input_cal)[0]
+                                        if xgb_model is not None else 0)
+    except Exception:
+        combined_cal = lstm_pred_cal
+
+    model_current   = scaler.inverse_transform(
+        np.array([[combined_cal]]))[0][0]
+    correction_factor = (last_actual_close / model_current
+                         if model_current > 0 else 1.0)
+    print(f"Calibration: model=${model_current:.2f}, "
+          f"actual=${last_actual_close:.2f}, factor={correction_factor:.4f}")
+
+    predictions    = []
+    prev_day_pred  = combined_cal
+
+    for day in range(days_ahead):
+        if stop_requested_callback and stop_requested_callback():
+            print(f"Prediction stopped at day {day}/{days_ahead}")
+            break
+
+        lstm_input = np.array(temp_input[-time_step:]).reshape(1, time_step, n_features)
+        lstm_pred  = lstm_model.predict(lstm_input, verbose=0)[0][0]
+        xgb_input  = np.array(temp_input[-time_step:]).reshape(1, -1)
+
+        try:
+            combined_pred = (lstm_pred + xgb_model.predict(xgb_input)[0]
+                             if xgb_model is not None else lstm_pred)
+        except Exception as e:
+            print(f"XGBoost predict error: {e}")
+            combined_pred = lstm_pred
+
+        prev_unscaled    = scaler.inverse_transform(
+            np.array([[prev_day_pred]]))[0][0]
+        current_unscaled = scaler.inverse_transform(
+            np.array([[combined_pred]]))[0][0]
+        price_change     = current_unscaled - prev_unscaled
+        trend_direction  = 1 if price_change >= 0 else -1
+
+        day_volatility      = volatility * (1 + day * 0.1)
+        adjusted_volatility = min(day_volatility, 0.015)
+        random_factor       = np.random.normal(0, adjusted_volatility)
+
+        if trend_direction > 0:
+            flux_factor = (abs(random_factor) * trend_direction * 0.15
+                           if np.random.random() < 0.7
+                           else -abs(random_factor) * trend_direction * 0.3)
+        else:
+            flux_factor = (abs(random_factor) * trend_direction * 0.25
+                           if np.random.random() < 0.8
+                           else -abs(random_factor) * trend_direction * 0.1)
+
+        flux_amount      = prev_unscaled * flux_factor
+        adjusted_unscaled = current_unscaled + flux_amount
+        adjusted_pred     = scaler.transform(
+            np.array([[adjusted_unscaled]]))[0][0]
+
+        next_row    = temp_input[-1].copy()
+        next_row[0] = adjusted_pred
+        prev_day_pred = adjusted_pred
+
+        predictions.append(adjusted_pred)
+        temp_input.append(next_row)
+
+    if not predictions:
+        return None
+
+    final_predictions    = scaler.inverse_transform(
+        np.array(predictions).reshape(-1, 1))
+    corrected_predictions = final_predictions * correction_factor
+
+    print("\nPredictions (original → corrected):")
+    for i in range(len(final_predictions)):
+        print(f"  Day {i+1}: ${final_predictions[i][0]:.2f} "
+              f"→ ${corrected_predictions[i][0]:.2f}")
+
+    return corrected_predictions
+
+
+def plot_prices(data, predictions, symbol, days_ahead):
+    """Plot actual + predicted prices (used in standalone main())."""
+    fig = go.Figure()
+    three_months_ago = data.index[-1] - pd.DateOffset(months=3)
+    actual_data = data.loc[three_months_ago:]
+    close_prices = (actual_data["Close"]
+                    if isinstance(actual_data, pd.DataFrame) and "Close" in actual_data.columns
+                    else actual_data.iloc[:, 0])
+
+    future_dates = []
+    last_date = data.index[-1]
+    for i in range(1, days_ahead + 1):
+        next_date = last_date + timedelta(days=i)
+        while next_date.weekday() > 4:
+            next_date += timedelta(days=1)
+        future_dates.append(next_date)
+    future_dates    = list(dict.fromkeys(future_dates))
+    prediction_data = predictions[: len(future_dates)].flatten()
+
+    fig.add_trace(go.Scatter(
+        x=future_dates, y=prediction_data,
+        mode="lines+markers", name="Predicted Price",
+        line=dict(color="orange", width=3)))
+    fig.add_trace(go.Scatter(
+        x=close_prices.index, y=close_prices.values,
+        mode="lines", name="Actual Price",
+        line=dict(color="blue", width=2)))
+    fig.add_trace(go.Scatter(
+        x=[close_prices.index[-1]], y=[close_prices.values[-1]],
+        mode="markers", name="Latest Price",
+        marker=dict(color="green", size=10, symbol="circle")))
+
+    fig.update_layout(
+        title=f"Stock Price Prediction for {symbol}",
+        xaxis_title="Date", yaxis_title="Price (USD)",
+        template="plotly_white", hovermode="x unified")
+    fig.show()
+
+
+# =============================================================================
+#                   NEWS SENTIMENT ANALYSIS FUNCTIONS
+# =============================================================================
+
+def fetch_finnhub_news(company_symbol):
+    end_date      = datetime.now()
+    start_date    = end_date - timedelta(days=28)
+    url = (f"https://finnhub.io/api/v1/company-news"
+           f"?symbol={company_symbol}"
+           f"&from={start_date.strftime('%Y-%m-%d')}"
+           f"&to={end_date.strftime('%Y-%m-%d')}"
+           f"&token={FINNHUB_API_KEY}")
+    try:
+        response = requests.get(url)
+        if response.status_code == 200:
+            articles  = response.json()
+            headlines = [a["headline"] for a in articles if "headline" in a]
+            return headlines
+        else:
+            print(f"Error fetching news: {response.status_code}")
+            return []
+    except Exception as e:
+        print(f"Error parsing news response: {e}")
+        return []
+
+
+def analyze_sentiment(headlines):
+    try:
+        sid              = SentimentIntensityAnalyzer()
+        sentiment_results = []
+        sentiment_totals  = {"positive": 0, "negative": 0, "neutral": 0}
+
+        for headline in headlines:
+            if not headline or not isinstance(headline, str):
+                continue
+            sentiment = sid.polarity_scores(headline)
+            sentiment_results.append({"headline": headline, "sentiment": sentiment})
+            if sentiment["compound"] > 0.05:
+                sentiment_totals["positive"] += 1
+            elif sentiment["compound"] < -0.05:
+                sentiment_totals["negative"] += 1
+            else:
+                sentiment_totals["neutral"] += 1
+
+        return sentiment_results, sentiment_totals
+    except Exception as e:
+        print(f"Error in sentiment analysis: {e}")
+        return [], {"positive": 0, "negative": 0, "neutral": 0}
+
+
+def plot_sentiment_pie(sentiment_totals, company_symbol):
+    fig = go.Figure(data=[go.Pie(
+        labels=["Positive", "Negative", "Neutral"],
+        values=[sentiment_totals["positive"],
+                sentiment_totals["negative"],
+                sentiment_totals["neutral"]],
+        marker=dict(colors=["#2ecc71", "#e74c3c", "#95a5a6"],
+                    line=dict(color="white", width=0)),
+        textinfo="percent+label", textfont_size=20)])
+    fig.update_layout(
+        title=f"Sentiment Distribution for {company_symbol} (Last 28 Days)",
+        showlegend=True)
+    fig.show()
+
+
+# =============================================================================
+#          AI SUMMARY FUNCTIONS  [OPT-1] Transformers removed
+# =============================================================================
+
+def _extractive_summary(headlines, n=3):
+    """
+    Lightweight extractive summariser – replaces the BART transformer pipeline.
+    [OPT-1] Picks the top-n headlines by absolute VADER compound score so the
+    most opinionated sentences surface first.  No heavy model download needed.
+    """
+    if not headlines:
+        return ""
+    try:
+        sid    = SentimentIntensityAnalyzer()
+        scored = [(h, abs(sid.polarity_scores(h)["compound"]))
+                  for h in headlines if h and isinstance(h, str)]
+        scored.sort(key=lambda x: x[1], reverse=True)
+        top    = [h for h, _ in scored[:n]]
+        return " | ".join(top)
+    except Exception as e:
+        print(f"Extractive summary error: {e}")
+        return headlines[0] if headlines else ""
+
+
+def generate_sentiment_summary(sentiment_totals, headlines, company_symbol):
+    """
+    Generate a human-readable sentiment summary.
+    [OPT-1] Uses simple NLTK-based extractive summarisation instead of a
+    Transformers pipeline (removes ~1.2 GB BART model download).
+    """
+    try:
+        total   = max(1, sum(sentiment_totals.values()))
+        pos_pct = sentiment_totals["positive"] / total * 100
+        neg_pct = sentiment_totals["negative"] / total * 100
+
+        summary = (
+            f"Over the past 28 days, {len(headlines)} news articles about "
+            f"{company_symbol} were analysed. "
+            f"{sentiment_totals['positive']} positive ({pos_pct:.0f}%), "
+            f"{sentiment_totals['negative']} negative ({neg_pct:.0f}%), "
+            f"and {sentiment_totals['neutral']} neutral articles found."
+        )
+
+        if headlines:
+            key_headlines = _extractive_summary(headlines, n=2)
+            if key_headlines:
+                summary += f" Key headlines: {key_headlines}"
+
+        return summary
+    except Exception as e:
+        print(f"Error in generate_sentiment_summary: {e}")
+        return f"Unable to generate sentiment summary for {company_symbol}."
+
+
+def generate_prediction_summary(pred_df, company_symbol):
+    first_price = pred_df["Predicted Price"].iloc[0]
+    last_price  = pred_df["Predicted Price"].iloc[-1]
+    return (
+        f"The predicted stock prices for {company_symbol} range from "
+        f"${first_price:.2f} to ${last_price:.2f} over the forecast period."
+    )
+
+
+def display_price_table(data, predictions, symbol, days_ahead):
+    """Print prediction results as a table (used in standalone main())."""
+    if isinstance(data, pd.DataFrame) and "Close" in data.columns:
+        last_price = data["Close"].iloc[-1]
+        last_date  = data.index[-1]
+    else:
+        last_price = data.iloc[-1, 0]
+        last_date  = data.index[-1]
+
+    future_dates = []
+    for i in range(1, days_ahead + 1):
+        next_date = last_date + timedelta(days=i)
+        while next_date.weekday() > 4:
+            next_date += timedelta(days=1)
+        future_dates.append(next_date)
+    future_dates    = list(dict.fromkeys(future_dates))
+    prediction_data = predictions[: len(future_dates)].flatten()
+
+    last_price_row = pd.DataFrame({
+        "Date": [last_date.strftime("%Y-%m-%d")],
+        "Price": [f"${last_price:.2f}"],
+        "Change": ["0.00%"],
+        "Note": ["Actual last closing price"],
+    })
+    pred_rows = []
+    for i, (date, price) in enumerate(zip(future_dates, prediction_data)):
+        change_pct = ((price - last_price) / last_price) * 100
+        pred_rows.append({
+            "Date": date.strftime("%Y-%m-%d"),
+            "Price": f"${price:.2f}",
+            "Change": f"{change_pct:.2f}%",
+            "Note": f"Day {i+1} prediction",
+        })
+
+    combined_df = pd.concat([last_price_row, pd.DataFrame(pred_rows)],
+                            ignore_index=True)
+    print(f"\n{symbol} Stock Price Prediction Table:")
+    print("=" * 80)
+    print(combined_df.to_string(index=False))
+    print("=" * 80)
+
+    return pd.DataFrame({
+        "Date": [d.strftime("%Y-%m-%d") for d in future_dates],
+        "Predicted Price": prediction_data,
+    })
+
+
+# =============================================================================
+#                          STANDALONE MAIN
+# =============================================================================
+
+def main():
+    symbol = input("Enter the stock symbol (e.g., AAPL): ").upper()
+    try:
+        days_ahead = int(input("Number of future days to predict (e.g., 5): "))
+    except ValueError:
+        print("Invalid input. Please enter an integer.")
+        return
+
+    print(f"\nFetching historical data for {symbol}...")
+    data = fetch_stock_data(symbol, outputsize="full")
+    if data is None or len(data) < 50:
+        print(f"Not enough data points for {symbol}.")
+        return
+
+    print("Preprocessing data...")
+    scaled_data, scaler = preprocess_data(data)
+
+    # [OPT-4] time_step 60 → 30 in standalone mode too
+    time_step = 30
+    X, y = create_sequences(scaled_data, time_step)
+    if len(X) == 0:
+        print("Could not create sequences.")
+        return
+
+    train_size       = int(len(X) * 0.8)
+    X_train, y_train = X[:train_size], y[:train_size]
+
+    print("Training LSTM model...")
+    lstm_model = train_lstm(X_train, y_train, time_step)
+
+    lstm_train_preds = lstm_model.predict(X_train, verbose=0).flatten()
+    residuals        = y_train - lstm_train_preds
+
+    print("Training XGBoost model...")
+    xgb_model = train_xgboost(X_train.reshape(X_train.shape[0], -1), residuals)
+
+    print(f"Predicting {days_ahead} days ahead...")
+    predictions = predict_stock_price(
+        lstm_model, xgb_model, scaled_data, scaler, time_step, days_ahead)
+
+    display_price_table(data, predictions, symbol, days_ahead)
+
+    future_dates = []
+    last_date    = data.index[-1]
+    for i in range(1, days_ahead + 1):
+        next_date = last_date + timedelta(days=i)
+        while next_date.weekday() > 4:
+            next_date += timedelta(days=1)
+        future_dates.append(next_date)
+    future_dates = list(dict.fromkeys(future_dates))
+
+    pred_df = pd.DataFrame({
+        "Date": [d.strftime("%Y-%m-%d") for d in future_dates[: len(predictions)]],
+        "Predicted Price": predictions.flatten()[: len(future_dates)],
+    })
+    print("\nPrediction summary:")
+    print(generate_prediction_summary(pred_df, symbol))
+
+    print("\nFetching news for sentiment analysis...")
+    headlines = fetch_finnhub_news(symbol)
+    if headlines:
+        sentiment_results, sentiment_totals = analyze_sentiment(headlines)
+        plot_sentiment_pie(sentiment_totals, symbol)
+        print(generate_sentiment_summary(sentiment_totals, headlines, symbol))
+    else:
+        print("No headlines found.")
+
+
+if __name__ == "__main__":
+    main()