Initial backend deployment

.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.pyc
+.env
+venv/
+*.h5
+*.pkl

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

app/config.py

@@ -0,0 +1,7 @@
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+APP_NAME = os.getenv("APP_NAME", "AlphaSignal")
+DEBUG = os.getenv("DEBUG", "True") == "True"

app/main.py

@@ -0,0 +1,42 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from app.config import APP_NAME
+from app.routers import stock         
+from app.routers import prediction
+from app.routers import sentiment
+
+app = FastAPI(
+    title=APP_NAME,
+    description="AI-powered Stock Prediction & Decision Support System",
+    version="1.0.0"
+)
+
+# Allow React frontend to talk to this backend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:5173"],  # React dev server
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Register routers
+app.include_router(stock.router)       # ← ADD THIS
+
+@app.get("/")
+def root():
+    return {
+        "app": APP_NAME,
+        "status": "AlphaSignal is running 🚀",
+        "version": "1.0.0"
+    }
+
+@app.get("/health")
+def health():
+    return {"status": "healthy"}
+
+app.include_router(prediction.router)
+app.include_router(sentiment.router)
+
+from app.routers import backtest
+app.include_router(backtest.router)

app/ml/backtest.py

@@ -0,0 +1,75 @@
+import numpy as np
+import pickle
+from tensorflow.keras.models import load_model
+
+from .train import (
+    get_cache_paths, is_cached, train_and_cache,
+    download_and_engineer, SEQ_LEN, N_FEATURES
+)
+
+
+def run_backtest(ticker: str):
+    if is_cached(ticker):
+        mp, sp, fp = get_cache_paths(ticker)
+        model = load_model(mp)
+        with open(sp, "rb") as f:
+            close_scaler = pickle.load(f)
+        with open(fp, "rb") as f:
+            feat_scaler = pickle.load(f)
+        df = download_and_engineer(ticker)
+    else:
+        model, close_scaler, feat_scaler, df = train_and_cache(ticker)
+
+    feat_cols       = ["Close", "Volume", "RSI", "MACD", "MACD_Signal"]
+    scaled_features = feat_scaler.transform(df[feat_cols].values)
+    actual_prices   = df["Close"].values.flatten()
+    actual_dates    = df.index
+
+    results = []
+    for i in range(30, 0, -1):
+        end_idx = len(scaled_features) - i
+        if end_idx < SEQ_LEN:
+            continue
+
+        inp         = scaled_features[end_idx - SEQ_LEN:end_idx].reshape(1, SEQ_LEN, N_FEATURES)
+        pred_scaled = model.predict(inp, verbose=0)[0][0]
+        pred_price  = close_scaler.inverse_transform([[pred_scaled]])[0][0]
+
+        results.append({
+            "date":      actual_dates[end_idx].strftime("%Y-%m-%d"),
+            "actual":    round(float(actual_prices[end_idx]), 2),
+            "predicted": round(float(pred_price), 2),
+        })
+
+    if not results:
+        raise ValueError("Not enough data for backtest")
+
+    actuals = np.array([r["actual"]    for r in results])
+    preds   = np.array([r["predicted"] for r in results])
+
+    rmse = round(float(np.sqrt(np.mean((actuals - preds) ** 2))), 2)
+    mae  = round(float(np.mean(np.abs(actuals - preds))), 2)
+    mape = round(float(np.mean(np.abs((actuals - preds) / actuals)) * 100), 2)
+
+    correct_dir = sum(
+        1 for i in range(1, len(results))
+        if (results[i]["actual"] - results[i-1]["actual"]) *
+           (results[i]["predicted"] - results[i-1]["predicted"]) > 0
+    )
+    directional_accuracy = round(correct_dir / (len(results) - 1) * 100, 1) if len(results) > 1 else 0
+
+    verdict = (
+        "good"     if directional_accuracy >= 60 and mape <= 2 else
+        "moderate" if directional_accuracy >= 50 and mape <= 5 else
+        "poor"
+    )
+
+    return {
+        "ticker":               ticker,
+        "rmse":                 rmse,
+        "mae":                  mae,
+        "mape":                 mape,
+        "directional_accuracy": directional_accuracy,
+        "verdict":              verdict,
+        "data_points":          results,
+    }

app/ml/predict.py

@@ -0,0 +1,62 @@
+import numpy as np
+import pandas as pd
+import pickle
+from tensorflow.keras.models import load_model
+
+from .train import (
+    get_cache_paths, is_cached, train_and_cache,
+    download_and_engineer, SEQ_LEN, N_FEATURES
+)
+
+
+def _load_artifacts(ticker: str):
+    if is_cached(ticker):
+        mp, sp, fp = get_cache_paths(ticker)
+        model = load_model(mp)
+        with open(sp, "rb") as f:
+            close_scaler = pickle.load(f)
+        with open(fp, "rb") as f:
+            feat_scaler = pickle.load(f)
+        df = download_and_engineer(ticker)
+    else:
+        model, close_scaler, feat_scaler, df = train_and_cache(ticker)
+    return model, close_scaler, feat_scaler, df
+
+
+def get_predictions(ticker: str, sentiment_score: float = 0.0):
+    """
+    Predict 7 business days ahead.
+    sentiment_score: float [-1, 1] from FinBERT (0.0 = ignore)
+    """
+    model, close_scaler, feat_scaler, df = _load_artifacts(ticker)
+
+    feat_cols       = ["Close", "Volume", "RSI", "MACD", "MACD_Signal"]
+    scaled_features = feat_scaler.transform(df[feat_cols].values)
+
+    current_window  = scaled_features[-SEQ_LEN:].copy()
+    last_aux        = scaled_features[-1, 1:].copy()   # Volume, RSI, MACD, Signal
+    raw_preds       = []
+
+    for _ in range(7):
+        inp  = current_window[-SEQ_LEN:].reshape(1, SEQ_LEN, N_FEATURES)
+        pred = model.predict(inp, verbose=0)[0][0]
+        raw_preds.append(pred)
+        current_window = np.vstack([current_window, np.concatenate([[pred], last_aux])])
+
+    predicted_prices = close_scaler.inverse_transform(
+        np.array(raw_preds).reshape(-1, 1)
+    ).flatten()
+
+    # Gentle sentiment nudge (max ±1.5%, decays over 7 days)
+    if sentiment_score != 0.0:
+        for i in range(len(predicted_prices)):
+            decay = 1 - (i / len(predicted_prices))
+            predicted_prices[i] *= (1 + sentiment_score * 0.015 * decay)
+
+    last_date    = df.index[-1]
+    future_dates = pd.bdate_range(start=last_date + pd.Timedelta(days=1), periods=7)
+
+    return [
+        {"date": d.strftime("%Y-%m-%d"), "predicted_price": round(float(p), 2)}
+        for d, p in zip(future_dates, predicted_prices)
+    ]

app/ml/train.py

@@ -0,0 +1,119 @@
+import numpy as np
+import pandas as pd
+import yfinance as yf
+import pickle
+import os
+from datetime import date
+from sklearn.preprocessing import MinMaxScaler
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import LSTM, Dense, Dropout, BatchNormalization
+from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau
+from tensorflow.keras.optimizers import Adam
+
+# ── Constants ────────────────────────────────────────────────────────────────
+SEQ_LEN    = 120        # 2x original (60), still lightweight
+N_FEATURES = 5          # Close, Volume, RSI, MACD, MACD_Signal
+DATA_PERIOD = "3y"      # good balance of history vs. download/training time
+CACHE_DIR  = os.path.join(os.path.dirname(__file__), "..", "cache", "models")
+
+
+# ── Cache helpers (daily key so model auto-refreshes each day) ───────────────
+def get_cache_paths(ticker):
+    safe  = ticker.replace(".", "_")
+    today = date.today().strftime("%Y%m%d")
+    base  = os.path.join(CACHE_DIR, f"{safe}_{today}")
+    return base + "_model.keras", base + "_scaler.pkl", base + "_feat_scaler.pkl"
+
+def is_cached(ticker):
+    mp, sp, fp = get_cache_paths(ticker)
+    return os.path.exists(mp) and os.path.exists(sp) and os.path.exists(fp)
+
+
+# ── Feature engineering ──────────────────────────────────────────────────────
+def add_features(df: pd.DataFrame) -> pd.DataFrame:
+    close = df["Close"]
+
+    delta = close.diff()
+    gain  = delta.clip(lower=0).rolling(14).mean()
+    loss  = (-delta.clip(upper=0)).rolling(14).mean()
+    df["RSI"] = 100 - (100 / (1 + gain / (loss + 1e-9)))
+
+    ema12 = close.ewm(span=12, adjust=False).mean()
+    ema26 = close.ewm(span=26, adjust=False).mean()
+    df["MACD"]        = ema12 - ema26
+    df["MACD_Signal"] = df["MACD"].ewm(span=9, adjust=False).mean()
+
+    return df.dropna()
+
+def download_and_engineer(ticker: str) -> pd.DataFrame:
+    raw = yf.download(ticker, period=DATA_PERIOD, interval="1d", auto_adjust=True)
+    df  = raw[["Close", "Volume"]].copy()
+    return add_features(df)
+
+
+# ── Sequence builder ─────────────────────────────────────────────────────────
+def build_sequences(scaled_features, scaled_close):
+    X, y = [], []
+    for i in range(SEQ_LEN, len(scaled_features)):
+        X.append(scaled_features[i - SEQ_LEN:i])
+        y.append(scaled_close[i, 0])
+    return np.array(X), np.array(y)
+
+
+# ── Lightweight 2-layer model (M4 Air friendly) ──────────────────────────────
+def build_model():
+    model = Sequential([
+        LSTM(128, return_sequences=True, input_shape=(SEQ_LEN, N_FEATURES)),
+        BatchNormalization(),
+        Dropout(0.2),
+
+        LSTM(64, return_sequences=False),
+        BatchNormalization(),
+        Dropout(0.2),
+
+        Dense(32, activation="relu"),
+        Dense(1)
+    ])
+    model.compile(optimizer=Adam(learning_rate=1e-3), loss="huber")
+    return model
+
+
+# ── Train + cache ────────────────────────────────────────────────────────────
+def train_and_cache(ticker: str):
+    os.makedirs(CACHE_DIR, exist_ok=True)
+
+    df = download_and_engineer(ticker)
+    if len(df) < SEQ_LEN + 50:
+        raise ValueError(f"Not enough data for {ticker}")
+
+    feat_cols    = ["Close", "Volume", "RSI", "MACD", "MACD_Signal"]
+    feat_scaler  = MinMaxScaler()
+    close_scaler = MinMaxScaler()
+
+    scaled_features = feat_scaler.fit_transform(df[feat_cols].values)
+    scaled_close    = close_scaler.fit_transform(df[["Close"]].values)
+
+    X, y  = build_sequences(scaled_features, scaled_close)
+    split = int(len(X) * 0.8)
+
+    model = build_model()
+    model.fit(
+        X[:split], y[:split],
+        epochs=50,                          # reduced from 100
+        batch_size=64,                      # larger batch = fewer steps = faster
+        validation_data=(X[split:], y[split:]),
+        callbacks=[
+            EarlyStopping(monitor="val_loss", patience=8, restore_best_weights=True),
+            ReduceLROnPlateau(monitor="val_loss", factor=0.5, patience=4, min_lr=1e-5),
+        ],
+        verbose=0,
+    )
+
+    model_path, scaler_path, feat_scaler_path = get_cache_paths(ticker)
+    model.save(model_path)
+    with open(scaler_path, "wb") as f:
+        pickle.dump(close_scaler, f)
+    with open(feat_scaler_path, "wb") as f:
+        pickle.dump(feat_scaler, f)
+
+    return model, close_scaler, feat_scaler, df

app/routers/backtest.py

@@ -0,0 +1,16 @@
+from fastapi import APIRouter, HTTPException
+from app.ml.backtest import run_backtest
+import traceback
+
+router = APIRouter()
+
+@router.get("/api/stock/{ticker}/backtest")
+def backtest_stock(ticker: str):
+    try:
+        result = run_backtest(ticker)
+        return result
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        print("BACKTEST ERROR:", traceback.format_exc())
+        raise HTTPException(status_code=500, detail=f"Backtest failed: {str(e)}")

app/routers/prediction.py

@@ -0,0 +1,18 @@
+from fastapi import APIRouter, HTTPException
+from app.ml.predict import get_predictions
+
+router = APIRouter()
+
+@router.get("/api/stock/{ticker}/predict")
+def predict_stock(ticker: str):
+    try:
+        predictions = get_predictions(ticker)
+        return {
+            "ticker": ticker,
+            "predictions": predictions,
+            "days": 7
+        }
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Prediction failed: {str(e)}")

app/routers/sentiment.py

@@ -0,0 +1,12 @@
+from fastapi import APIRouter, HTTPException
+from app.services.sentiment import get_sentiment_score
+
+router = APIRouter()
+
+@router.get("/api/stock/{ticker}/sentiment")
+def get_sentiment(ticker: str):
+    try:
+        result = get_sentiment_score(ticker)
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Sentiment analysis failed: {str(e)}")

app/routers/stock.py

@@ -0,0 +1,64 @@
+from fastapi import APIRouter, HTTPException
+from app.services.data_fetcher import get_stock_history, get_stock_info
+from app.services.indicators import get_all_indicators
+from app.services.decision_engine import get_decision
+
+router = APIRouter(
+    prefix="/api/stock",
+    tags=["Stock Data"]
+)
+
+@router.get("/{ticker}/history")
+def stock_history(ticker: str, period: str = "1y"):
+    data = get_stock_history(ticker.upper(), period)
+    if data is None:
+        raise HTTPException(status_code=404, detail=f"Stock '{ticker}' not found or no data available")
+    return {
+        "ticker": ticker.upper(),
+        "period": period,
+        "count": len(data),
+        "data": data
+    }
+
+
+@router.get("/{ticker}/info")
+def stock_info(ticker: str):
+    data = get_stock_info(ticker.upper())
+    if data is None:
+        raise HTTPException(status_code=404, detail=f"Stock '{ticker}' not found")
+    return data
+
+
+@router.get("/{ticker}/indicators")
+def stock_indicators(ticker: str, period: str = "1y"):
+    data = get_all_indicators(ticker.upper(), period)
+    if data is None:
+        raise HTTPException(status_code=404, detail=f"Could not calculate indicators for '{ticker}'")
+    return data
+
+
+@router.get("/{ticker}/decision")
+def stock_decision(ticker: str):
+    data = get_decision(ticker.upper())
+    if data is None:
+        raise HTTPException(status_code=404, detail=f"Could not generate decision for '{ticker}'")
+    return data
+
+
+@router.get("/{ticker}/summary")
+def stock_summary(ticker: str, period: str = "1y"):
+    ticker = ticker.upper()
+    decision_data = get_decision(ticker, period)
+    if decision_data is None:
+        raise HTTPException(status_code=404, detail=f"Could not generate summary for '{ticker}'")
+    info_data = get_stock_info(ticker)
+    return {
+        "ticker": ticker,
+        "info": info_data,
+        "decision": decision_data["decision"],
+        "confidence": decision_data["confidence"],
+        "score": decision_data["score"],
+        "risk": decision_data["risk"],
+        "reasons": decision_data["reasons"],
+        "indicators": decision_data["latest"]
+    }

app/services/data_fetcher.py

@@ -0,0 +1,72 @@
+import yfinance as yf
+import pandas as pd
+
+def get_stock_history(ticker: str, period: str = "1y", interval: str = None):
+    try:
+        stock = yf.Ticker(ticker)
+
+        if interval is None:
+            if period == "1d":
+                interval = "5m"
+            elif period == "5d":
+                interval = "1h"
+            elif period == "1mo":
+                interval = "1h"
+            else:
+                interval = "1d"
+
+        if period == "1d":
+            df = stock.history(period="1d", interval="5m")
+        else:
+            df = stock.history(period=period, interval=interval)
+
+        if df.empty:
+            return None
+
+        df = df.reset_index()
+
+        date_col = "Datetime" if "Datetime" in df.columns else "Date"
+        df = df.rename(columns={date_col: "Date"})
+
+        df["Date"] = pd.to_datetime(df["Date"])
+
+        if hasattr(df["Date"].dt, "tz") and df["Date"].dt.tz is not None:
+            df["Date"] = df["Date"].dt.tz_localize(None)
+
+        if period == "1d":
+            df["Date"] = df["Date"].dt.strftime("%H:%M")
+        elif period in ["5d", "1mo"]:
+            df["Date"] = df["Date"].dt.strftime("%d %b %H:%M")
+        else:
+            df["Date"] = df["Date"].dt.strftime("%Y-%m-%d")
+
+        df = df[["Date", "Open", "High", "Low", "Close", "Volume"]]
+        df = df.round(2)
+
+        return df.to_dict(orient="records")
+
+    except Exception as e:
+        print(f"Error fetching history for {ticker}: {e}")
+        return None
+
+
+def get_stock_info(ticker: str):
+    try:
+        stock = yf.Ticker(ticker)
+        info = stock.info
+
+        return {
+            "ticker": ticker,
+            "name": info.get("longName", ticker),
+            "sector": info.get("sector", "N/A"),
+            "current_price": info.get("currentPrice", info.get("regularMarketPrice", 0)),
+            "currency": info.get("currency", "USD"),
+            "market_cap": info.get("marketCap", 0),
+            "pe_ratio": info.get("trailingPE", 0),
+            "52_week_high": info.get("fiftyTwoWeekHigh", 0),
+            "52_week_low": info.get("fiftyTwoWeekLow", 0),
+        }
+
+    except Exception as e:
+        print(f"Error fetching info for {ticker}: {e}")
+        return None

app/services/decision_engine.py

@@ -0,0 +1,96 @@
+from app.services.indicators import get_all_indicators
+
+def get_decision(ticker: str, period: str = "1y"):
+    data = get_all_indicators(ticker, period)
+
+    if data is None:
+        return None
+
+    latest = data["latest"]
+    score = 0
+    reasons = []
+
+    rsi = latest["rsi"]
+    macd_line = latest["macd_line"]
+    signal_line = latest["signal_line"]
+    histogram = latest["histogram"]
+    close = latest["close"]
+    upper_band = latest["upper_band"]
+    lower_band = latest["lower_band"]
+    middle_band = latest["middle_band"]
+    sma20 = latest["sma20"]
+    sma50 = latest["sma50"]
+
+    if rsi is not None:
+        if rsi < 30:
+            score += 2
+            reasons.append(f"RSI is {rsi} — stock is oversold, potential BUY opportunity")
+        elif rsi > 70:
+            score -= 2
+            reasons.append(f"RSI is {rsi} — stock is overbought, potential SELL signal")
+        else:
+            reasons.append(f"RSI is {rsi} — stock is in neutral zone")
+
+    if histogram is not None and macd_line is not None and signal_line is not None:
+        if histogram > 0 and macd_line > signal_line:
+            score += 2
+            reasons.append(f"MACD is bullish — momentum is increasing, BUY signal")
+        elif histogram < 0 and macd_line < signal_line:
+            score -= 2
+            reasons.append(f"MACD is bearish — momentum is decreasing, SELL signal")
+        else:
+            reasons.append(f"MACD is neutral — no clear momentum signal")
+
+    if close is not None and sma20 is not None and sma50 is not None:
+        if close > sma20 and close > sma50:
+            score += 2
+            reasons.append(f"Price is above SMA20 and SMA50 — strong uptrend, bullish signal")
+        elif close < sma20 and close < sma50:
+            score -= 2
+            reasons.append(f"Price is below SMA20 and SMA50 — strong downtrend, bearish signal")
+        else:
+            reasons.append(f"Price is between SMA20 and SMA50 — mixed trend signals")
+
+    if close is not None and upper_band is not None and lower_band is not None and middle_band is not None:
+        band_range = upper_band - lower_band
+        if band_range > 0:
+            position = (close - lower_band) / band_range
+            if position < 0.2:
+                score += 1
+                reasons.append(f"Price is near lower Bollinger Band — possible reversal upward")
+            elif position > 0.8:
+                score -= 1
+                reasons.append(f"Price is near upper Bollinger Band — possible reversal downward")
+            else:
+                reasons.append(f"Price is within Bollinger Bands — normal volatility range")
+
+    if upper_band is not None and lower_band is not None and middle_band is not None:
+        band_width = (upper_band - lower_band) / middle_band * 100
+        if band_width > 10:
+            risk = "HIGH"
+        elif band_width > 5:
+            risk = "MEDIUM"
+        else:
+            risk = "LOW"
+    else:
+        risk = "MEDIUM"
+
+    if score >= 4:
+        decision = "BUY"
+        confidence = min(50 + (score * 8), 95)
+    elif score <= -4:
+        decision = "SELL"
+        confidence = min(50 + (abs(score) * 8), 95)
+    else:
+        decision = "HOLD"
+        confidence = 50 + (abs(score) * 5)
+
+    return {
+        "ticker": ticker,
+        "decision": decision,
+        "confidence": round(confidence, 1),
+        "score": score,
+        "risk": risk,
+        "reasons": reasons,
+        "latest": latest
+    }

app/services/indicators.py

@@ -0,0 +1,148 @@
+import pandas as pd
+import numpy as np
+import yfinance as yf
+import math
+
+def clean_nan(value):
+    """Replace NaN/Inf with None so JSON doesn't crash"""
+    if value is None:
+        return None
+    if isinstance(value, float) and (math.isnan(value) or math.isinf(value)):
+        return None
+    return value
+
+def clean_list(lst):
+    """Clean an entire list of values"""
+    return [clean_nan(x) for x in lst]
+
+def calculate_rsi(closes: pd.Series, period: int = 14) -> pd.Series:
+    """
+    RSI — Relative Strength Index
+    - Above 70 = Overbought (possible SELL signal)
+    - Below 30 = Oversold (possible BUY signal)
+    - Between 30-70 = Neutral
+    """
+    delta = closes.diff()
+    gain = delta.where(delta > 0, 0)
+    loss = -delta.where(delta < 0, 0)
+    avg_gain = gain.ewm(com=period - 1, min_periods=period).mean()
+    avg_loss = loss.ewm(com=period - 1, min_periods=period).mean()
+    rs = avg_gain / avg_loss
+    rsi = 100 - (100 / (1 + rs))
+    return rsi.round(2)
+
+
+def calculate_macd(closes: pd.Series):
+    """
+    MACD — Moving Average Convergence Divergence
+    - MACD crossing above signal = BUY signal
+    - MACD crossing below signal = SELL signal
+    """
+    ema12 = closes.ewm(span=12, adjust=False).mean()
+    ema26 = closes.ewm(span=26, adjust=False).mean()
+    macd_line = ema12 - ema26
+    signal_line = macd_line.ewm(span=9, adjust=False).mean()
+    histogram = macd_line - signal_line
+    return (
+        macd_line.round(2),
+        signal_line.round(2),
+        histogram.round(2)
+    )
+
+
+def calculate_bollinger_bands(closes: pd.Series, period: int = 20):
+    """
+    Bollinger Bands
+    - Price above upper band = Overbought
+    - Price below lower band = Oversold
+    """
+    sma = closes.rolling(window=period).mean()
+    std = closes.rolling(window=period).std()
+    upper_band = sma + (2 * std)
+    lower_band = sma - (2 * std)
+    return (
+        upper_band.round(2),
+        sma.round(2),
+        lower_band.round(2)
+    )
+
+
+def calculate_sma(closes: pd.Series, period: int) -> pd.Series:
+    """
+    Simple Moving Average
+    - SMA20 = short term trend
+    - SMA50 = long term trend
+    """
+    return closes.rolling(window=period).mean().round(2)
+
+
+def get_all_indicators(ticker: str, period: str = "1y"):
+    """
+    Master function — fetches stock data and calculates
+    ALL indicators in one go.
+    """
+    try:
+        stock = yf.Ticker(ticker)
+        df = stock.history(period=period)
+
+        if df.empty:
+            return None
+
+        closes = df["Close"]
+
+        # Calculate all indicators
+        rsi = calculate_rsi(closes)
+        macd_line, signal_line, histogram = calculate_macd(closes)
+        upper_band, middle_band, lower_band = calculate_bollinger_bands(closes)
+        sma20 = calculate_sma(closes, 20)
+        sma50 = calculate_sma(closes, 50)
+
+        # Reset index so Date becomes a column
+        df = df.reset_index()
+        df["Date"] = df["Date"].dt.strftime("%Y-%m-%d")
+
+        dates = df["Date"].tolist()
+        close_prices = clean_list(closes.round(2).tolist())
+
+        # Get latest non-NaN values safely
+        def latest(series):
+            val = series.dropna().iloc[-1] if not series.dropna().empty else None
+            return clean_nan(float(val)) if val is not None else None
+
+        return {
+            "ticker": ticker,
+            "dates": dates,
+            "closes": close_prices,
+            "rsi": clean_list(rsi.tolist()),
+            "macd": {
+                "macd_line": clean_list(macd_line.tolist()),
+                "signal_line": clean_list(signal_line.tolist()),
+                "histogram": clean_list(histogram.tolist())
+            },
+            "bollinger_bands": {
+                "upper": clean_list(upper_band.tolist()),
+                "middle": clean_list(middle_band.tolist()),
+                "lower": clean_list(lower_band.tolist())
+            },
+            "sma": {
+                "sma20": clean_list(sma20.tolist()),
+                "sma50": clean_list(sma50.tolist())
+            },
+            # Latest values for decision engine
+            "latest": {
+                "close": latest(closes),
+                "rsi": latest(rsi),
+                "macd_line": latest(macd_line),
+                "signal_line": latest(signal_line),
+                "histogram": latest(histogram),
+                "upper_band": latest(upper_band),
+                "middle_band": latest(middle_band),
+                "lower_band": latest(lower_band),
+                "sma20": latest(sma20),
+                "sma50": latest(sma50),
+            }
+        }
+
+    except Exception as e:
+        print(f"Error calculating indicators for {ticker}: {e}")
+        return None

app/services/sentiment.py

@@ -0,0 +1,228 @@
+"""
+sentiment_service.py
+~~~~~~~~~~~~~~~~~~~~
+Robust news sentiment for any ticker using a tiered approach:
+
+Tier 1 — NewsAPI  (fast, broad coverage)
+Tier 2 — Yahoo Finance RSS  (free, no key needed, good for US stocks)
+Tier 3 — Finnhub  (great for less-covered stocks, needs free API key)
+
+Each headline is scored with FinBERT. Returns a full response matching
+the SentimentPanel frontend component.
+"""
+
+from __future__ import annotations
+
+import os
+import logging
+import urllib.request
+import urllib.parse
+import json
+import xml.etree.ElementTree as ET
+from functools import lru_cache
+from typing import List
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+# ── Lazy-load FinBERT ───────────────────────────────────────────────────────────
+@lru_cache(maxsize=1)
+def _get_finbert():
+    from transformers import pipeline
+    return pipeline(
+        "text-classification",
+        model="ProsusAI/finbert",
+        tokenizer="ProsusAI/finbert",
+        device=-1,
+        top_k=None,
+        truncation=True,
+        max_length=512,
+    )
+
+LABEL_MAP = {"positive": 1.0, "negative": -1.0, "neutral": 0.0}
+
+
+# ── Score a single headline → (weighted_score, label, confidence) ───────────────
+def _score_one(text: str):
+    pipe     = _get_finbert()
+    result   = pipe(text[:512])[0]          # list of {label, score}
+    weighted = sum(LABEL_MAP[r["label"]] * r["score"] for r in result)
+    top      = max(result, key=lambda r: r["score"])
+    return weighted, top["label"], round(top["score"], 4)
+
+
+# ── Fetchers ────────────────────────────────────────────────────────────────────
+def _fetch_newsapi(ticker: str, company_name: str = "") -> List[dict]:
+    api_key = os.getenv("NEWSAPI_KEY", "")
+    if not api_key:
+        return []
+    query = urllib.parse.quote(f"{ticker} OR {company_name}" if company_name else ticker)
+    url   = (
+        f"https://newsapi.org/v2/everything"
+        f"?q={query}&language=en&sortBy=publishedAt&pageSize=10"
+        f"&apiKey={api_key}"
+    )
+    try:
+        with urllib.request.urlopen(url, timeout=5) as resp:
+            data = json.loads(resp.read())
+            return [
+                {
+                    "title":        a.get("title", ""),
+                    "url":          a.get("url", ""),
+                    "source":       a.get("source", {}).get("name", "NewsAPI"),
+                    "published_at": a.get("publishedAt", ""),
+                }
+                for a in data.get("articles", []) if a.get("title")
+            ]
+    except Exception as e:
+        logger.warning("NewsAPI failed for %s: %s", ticker, e)
+        return []
+
+
+def _fetch_yahoo_rss(ticker: str) -> List[dict]:
+    url = f"https://feeds.finance.yahoo.com/rss/2.0/headline?s={ticker}&region=US&lang=en-US"
+    try:
+        req = urllib.request.Request(url, headers={"User-Agent": "AlphaSignal/1.0"})
+        with urllib.request.urlopen(req, timeout=5) as resp:
+            root    = ET.fromstring(resp.read())
+            results = []
+            for item in root.findall(".//item")[:15]:
+                title = item.findtext("title") or ""
+                if title:
+                    results.append({
+                        "title":        title,
+                        "url":          item.findtext("link") or "",
+                        "source":       "Yahoo Finance",
+                        "published_at": item.findtext("pubDate") or "",
+                    })
+            return results
+    except Exception as e:
+        logger.warning("Yahoo RSS failed for %s: %s", ticker, e)
+        return []
+
+
+def _fetch_finnhub(ticker: str) -> List[dict]:
+    api_key = os.getenv("FINNHUB_KEY", "")
+    if not api_key:
+        return []
+    from datetime import date, timedelta
+    today = date.today().strftime("%Y-%m-%d")
+    week  = (date.today() - timedelta(days=7)).strftime("%Y-%m-%d")
+    url   = (
+        f"https://finnhub.io/api/v1/company-news"
+        f"?symbol={ticker}&from={week}&to={today}&token={api_key}"
+    )
+    try:
+        with urllib.request.urlopen(url, timeout=5) as resp:
+            return [
+                {
+                    "title":        a.get("headline", ""),
+                    "url":          a.get("url", ""),
+                    "source":       a.get("source", "Finnhub"),
+                    "published_at": str(a.get("datetime", "")),
+                }
+                for a in json.loads(resp.read())[:15] if a.get("headline")
+            ]
+    except Exception as e:
+        logger.warning("Finnhub failed for %s: %s", ticker, e)
+        return []
+
+
+def _dedupe(articles: List[dict]) -> List[dict]:
+    seen, out = set(), []
+    for a in articles:
+        key = a["title"].lower().strip()
+        if key not in seen:
+            seen.add(key)
+            out.append(a)
+    return out
+
+
+# ── Neutral response helper ─────────────────────────────────────────────────────
+def _neutral_response(ticker: str, message: str = "No relevant news found.") -> dict:
+    return {
+        "ticker":            ticker,
+        "headline_count":    0,
+        "overall_sentiment": "neutral",
+        "positive_pct":      0,
+        "neutral_pct":       100,
+        "negative_pct":      0,
+        "score":             0.0,
+        "source":            "none",
+        "message":           message,
+        "headlines":         [],
+    }
+
+
+# ── Public API ──────────────────────────────────────────────────────────────────
+def get_sentiment_score(ticker: str, company_name: str = "") -> dict:
+    """
+    Returns a dict matching SentimentPanel.jsx:
+    {
+        ticker, headline_count, overall_sentiment,
+        positive_pct, neutral_pct, negative_pct,
+        score, source,
+        headlines: [{ title, url, source, published_at, sentiment, score }]
+    }
+    """
+    articles: List[dict] = []
+    articles.extend(_fetch_newsapi(ticker, company_name))
+    articles.extend(_fetch_yahoo_rss(ticker))
+    if len(articles) < 5:
+        articles.extend(_fetch_finnhub(ticker))
+
+    articles = _dedupe(articles)
+
+    if len(articles) < 3:
+        return _neutral_response(ticker)
+
+    # Score each headline
+    scored = []
+    for a in articles:
+        try:
+            weighted, label, confidence = _score_one(a["title"])
+            scored.append({
+                "title":        a["title"],
+                "url":          a["url"],
+                "source":       a["source"],
+                "published_at": a["published_at"],
+                "sentiment":    label,        # "positive" | "negative" | "neutral"
+                "score":        confidence,   # shown as "XX% Conf." in the UI
+            })
+        except Exception as e:
+            logger.warning("Scoring failed: %s", e)
+
+    if not scored:
+        return _neutral_response(ticker, "Sentiment scoring failed.")
+
+    # Aggregate
+    n            = len(scored)
+    pos_count    = sum(1 for s in scored if s["sentiment"] == "positive")
+    neu_count    = sum(1 for s in scored if s["sentiment"] == "neutral")
+    neg_count    = sum(1 for s in scored if s["sentiment"] == "negative")
+    positive_pct = round(pos_count / n * 100)
+    neutral_pct  = round(neu_count / n * 100)
+    negative_pct = round(neg_count / n * 100)
+
+    overall_score = float(np.mean([LABEL_MAP[s["sentiment"]] * s["score"] for s in scored]))
+
+    if overall_score >= 0.15:
+        overall_sentiment = "positive"
+    elif overall_score <= -0.15:
+        overall_sentiment = "negative"
+    else:
+        overall_sentiment = "neutral"
+
+    return {
+        "ticker":            ticker,
+        "headline_count":    n,
+        "overall_sentiment": overall_sentiment,
+        "positive_pct":      positive_pct,
+        "neutral_pct":       neutral_pct,
+        "negative_pct":      negative_pct,
+        "score":             round(overall_score, 4),
+        "source":            "+".join(sorted({a["source"] for a in articles})),
+        "headlines":         scored,
+    }

requirements.txt

@@ -0,0 +1,83 @@
+absl-py==2.4.0
+annotated-doc==0.0.4
+annotated-types==0.7.0
+anyio==4.12.1
+astunparse==1.6.3
+beautifulsoup4==4.14.3
+certifi==2026.2.25
+cffi==2.0.0
+charset-normalizer==3.4.6
+click==8.3.1
+curl_cffi==0.13.0
+fastapi==0.135.1
+filelock==3.25.2
+flatbuffers==25.12.19
+frozendict==2.4.7
+fsspec==2026.2.0
+gast==0.7.0
+google-pasta==0.2.0
+grpcio==1.78.0
+h11==0.16.0
+h5py==3.14.0
+hf-xet==1.4.2
+httpcore==1.0.9
+httpx==0.28.1
+huggingface_hub==1.7.2
+idna==3.11
+Jinja2==3.1.6
+joblib==1.5.3
+keras==3.13.2
+libclang==18.1.1
+markdown-it-py==4.0.0
+MarkupSafe==3.0.3
+mdurl==0.1.2
+ml_dtypes==0.5.4
+mpmath==1.3.0
+multitasking==0.0.12
+namex==0.1.0
+networkx==3.6.1
+newsapi-python==0.2.7
+numpy==2.4.3
+opt_einsum==3.4.0
+optree==0.19.0
+packaging==26.0
+pandas==3.0.1
+peewee==4.0.2
+platformdirs==4.9.4
+protobuf==7.34.1
+pycparser==3.0
+pydantic==2.12.5
+pydantic_core==2.41.5
+Pygments==2.19.2
+python-dateutil==2.9.0.post0
+python-dotenv==1.2.2
+pytz==2026.1.post1
+PyYAML==6.0.3
+regex==2026.2.28
+requests==2.32.5
+rich==14.3.3
+safetensors==0.7.0
+scikit-learn==1.8.0
+scipy==1.17.1
+setuptools==81.0.0
+shellingham==1.5.4
+six==1.17.0
+soupsieve==2.8.3
+starlette==1.0.0
+sympy==1.14.0
+tensorflow==2.21.0
+termcolor==3.3.0
+threadpoolctl==3.6.0
+tokenizers==0.22.2
+torch==2.11.0
+tqdm==4.67.3
+transformers==5.3.0
+typer==0.24.1
+typing-inspection==0.4.2
+typing_extensions==4.15.0
+urllib3==2.6.3
+uvicorn==0.42.0
+websockets==16.0
+wheel==0.46.3
+wrapt==2.1.2
+yfinance==1.2.0