Upload 13 files

Dockerfile

@@ -0,0 +1,14 @@
+FROM python:3.11-slim
+
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user PATH=/home/user/.local/bin:$PATH
+WORKDIR $HOME/app
+
+COPY --chown=user requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip && pip install --no-cache-dir -r requirements.txt
+
+COPY --chown=user app ./app
+
+EXPOSE 7860
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,10 @@
+---
+title: Quant Live Portfolio Upload API
+emoji: 📈
+colorFrom: purple
+colorTo: blue
+sdk: docker
+app_port: 7860
+---
+
+Backend for Vercel frontend with CSV and TXT ticker upload handled client side.

app/config.py

@@ -0,0 +1,10 @@
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+class Settings(BaseSettings):
+    app_name: str = Field(default="Quant Live Portfolio")
+    frontend_origin: str = Field(default="http://localhost:5173")
+    stream_interval_seconds: int = Field(default=15)
+    model_config = SettingsConfigDict(env_file=".env", extra="ignore")
+
+settings = Settings()

app/features.py

@@ -0,0 +1,42 @@
+import numpy as np
+import pandas as pd
+
+FEATURE_COLUMNS = [
+    "ret_1d", "ret_5d", "ret_20d", "vol_20d",
+    "ma_ratio_10_50", "volume_z", "market_return",
+    "momentum_factor", "value_factor",
+]
+
+def build_features(df: pd.DataFrame, sector_map: dict[str, str]) -> pd.DataFrame:
+    if df.empty:
+        raise ValueError("Input market dataframe is empty")
+    out = df.sort_values(["ticker", "date"]).copy()
+    market_daily = out.groupby("date")["close"].mean().pct_change().fillna(0.0).rename("market_return")
+    out = out.merge(market_daily, on="date", how="left")
+
+    def add_group_features(g: pd.DataFrame) -> pd.DataFrame:
+        g = g.sort_values("date").copy()
+        g["ret_1d"] = g["close"].pct_change(1)
+        g["ret_5d"] = g["close"].pct_change(5)
+        g["ret_20d"] = g["close"].pct_change(20)
+        g["vol_20d"] = g["close"].pct_change().rolling(20).std()
+        ma10 = g["close"].rolling(10).mean()
+        ma50 = g["close"].rolling(50).mean()
+        g["ma_ratio_10_50"] = ma10 / ma50 - 1.0
+        vol_mean = g["volume"].rolling(20).mean()
+        vol_std = g["volume"].rolling(20).std().replace(0, np.nan)
+        g["volume_z"] = ((g["volume"] - vol_mean) / vol_std).fillna(0.0)
+        g["momentum_factor"] = g["ret_20d"].rolling(5).mean()
+        g["value_factor"] = -g["ma_ratio_10_50"]
+        g["target_return_5d"] = g["close"].shift(-5) / g["close"] - 1.0
+        return g
+
+    pieces = []
+    for _, g in out.groupby("ticker"):
+        pieces.append(add_group_features(g))
+    out = pd.concat(pieces, ignore_index=True)
+    out["sector"] = out["ticker"].map(sector_map).fillna("Unknown")
+    out = out.dropna().reset_index(drop=True)
+    if out.empty:
+        raise ValueError("No usable rows after feature engineering")
+    return out

app/main.py

@@ -0,0 +1,63 @@
+import asyncio
+import json
+from fastapi import FastAPI, HTTPException, Query
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse
+from .config import settings
+from .schemas import PortfolioRequest, PortfolioResponse
+from .market import DEFAULT_UNIVERSE
+from .service import build_portfolio_payload
+
+app = FastAPI(title=settings.app_name)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[settings.frontend_origin, "http://localhost:5173"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/health")
+def health():
+    return {"ok": True, "service": settings.app_name}
+
+@app.get("/api/universe")
+def universe():
+    return {"tickers": DEFAULT_UNIVERSE}
+
+@app.post("/api/portfolio", response_model=PortfolioResponse)
+def portfolio(req: PortfolioRequest):
+    try:
+        return build_portfolio_payload(
+            tickers=req.tickers,
+            lookback_days=req.lookback_days,
+            risk_aversion=req.risk_aversion,
+            max_weight=req.max_weight,
+            sector_limit=req.sector_limit,
+            beta_limit=req.beta_limit,
+        )
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@app.get("/api/stream")
+async def stream(tickers: str = Query(default="AAPL,MSFT,NVDA,AMZN"), lookback_days: int = Query(default=365), risk_aversion: float = Query(default=8.0), max_weight: float = Query(default=0.35), sector_limit: float = Query(default=0.70), beta_limit: float = Query(default=1.20)):
+    ticker_list = [x.strip().upper() for x in tickers.split(",") if x.strip()]
+
+    async def event_generator():
+        while True:
+            try:
+                payload = build_portfolio_payload(
+                    tickers=ticker_list,
+                    lookback_days=lookback_days,
+                    risk_aversion=risk_aversion,
+                    max_weight=max_weight,
+                    sector_limit=sector_limit,
+                    beta_limit=beta_limit,
+                )
+                yield f"data: {json.dumps(payload)}\n\n"
+            except Exception as e:
+                yield f"data: {json.dumps({'error': str(e)})}\n\n"
+            await asyncio.sleep(settings.stream_interval_seconds)
+
+    return StreamingResponse(event_generator(), media_type="text/event-stream")

app/market.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+from typing import List, Dict
+import pandas as pd
+import yfinance as yf
+
+DEFAULT_UNIVERSE = [
+    "AAPL", "MSFT", "NVDA", "AMZN", "GOOGL", "META",
+    "JPM", "XOM", "AVGO", "LLY", "AMD", "COST"
+]
+
+def sanitize_tickers(tickers: List[str]) -> List[str]:
+    cleaned = []
+    for t in tickers:
+        t = (t or "").strip().upper().replace('"', "").replace("'", "")
+        if t and t.isascii() and t.replace("-", "").replace(".", "").isalnum():
+            cleaned.append(t)
+    return list(dict.fromkeys(cleaned))[:20]
+
+def fetch_price_history(tickers: List[str], lookback_days: int = 365) -> pd.DataFrame:
+    tickers = sanitize_tickers(tickers)
+    if len(tickers) < 2:
+        raise ValueError("Need at least 2 valid tickers")
+
+    period = "2y" if lookback_days > 365 else "1y"
+    data = yf.download(
+        tickers=tickers,
+        period=period,
+        interval="1d",
+        auto_adjust=True,
+        progress=False,
+        threads=True,
+        group_by="ticker",
+    )
+
+    rows = []
+
+    if isinstance(data.columns, pd.MultiIndex):
+        for ticker in tickers:
+            try:
+                block = data[ticker].copy()
+            except Exception:
+                continue
+
+            if block.empty or "Close" not in block.columns:
+                continue
+
+            block = block.reset_index()
+            date_col = "Date" if "Date" in block.columns else block.columns[0]
+
+            for _, row in block.iterrows():
+                close_val = row.get("Close")
+                if pd.isna(close_val):
+                    continue
+                rows.append({
+                    "date": pd.Timestamp(row[date_col]).normalize(),
+                    "ticker": ticker,
+                    "close": float(close_val),
+                    "volume": float(row.get("Volume", 0.0) or 0.0),
+                })
+    else:
+        if len(tickers) != 1:
+            raise ValueError("Unexpected Yahoo Finance schema for multiple tickers")
+        ticker = tickers[0]
+        block = data.copy()
+        if block.empty or "Close" not in block.columns:
+            raise ValueError("No usable market data returned")
+        block = block.reset_index()
+        date_col = "Date" if "Date" in block.columns else block.columns[0]
+
+        for _, row in block.iterrows():
+            close_val = row.get("Close")
+            if pd.isna(close_val):
+                continue
+            rows.append({
+                "date": pd.Timestamp(row[date_col]).normalize(),
+                "ticker": ticker,
+                "close": float(close_val),
+                "volume": float(row.get("Volume", 0.0) or 0.0),
+            })
+
+    out = pd.DataFrame(rows)
+    if out.empty:
+        raise ValueError("No market data returned")
+    if "ticker" not in out.columns:
+        raise ValueError(f"Ticker column missing from market data. Columns: {list(out.columns)}")
+    out = out.sort_values(["ticker", "date"]).reset_index(drop=True)
+    return out
+
+def fetch_quotes(tickers: List[str]) -> List[Dict[str, float]]:
+    tickers = sanitize_tickers(tickers)
+    result = []
+    for ticker in tickers:
+        try:
+            hist = yf.Ticker(ticker).history(period="5d", interval="1d", auto_adjust=True)
+            if hist.empty:
+                continue
+            last = float(hist["Close"].iloc[-1])
+            prev = float(hist["Close"].iloc[-2]) if len(hist) > 1 else last
+            chg = 0.0 if prev == 0 else (last / prev - 1.0)
+            result.append({
+                "ticker": ticker,
+                "price": last,
+                "day_change_pct": chg,
+            })
+        except Exception:
+            continue
+    return result
+
+def infer_sectors(tickers: List[str]) -> Dict[str, str]:
+    return {ticker: "Unknown" for ticker in sanitize_tickers(tickers)}

app/models.py

@@ -0,0 +1,40 @@
+from typing import Dict, Tuple
+import pandas as pd
+from xgboost import XGBRegressor
+from .features import FEATURE_COLUMNS
+
+def train_model(feature_df: pd.DataFrame) -> Tuple[XGBRegressor, pd.DataFrame]:
+    X = feature_df[FEATURE_COLUMNS]
+    y = feature_df["target_return_5d"]
+    model = XGBRegressor(
+        n_estimators=120,
+        max_depth=4,
+        learning_rate=0.05,
+        subsample=0.9,
+        colsample_bytree=0.9,
+        objective="reg:squarederror",
+        random_state=42,
+        n_jobs=2,
+        enable_categorical=False,
+    )
+    model.fit(X, y)
+    return model, feature_df
+
+def latest_predictions(model: XGBRegressor, feature_df: pd.DataFrame) -> pd.DataFrame:
+    latest = feature_df.sort_values("date").groupby("ticker", as_index=False).tail(1).reset_index(drop=True)
+    latest["predicted_return"] = model.predict(latest[FEATURE_COLUMNS])
+    return latest
+
+def top_feature_contributions(model: XGBRegressor, latest_df: pd.DataFrame, top_n: int = 5) -> Dict[str, list]:
+    booster = model.get_booster()
+    raw_gain = booster.get_score(importance_type="gain") or {}
+    gain_map = {name: float(raw_gain.get(f"f{i}", 0.0)) for i, name in enumerate(FEATURE_COLUMNS)}
+    ranked = sorted(gain_map.items(), key=lambda x: x[1], reverse=True)[:top_n]
+    template = [{"feature": f, "contribution": v} for f, v in ranked]
+    if not template:
+        template = [
+            {"feature": "ret_20d", "contribution": 0.0},
+            {"feature": "momentum_factor", "contribution": 0.0},
+            {"feature": "market_return", "contribution": 0.0},
+        ]
+    return {ticker: template for ticker in latest_df["ticker"].tolist()}

app/optimizer.py

@@ -0,0 +1,41 @@
+from typing import Dict, List, Tuple
+import numpy as np
+import pandas as pd
+import cvxpy as cp
+
+def optimize_portfolio(latest_predictions: pd.DataFrame, feature_df: pd.DataFrame, risk_aversion: float = 8.0, max_weight: float = 0.35, sector_limit: float = 0.70, beta_limit: float = 1.20) -> Tuple[pd.DataFrame, List[Dict[str, float]], Dict[str, float]]:
+    tickers = latest_predictions["ticker"].tolist()
+    n = len(tickers)
+    returns_wide = feature_df.pivot(index="date", columns="ticker", values="ret_1d").dropna().loc[:, tickers]
+    cov = returns_wide.cov().fillna(0.0).values + np.eye(n) * 1e-6
+    mu = latest_predictions["predicted_return"].fillna(0.0).values
+    beta = latest_predictions["ret_20d"].fillna(0.0).values * 4 + 1.0
+    sectors = latest_predictions["sector"].tolist()
+
+    w = cp.Variable(n)
+    objective = cp.Maximize(mu @ w - risk_aversion * cp.quad_form(w, cov))
+    constraints = [cp.sum(w) == 1, w >= 0, w <= max_weight, beta @ w <= beta_limit]
+    for sec in sorted(set(sectors)):
+        idx = [i for i, s in enumerate(sectors) if s == sec]
+        constraints.append(cp.sum(w[idx]) <= sector_limit)
+
+    problem = cp.Problem(objective, constraints)
+    try:
+        problem.solve(solver=cp.SCS, verbose=False)
+    except Exception:
+        pass
+
+    if w.value is None:
+        weights = np.repeat(1.0 / n, n)
+    else:
+        weights = np.maximum(np.array(w.value).flatten(), 0.0)
+        weights = weights / weights.sum() if weights.sum() > 0 else np.repeat(1.0 / n, n)
+
+    weight_df = pd.DataFrame({"ticker": tickers, "weight": weights})
+    exposures = [{"factor": "beta", "exposure": float(beta @ weights), "limit": beta_limit}]
+    for sec in sorted(set(sectors)):
+        idx = [i for i, s in enumerate(sectors) if s == sec]
+        exposures.append({"factor": f"sector_{sec.lower().replace(' ', '_')}", "exposure": float(weights[idx].sum()), "limit": sector_limit})
+
+    aux = {"exp_return_daily": float(mu @ weights), "vol_daily": float(np.sqrt(max(weights.T @ cov @ weights, 1e-12)))}
+    return weight_df, exposures, aux

app/risk.py

@@ -0,0 +1,28 @@
+from typing import Dict, List
+import numpy as np
+import pandas as pd
+
+def monte_carlo_quantiles(weight_df: pd.DataFrame, feature_df: pd.DataFrame, horizon_days: int = 126, n_sims: int = 1200) -> Dict[str, float]:
+    tickers = weight_df["ticker"].tolist()
+    weights = weight_df["weight"].values
+    returns_wide = feature_df.pivot(index="date", columns="ticker", values="ret_1d").dropna().loc[:, tickers]
+    mu = returns_wide.mean().values
+    cov = returns_wide.cov().values + np.eye(len(tickers)) * 1e-6
+    rng = np.random.default_rng(7)
+    sims = rng.multivariate_normal(mu, cov, size=(n_sims, horizon_days))
+    port_paths = 1.0 + np.einsum("shn,n->sh", sims, weights)
+    terminal = port_paths.prod(axis=1)
+    return {"p05": float(np.quantile(terminal, 0.05)), "p50": float(np.quantile(terminal, 0.50)), "p95": float(np.quantile(terminal, 0.95))}
+
+def simple_backtest(weight_df: pd.DataFrame, feature_df: pd.DataFrame) -> List[Dict[str, float]]:
+    tickers = weight_df["ticker"].tolist()
+    weights = weight_df["weight"].values
+    returns_wide = feature_df.pivot(index="date", columns="ticker", values="ret_1d").dropna().loc[:, tickers]
+    benchmark = returns_wide.mean(axis=1)
+    port = returns_wide.values @ weights
+    portfolio_curve = (1 + pd.Series(port, index=returns_wide.index)).cumprod()
+    benchmark_curve = (1 + benchmark).cumprod()
+    points = []
+    for d in returns_wide.index[-120:]:
+        points.append({"timestamp": float(pd.Timestamp(d).timestamp()), "portfolio": float(portfolio_curve.loc[d]), "benchmark": float(benchmark_curve.loc[d])})
+    return points

app/schemas.py

@@ -0,0 +1,43 @@
+from typing import List, Dict
+from pydantic import BaseModel, Field
+
+class PortfolioRequest(BaseModel):
+    tickers: List[str] = Field(min_length=2, max_length=20)
+    lookback_days: int = Field(default=365, ge=120, le=1500)
+    risk_aversion: float = Field(default=8.0, ge=0.1, le=50.0)
+    max_weight: float = Field(default=0.35, ge=0.05, le=1.0)
+    sector_limit: float = Field(default=0.70, ge=0.10, le=1.0)
+    beta_limit: float = Field(default=1.20, ge=0.50, le=3.0)
+
+class WeightItem(BaseModel):
+    ticker: str
+    weight: float
+
+class MetricCard(BaseModel):
+    label: str
+    value: float
+
+class FactorExposure(BaseModel):
+    factor: str
+    exposure: float
+    limit: float
+
+class QuoteItem(BaseModel):
+    ticker: str
+    price: float
+    day_change_pct: float
+
+class ShapItem(BaseModel):
+    feature: str
+    contribution: float
+
+class PortfolioResponse(BaseModel):
+    tickers: List[str]
+    weights: List[WeightItem]
+    metrics: List[MetricCard]
+    factor_exposures: List[FactorExposure]
+    quotes: List[QuoteItem]
+    monte_carlo_quantiles: Dict[str, float]
+    backtest_points: List[Dict[str, float]]
+    shap_top_features: Dict[str, List[ShapItem]]
+    notes: List[str] = Field(default_factory=list)

app/service.py

@@ -0,0 +1,56 @@
+from .market import sanitize_tickers, fetch_price_history, fetch_quotes, infer_sectors
+from .features import build_features
+from .models import train_model, latest_predictions, top_feature_contributions
+from .optimizer import optimize_portfolio
+from .risk import monte_carlo_quantiles, simple_backtest
+
+def build_portfolio_payload(tickers, lookback_days, risk_aversion, max_weight, sector_limit, beta_limit):
+    tickers = sanitize_tickers(tickers)
+    if len(tickers) < 2:
+        raise ValueError("Choose at least 2 valid tickers")
+
+    sector_map = infer_sectors(tickers)
+    raw = fetch_price_history(tickers, lookback_days=lookback_days)
+    feature_df = build_features(raw, sector_map)
+    model, feature_df = train_model(feature_df)
+    latest_df = latest_predictions(model, feature_df)
+    weights_df, factor_exposures, aux = optimize_portfolio(
+        latest_predictions=latest_df,
+        feature_df=feature_df,
+        risk_aversion=risk_aversion,
+        max_weight=max_weight,
+        sector_limit=sector_limit,
+        beta_limit=beta_limit,
+    )
+    quotes = fetch_quotes(tickers)
+    mc = monte_carlo_quantiles(weights_df, feature_df)
+    backtest = simple_backtest(weights_df, feature_df)
+    explain = top_feature_contributions(model, latest_df)
+
+    metrics = [
+        {"label": "Expected Return", "value": round(aux["exp_return_daily"] * 252, 4)},
+        {"label": "Volatility", "value": round(aux["vol_daily"] * (252 ** 0.5), 4)},
+        {"label": "Sharpe Proxy", "value": round((aux["exp_return_daily"] * 252) / max(aux["vol_daily"] * (252 ** 0.5), 1e-6), 4)},
+        {"label": "VaR Proxy", "value": round(1 - mc["p05"], 4)},
+        {"label": "CVaR Proxy", "value": round((1 - mc["p05"]) * 1.15, 4)},
+        {"label": "Median Terminal", "value": round(mc["p50"], 4)},
+    ]
+
+    notes = [
+        "Live prices come from Yahoo Finance.",
+        "Users choose stocks from buttons, paste text, or upload CSV or TXT.",
+        "The backend streams updated portfolio payloads with Server Sent Events.",
+        "Model drivers use XGBoost gain importance for deployment stability.",
+    ]
+
+    return {
+        "tickers": tickers,
+        "weights": weights_df.to_dict(orient="records"),
+        "metrics": metrics,
+        "factor_exposures": factor_exposures,
+        "quotes": quotes,
+        "monte_carlo_quantiles": mc,
+        "backtest_points": backtest,
+        "shap_top_features": explain,
+        "notes": notes,
+    }

requirements.txt

@@ -0,0 +1,12 @@
+fastapi==0.121.0
+uvicorn[standard]==0.38.0
+pydantic==2.12.2
+pydantic-settings==2.11.0
+numpy==2.1.3
+pandas==2.3.3
+cvxpy==1.7.3
+xgboost==3.1.0
+scikit-learn==1.7.2
+python-dotenv==1.1.1
+yfinance==0.2.66
+httpx==0.28.1