Upload 15 files

Dockerfile

@@ -0,0 +1,16 @@
+FROM python:3.10
+
+WORKDIR /code
+
+# Fix Python path for imports
+ENV PYTHONPATH=/code
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip \
+    && pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

app/__init__.py

@@ -0,0 +1 @@
+# just marks package

app/api/__init__.py

@@ -0,0 +1,9 @@
+from fastapi import APIRouter
+from .routes_root import router as root_router
+from .routes_prediction import router as prediction_router
+from .routes_price import router as price_router
+
+api_router = APIRouter()
+api_router.include_router(root_router)
+api_router.include_router(prediction_router)
+api_router.include_router(price_router)

app/api/routes_prediction.py

@@ -0,0 +1,25 @@
+from fastapi import APIRouter, HTTPException, Query
+from app.schemas import PredictionResponse, ChartForecastResponse
+from app.services.prediction import predict_path
+
+router = APIRouter(prefix="/api")
+
+@router.get("/prediction", response_model=PredictionResponse)
+def get_prediction(ticker: str = Query(..., min_length=1), days: int = 7):
+    try:
+        prediction_payload, _chart_payload, _loaded = predict_path(ticker, days)
+        return prediction_payload
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/price/forecast", response_model=ChartForecastResponse)
+def get_price_forecast(ticker: str = Query(..., min_length=1), days: int = 7):
+    try:
+        _prediction_payload, chart_payload, _loaded = predict_path(ticker, days)
+        return chart_payload
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

app/api/routes_price.py

@@ -0,0 +1,21 @@
+from fastapi import APIRouter, HTTPException, Query
+from app.schemas import HistoryResponse
+from app.services.market_data import get_enriched_history, last_n_candles
+from app.config import get_settings
+
+router = APIRouter(prefix="/api")
+settings = get_settings()
+
+@router.get("/price/history", response_model=HistoryResponse)
+def get_price_history(
+    ticker: str = Query(..., min_length=1),
+    days: int = Query(60, ge=30, le=365),
+):
+    try:
+        df_raw, _df_tech = get_enriched_history(ticker)
+        candles = last_n_candles(df_raw, min(days, settings.history_window))
+        return HistoryResponse(ticker=ticker.upper(), historicalPrices=candles)
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

app/api/routes_root.py

@@ -0,0 +1,12 @@
+from fastapi import APIRouter
+from app.schemas import HealthResponse
+from app.services.prediction import MODEL_LOADED
+
+router = APIRouter()
+
+@router.get("/", response_model=HealthResponse)
+def root() -> HealthResponse:
+    return HealthResponse(
+        status="QuantMind backend is live 🤖",
+        modelLoaded=MODEL_LOADED,
+    )

app/config.py

@@ -0,0 +1,18 @@
+import os
+from functools import lru_cache
+
+class Settings:
+    app_name: str = "QuantMind Backend"
+    environment: str = os.getenv("ENVIRONMENT", "dev")
+    cors_origins: list[str] = os.getenv("CORS_ORIGINS", "*").split(",")
+    model_path: str = os.getenv(
+        "MODEL_PATH",
+        "model/universal_multivariate_model_v1.h5",
+    )
+    yfinance_period: str = os.getenv("YF_PERIOD", "1y")
+    history_window: int = int(os.getenv("HISTORY_WINDOW", "60"))
+    max_forecast_days: int = int(os.getenv("MAX_FORECAST_DAYS", "14"))
+
+@lru_cache
+def get_settings() -> Settings:
+    return Settings()

app/indicators.py

@@ -0,0 +1,46 @@
+import numpy as np
+import pandas as pd
+
+def add_technical_indicators(df: pd.DataFrame) -> pd.DataFrame:
+    df = df.copy()
+
+    # RSI
+    delta = df["Close"].diff()
+    gain = delta.where(delta > 0, 0).rolling(window=14).mean()
+    loss = -delta.where(delta < 0, 0).rolling(window=14).mean()
+    rs = gain / loss
+    df["RSI"] = 100 - (100 / (1 + rs))
+
+    # MACD
+    exp1 = df["Close"].ewm(span=12, adjust=False).mean()
+    exp2 = df["Close"].ewm(span=26, adjust=False).mean()
+    df["MACD"] = exp1 - exp2
+
+    # Simple 50-day MA
+    df["MA50"] = df["Close"].rolling(window=50).mean()
+
+    # Log Volume
+    df["Log_Volume"] = np.log(df["Volume"] + 1)
+
+    df = df.dropna()
+    return df
+
+def classify_signal(predicted_change: float) -> str:
+    if predicted_change > 1.0:
+        return "STRONG BUY"
+    if predicted_change > 0:
+        return "BUY"
+    if predicted_change < -1.0:
+        return "STRONG SELL"
+    if predicted_change < 0:
+        return "SELL"
+    return "HOLD"
+
+def classify_volatility(df: pd.DataFrame) -> str:
+    returns = df["Close"].pct_change().dropna()
+    vol = returns.std()
+    if vol < 0.01:
+        return "Low"
+    if vol < 0.025:
+        return "Medium"
+    return "High"

app/schemas.py

@@ -0,0 +1,47 @@
+from typing import List, Literal, Optional
+from pydantic import BaseModel, Field
+
+SignalType = Literal["BUY", "SELL", "HOLD", "STRONG BUY", "STRONG SELL"]
+VolatilityLevel = Literal["Low", "Medium", "High"]
+
+class Candle(BaseModel):
+    date: str
+    price: float
+
+class ForecastPoint(BaseModel):
+    day: int
+    price: float
+    lower: float
+    upper: float
+
+class PredictionResponse(BaseModel):
+    ticker: str
+    currentPrice: float
+    targetPrice: float
+    predictedChange: float
+    signal: SignalType
+    rsi: float
+    macd: str
+    volatility: VolatilityLevel
+    historicalPrices: List[Candle]
+    predictedPrice: float
+    forecastData: List[ForecastPoint]
+
+class HistoryResponse(BaseModel):
+    ticker: str
+    historicalPrices: List[Candle]
+
+class ChartForecastPoint(BaseModel):
+    date: str
+    price: float
+    lower: float
+    upper: float
+
+class ChartForecastResponse(BaseModel):
+    ticker: str
+    points: List[ChartForecastPoint]
+
+class HealthResponse(BaseModel):
+    status: str
+    modelLoaded: bool
+    version: str = Field(default="1.0.0")

app/services/__init__.py

@@ -0,0 +1 @@
+# service namespace

app/services/market_data.py

@@ -0,0 +1,40 @@
+from datetime import datetime
+from typing import Tuple
+import pandas as pd
+import yfinance as yf
+from fastapi import HTTPException
+
+from app.config import get_settings
+from app.indicators import add_technical_indicators
+
+settings = get_settings()
+
+def fetch_raw_history(ticker: str) -> pd.DataFrame:
+    df = yf.download(
+        ticker,
+        period=settings.yfinance_period,
+        progress=False,
+        auto_adjust=False,
+    )
+    if df.empty or len(df) < settings.history_window + 60:
+        raise HTTPException(
+            status_code=400,
+            detail="Not enough historical data for this ticker.",
+        )
+    df.index = df.index.tz_localize(None)
+    return df
+
+def get_enriched_history(ticker: str) -> Tuple[pd.DataFrame, pd.DataFrame]:
+    df_raw = fetch_raw_history(ticker)
+    df_tech = add_technical_indicators(df_raw)
+    return df_raw, df_tech
+
+def last_n_candles(df: pd.DataFrame, n: int) -> list[dict]:
+    tail = df.tail(n)
+    return [
+        {
+            "date": idx.strftime("%Y-%m-%d"),
+            "price": float(row["Close"]),
+        }
+        for idx, row in tail.iterrows()
+    ]

app/services/prediction.py

@@ -0,0 +1,132 @@
+from typing import List
+import numpy as np
+import pandas as pd
+from tensorflow.keras.models import load_model
+from fastapi import HTTPException
+
+from app.config import get_settings
+from app.indicators import classify_signal, classify_volatility
+from app.services.market_data import get_enriched_history, last_n_candles
+
+settings = get_settings()
+
+try:
+  _model = load_model(settings.model_path)
+  MODEL_LOADED = True
+except Exception as e:
+  print(f"[Prediction] Failed to load model: {e}")
+  _model = None
+  MODEL_LOADED = False
+
+def _normalize_window(window: np.ndarray) -> np.ndarray:
+    """
+    window shape: (60, 5) -> [Close, RSI, MACD, Log_Volume, MA50]
+    """
+    start_p = window[0, 0]
+    norm = np.zeros_like(window)
+    norm[:, 0] = (window[:, 0] / start_p) - 1
+    norm[:, 1] = window[:, 1] / 100.0
+    norm[:, 2] = window[:, 2] / start_p
+    norm[:, 3] = (window[:, 3] / np.mean(window[:, 3])) - 1
+    norm[:, 4] = (window[:, 4] / start_p) - 1
+    return norm, start_p
+
+def predict_path(ticker: str, days: int):
+    if _model is None or not MODEL_LOADED:
+        raise HTTPException(status_code=500, detail="Prediction model not loaded.")
+
+    if days > settings.max_forecast_days:
+        days = settings.max_forecast_days
+
+    df_raw, df_tech = get_enriched_history(ticker)
+    features = df_tech[["Close", "RSI", "MACD", "Log_Volume", "MA50"]].values
+    last_window = features[-settings.history_window :]
+    current_price = float(last_window[-1, 0])
+
+    temp_window = last_window.copy()
+    forecast_points: List[dict] = []
+
+    for i in range(days):
+        norm, start_p = _normalize_window(temp_window)
+        pred_pct = _model.predict(norm.reshape(1, 60, 5), verbose=0)[0][0]
+        next_price = float(start_p * (1 + pred_pct))
+
+        volatility = 0.015 * (i + 1)
+        lower_bound = float(next_price * (1 - volatility))
+        upper_bound = float(next_price * (1 + volatility))
+
+        forecast_points.append(
+            {
+                "day": i + 1,
+                "price": next_price,
+                "lower": lower_bound,
+                "upper": upper_bound,
+            }
+        )
+
+        new_row = temp_window[-1].copy()
+        new_row[0] = next_price
+        temp_window = np.vstack([temp_window[1:], new_row])
+
+    # summary metrics
+    target_price = float(forecast_points[-1]["price"])
+    predicted_change = ((target_price - current_price) / current_price) * 100
+
+    vol_label = classify_volatility(df_raw)
+    signal = classify_signal(predicted_change)
+    rsi_latest = float(df_tech["RSI"].iloc[-1])
+    macd_latest = float(df_tech["MACD"].iloc[-1])
+    macd_label = "Bullish" if macd_latest >= 0 else "Bearish"
+
+    historical = last_n_candles(df_raw, settings.history_window)
+
+    prediction_payload = {
+        "ticker": ticker.upper(),
+        "currentPrice": current_price,
+        "targetPrice": target_price,
+        "predictedChange": predicted_change,
+        "signal": signal,
+        "rsi": rsi_latest,
+        "macd": macd_label,
+        "volatility": vol_label,
+        "historicalPrices": historical,
+        "predictedPrice": target_price,
+        "forecastData": [
+            {
+                "day": p["day"],
+                "price": p["price"],
+                "changePct": ((p["price"] - current_price) / current_price) * 100,
+            }
+            for p in forecast_points
+        ],
+    }
+
+    chart_forecast_payload = {
+        "ticker": ticker.upper(),
+        "points": [
+            {
+                "date": historical[-1]["date"],  # last known date
+                "price": current_price,
+                "lower": current_price,
+                "upper": current_price,
+            },
+            # add synthetic forward dates
+        ],
+    }
+
+    # add future dates
+    from datetime import datetime, timedelta
+
+    last_date = datetime.strptime(historical[-1]["date"], "%Y-%m-%d")
+    for i, p in enumerate(forecast_points, start=1):
+        d = last_date + timedelta(days=i)
+        chart_forecast_payload["points"].append(
+            {
+                "date": d.strftime("%Y-%m-%d"),
+                "price": p["price"],
+                "lower": p["lower"],
+                "upper": p["upper"],
+            }
+        )
+
+    return prediction_payload, chart_forecast_payload, MODEL_LOADED

main.py

@@ -0,0 +1,23 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from app.api import api_router
+from app.config import get_settings
+
+settings = get_settings()
+
+app = FastAPI(
+    title="QuantMind Backend",
+    version="1.0.0",
+    description="LSTM-based stock prediction API for the QuantMind dashboard.",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # tighten later
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(api_router)

requirements.txt

@@ -0,0 +1,7 @@
+fastapi==0.115.0
+uvicorn[standard]==0.30.0
+numpy==1.26.4
+pandas==2.2.2
+yfinance==0.2.44
+tensorflow==2.17.0
+python-multipart==0.0.9

tests/test_health.py

@@ -0,0 +1,10 @@
+from fastapi.testclient import TestClient
+from main import app
+
+client = TestClient(app)
+
+def test_root_health():
+    resp = client.get("/")
+    assert resp.status_code == 200
+    body = resp.json()
+    assert "status" in body