Update Dockerfile

Dockerfile

@@ -1,608 +1,38 @@
-# app.py
-import os, io, math, time, warnings
-warnings.filterwarnings("ignore")
-
-# --- make matplotlib headless & writable ---
-import matplotlib
-matplotlib.use("Agg")
-os.environ.setdefault("MPLCONFIGDIR", "/home/user/.config/matplotlib")
-
-from typing import List, Tuple, Dict, Optional
-
-import numpy as np
-import pandas as pd
-import matplotlib.pyplot as plt
-from PIL import Image
-import requests
-import yfinance as yf
-import gradio as gr
-
-# ---------------- config ----------------
-DATA_DIR = "data"
-os.makedirs(DATA_DIR, exist_ok=True)
-
-MAX_TICKERS = 30
-DEFAULT_LOOKBACK_YEARS = 10
-MARKET_TICKER = "VOO"
-
-SYNTH_ROWS = 1000  # size of generated dataset for suggestions
-
-# Globals that update with horizon changes
-HORIZON_YEARS = 10
-RF_CODE = "DGS10"
-RF_ANN = 0.0375  # updated at launch
-
-# ---------------- helpers ----------------
-def fred_series_for_horizon(years: float) -> str:
-    y = max(1.0, min(100.0, float(years)))
-    if y <= 2: return "DGS2"
-    if y <= 3: return "DGS3"
-    if y <= 5: return "DGS5"
-    if y <= 7: return "DGS7"
-    if y <= 10: return "DGS10"
-    if y <= 20: return "DGS20"
-    return "DGS30"
-
-def fetch_fred_yield_annual(code: str) -> float:
-    url = f"https://fred.stlouisfed.org/graph/fredgraph.csv?id={code}"
-    try:
-        r = requests.get(url, timeout=10)
-        r.raise_for_status()
-        df = pd.read_csv(io.StringIO(r.text))
-        s = pd.to_numeric(df.iloc[:, 1], errors="coerce").dropna()
-        return float(s.iloc[-1] / 100.0) if len(s) else 0.03
-    except Exception:
-        return 0.03
-
-def fetch_prices_monthly(tickers: List[str], years: int) -> pd.DataFrame:
-    tickers = list(dict.fromkeys([t.upper().strip() for t in tickers]))
-    start = (pd.Timestamp.today(tz="UTC") - pd.DateOffset(years=years, days=7)).date()
-    end = pd.Timestamp.today(tz="UTC").date()
-
-    df = yf.download(
-        tickers,
-        start=start,
-        end=end,
-        interval="1mo",
-        auto_adjust=True,
-        actions=False,
-        progress=False,
-        group_by="column",
-        threads=False,
-    )
-
-    # Normalize to wide frame of prices (one column per ticker)
-    if isinstance(df, pd.Series):
-        df = df.to_frame()
-    if isinstance(df.columns, pd.MultiIndex):
-        lvl0 = [str(x) for x in df.columns.get_level_values(0).unique()]
-        if "Close" in lvl0:
-            df = df["Close"]
-        elif "Adj Close" in lvl0:
-            df = df["Adj Close"]
-        else:
-            df = df.xs(df.columns.levels[0][-1], axis=1, level=0, drop_level=True)
-
-    cols = [c for c in tickers if c in df.columns]
-    out = df[cols].dropna(how="all").fillna(method="ffill")
-    return out
-
-def monthly_returns(prices: pd.DataFrame) -> pd.DataFrame:
-    return prices.pct_change().dropna()
-
-def yahoo_search(query: str):
-    if not query or not str(query).strip():
-        return []
-    url = "https://query1.finance.yahoo.com/v1/finance/search"
-    params = {"q": query.strip(), "quotesCount": 10, "newsCount": 0}
-    headers = {"User-Agent": "Mozilla/5.0"}
-    try:
-        r = requests.get(url, params=params, headers=headers, timeout=10)
-        r.raise_for_status()
-        data = r.json()
-        out = []
-        for q in data.get("quotes", []):
-            sym = q.get("symbol")
-            name = q.get("shortname") or q.get("longname") or ""
-            exch = q.get("exchDisp") or ""
-            if sym and sym.isascii():
-                out.append(f"{sym}  |  {name}  |  {exch}")
-        if not out:
-            out = [f"{query.strip().upper()}  |  typed symbol  |  n/a"]
-        return out[:10]
-    except Exception:
-        return [f"{query.strip().upper()}  |  typed symbol  |  n/a"]
-
-def validate_tickers(symbols: List[str], years: int) -> List[str]:
-    base = [s for s in dict.fromkeys([t.upper().strip() for t in symbols]) if s]
-    px = fetch_prices_monthly(base + [MARKET_TICKER], years)
-    ok = [s for s in base if s in px.columns]
-    if MARKET_TICKER not in px.columns:
-        return []
-    return ok
-
-# -------------- aligned moments --------------
-def get_aligned_monthly_returns(symbols: List[str], years: int) -> pd.DataFrame:
-    uniq = [c for c in dict.fromkeys(symbols) if c != MARKET_TICKER]
-    tickers = uniq + [MARKET_TICKER]
-    px = fetch_prices_monthly(tickers, years)
-    rets = monthly_returns(px)
-    cols = [c for c in uniq if c in rets.columns] + ([MARKET_TICKER] if MARKET_TICKER in rets.columns else [])
-    R = rets[cols].dropna(how="any")
-    return R.loc[:, ~R.columns.duplicated()]
-
-def estimate_all_moments_aligned(symbols: List[str], years: int, rf_ann: float):
-    R = get_aligned_monthly_returns(symbols, years)
-    if MARKET_TICKER not in R.columns or len(R) < 3:
-        raise ValueError("Not enough aligned data with market proxy.")
-    rf_m = rf_ann / 12.0
-
-    m = R[MARKET_TICKER]
-    if isinstance(m, pd.DataFrame):
-        m = m.iloc[:, 0].squeeze()
-
-    mu_m_ann = float(m.mean() * 12.0)
-    sigma_m_ann = float(m.std(ddof=1) * math.sqrt(12.0))
-    erp_ann = float(mu_m_ann - rf_ann)
-
-    ex_m = m - rf_m
-    var_m = float(np.var(ex_m.values, ddof=1))
-    var_m = max(var_m, 1e-9)
-
-    betas: Dict[str, float] = {}
-    for s in [c for c in R.columns if c != MARKET_TICKER]:
-        ex_s = R[s] - rf_m
-        cov_sm = float(np.cov(ex_s.values, ex_m.values, ddof=1)[0, 1])
-        betas[s] = cov_sm / var_m
-
-    betas[MARKET_TICKER] = 1.0
-
-    asset_cols = [c for c in R.columns if c != MARKET_TICKER]
-    cov_m = np.cov(R[asset_cols].values.T, ddof=1) if asset_cols else np.zeros((0, 0))
-    covA = pd.DataFrame(cov_m * 12.0, index=asset_cols, columns=asset_cols)
-
-    return {"betas": betas, "cov_ann": covA, "erp_ann": erp_ann, "sigma_m_ann": sigma_m_ann}
-
-def capm_er(beta: float, rf_ann: float, erp_ann: float) -> float:
-    return float(rf_ann + beta * erp_ann)
-
-def portfolio_stats(weights: Dict[str, float],
-                    cov_ann: pd.DataFrame,
-                    betas: Dict[str, float],
-                    rf_ann: float,
-                    erp_ann: float) -> Tuple[float, float, float]:
-    tickers = list(weights.keys())
-    w = np.array([weights[t] for t in tickers], dtype=float)
-    gross = float(np.sum(np.abs(w)))
-    if gross <= 1e-12:
-        return 0.0, rf_ann, 0.0
-    w_expo = w / gross
-    beta_p = float(np.dot([betas.get(t, 0.0) for t in tickers], w_expo))
-    mu_capm = capm_er(beta_p, rf_ann, erp_ann)
-    cov = cov_ann.reindex(index=tickers, columns=tickers).fillna(0.0).to_numpy()
-    sigma_hist = float(max(w_expo.T @ cov @ w_expo, 0.0)) ** 0.5
-    return beta_p, mu_capm, sigma_hist  # <-- X uses HIST sigma
-
-def efficient_same_sigma(sigma_target: float, rf_ann: float, erp_ann: float, sigma_mkt: float):
-    if sigma_mkt <= 1e-12:
-        return 0.0, 1.0, rf_ann
-    a = sigma_target / sigma_mkt
-    return a, 1.0 - a, rf_ann + a * erp_ann
-
-def efficient_same_return(mu_target: float, rf_ann: float, erp_ann: float, sigma_mkt: float):
-    if abs(erp_ann) <= 1e-12:
-        return 0.0, 1.0, rf_ann
-    a = (mu_target - rf_ann) / erp_ann
-    return a, 1.0 - a, abs(a) * sigma_mkt
-
-# -------------- plotting (CAPM on CML) --------------
-def _pct(x):
-    return np.asarray(x, dtype=float) * 100.0
-
-def plot_cml(
-    rf_ann, erp_ann, sigma_mkt,
-    sigma_hist, mu_capm,
-    mu_same_sigma, sigma_same_mu,
-    sugg_mu=None, sugg_sigma=None
-) -> Image.Image:
-    fig = plt.figure(figsize=(6, 4), dpi=120)
-
-    xmax = max(0.3, sigma_mkt * 2.2, (sigma_hist or 0.0) * 1.6, (sugg_sigma or 0.0) * 1.6)
-    xs = np.linspace(0, xmax, 200)
-    cml = rf_ann + (erp_ann / max(sigma_mkt, 1e-9)) * xs
-
-    plt.plot(_pct(xs), _pct(cml), label="CML via Market", linewidth=1.8)
-    plt.scatter([_pct(0)], [_pct(rf_ann)], label="Risk-free")
-    plt.scatter([_pct(sigma_mkt)], [_pct(rf_ann + erp_ann)], label="Market")
-
-    # YOUR point: X = historical sigma, Y = CAPM expected return
-    plt.scatter([_pct(sigma_hist)], [_pct(mu_capm)], label="Your CAPM point", marker="o")
-
-    # Efficient references on CML
-    plt.scatter([_pct(sigma_hist)], [_pct(mu_same_sigma)], label="Efficient: same σ", marker="^")
-    plt.scatter([_pct(sigma_same_mu)], [_pct(mu_capm)], label="Efficient: same E[r]", marker="v")
-
-    if sugg_mu is not None and sugg_sigma is not None:
-        plt.scatter([_pct(sugg_sigma)], [_pct(sugg_mu)], label="Selected Suggestion", marker="X", s=60)
-
-    plt.xlabel("σ (annualized, %)")
-    plt.ylabel("Expected return (annual, %)")
-    plt.legend(loc="best")
-    plt.tight_layout()
-
-    buf = io.BytesIO()
-    plt.savefig(buf, format="png")
-    plt.close(fig)
-    buf.seek(0)
-    return Image.open(buf)
-
-# -------------- synthetic dataset --------------
-def build_synthetic_dataset(universe: List[str],
-                            covA: pd.DataFrame,
-                            betas: Dict[str, float],
-                            rf_ann: float,
-                            erp_ann: float,
-                            sigma_mkt: float,
-                            n_rows: int = SYNTH_ROWS) -> pd.DataFrame:
-    rng = np.random.default_rng(12345)
-    assets = [t for t in universe if t != MARKET_TICKER]
-    if not assets:
-        assets = [MARKET_TICKER]
-
-    rows = []
-    for _ in range(n_rows):
-        k = int(rng.integers(low=2, high=min(8, len(universe)) + 1))
-        picks = list(rng.choice(universe, size=k, replace=False))
-        w = rng.dirichlet(np.ones(k))
-        beta_p = float(np.dot([betas.get(t, 0.0) for t in picks], w))
-        mu_capm = capm_er(beta_p, rf_ann, erp_ann)
-        sub = covA.reindex(index=picks, columns=picks).fillna(0.0).to_numpy()
-        sigma_hist = float(max(w.T @ sub @ w, 0.0)) ** 0.5
-        sigma_capm = abs(beta_p) * sigma_mkt
-
-        rows.append({
-            "tickers": ",".join(picks),
-            "weights": ",".join(f"{x:.6f}" for x in w),
-            "beta": beta_p,
-            "mu_capm": mu_capm,
-            "sigma_hist": sigma_hist,
-            "sigma_capm": sigma_capm
-        })
-    return pd.DataFrame(rows)
-
-def _band_bounds(sigma_mkt: float, band: str) -> Tuple[float, float]:
-    band = (band or "Medium").strip().lower()
-    if band.startswith("low"):
-        return 0.0, 0.8 * sigma_mkt
-    if band.startswith("high"):
-        return 1.2 * sigma_mkt, 3.0 * sigma_mkt
-    return 0.8 * sigma_mkt, 1.2 * sigma_mkt
-
-def top3_by_return_in_band(df: pd.DataFrame, band: str, sigma_mkt: float) -> pd.DataFrame:
-    lo, hi = _band_bounds(sigma_mkt, band)
-    pick = df[(df["sigma_capm"] >= lo) & (df["sigma_capm"] <= hi)].copy()
-    if pick.empty:
-        pick = df.copy()
-    pick = pick.sort_values("mu_capm", ascending=False).head(3).reset_index(drop=True)
-    pick.insert(0, "pick", [1, 2, 3][: len(pick)])
-    return pick
-
-# -------------- optional: embeddings rerank --------------
-def rerank_with_embeddings(top3: pd.DataFrame, band: str) -> pd.DataFrame:
-    try:
-        from sentence_transformers import SentenceTransformer
-        model = SentenceTransformer("FinLang/finance-embeddings-investopedia")
-        prompt = {
-            "low": "low risk conservative portfolio stable diversified market exposure",
-            "medium": "balanced medium risk diversified portfolio",
-            "high": "high risk growth aggressive portfolio higher expected return"
-        }[(band or "medium").lower() if (band or "medium").lower() in {"low","medium","high"} else "medium"]
-
-        cand_texts = []
-        for _, r in top3.iterrows():
-            cand_texts.append(
-                f"portfolio with tickers {r['tickers']} having beta {float(r['beta']):.2f}, "
-                f"expected return {float(r['mu_capm']):.3f}, sigma {float(r['sigma_capm']):.3f}"
-            )
-
-        q = model.encode([prompt])
-        c = model.encode(cand_texts)
-        sims = (q @ c.T) / (np.linalg.norm(q) * np.linalg.norm(c, axis=1, keepdims=False))
-        order = np.argsort(-sims.ravel())
-        return top3.iloc[order].reset_index(drop=True)
-    except Exception:
-        return top3
-
-# -------------- UI helpers --------------
-def empty_positions_df():
-    return pd.DataFrame(columns=["ticker", "amount_usd", "weight_exposure", "beta"])
-
-def empty_suggestion_df():
-    return pd.DataFrame(columns=["ticker", "weight_%", "amount_$"])
-
-def set_horizon(years: float):
-    y = max(1.0, min(100.0, float(years)))
-    code = fred_series_for_horizon(y)
-    rf = fetch_fred_yield_annual(code)
-    global HORIZON_YEARS, RF_CODE, RF_ANN
-    HORIZON_YEARS = y
-    RF_CODE = code
-    RF_ANN = rf
-    return f"Risk-free series {code}. Latest annual rate {rf:.2%}."
-
-def search_tickers_cb(q: str):
-    opts = yahoo_search(q)
-    note = "Select a symbol and click 'Add selected to portfolio'." if opts else "No matches."
-    return note, gr.update(choices=opts, value=None)
-
-def add_symbol(selection: str, table: Optional[pd.DataFrame]):
-    if not selection:
-        return table if isinstance(table, pd.DataFrame) else pd.DataFrame(columns=["ticker","amount_usd"]), "Pick a row in Matches first."
-    symbol = selection.split("|")[0].strip().upper()
-
-    current = []
-    if isinstance(table, pd.DataFrame) and not table.empty:
-        current = [str(x).upper() for x in table["ticker"].tolist() if str(x) != "nan"]
-    tickers = current if symbol in current else current + [symbol]
-
-    val = validate_tickers(tickers, years=DEFAULT_LOOKBACK_YEARS)
-    tickers = [t for t in tickers if t in val]
-
-    amt_map = {}
-    if isinstance(table, pd.DataFrame) and not table.empty:
-        for _, r in table.iterrows():
-            t = str(r.get("ticker", "")).upper()
-            if t in tickers:
-                amt_map[t] = float(pd.to_numeric(r.get("amount_usd", 0.0), errors="coerce") or 0.0)
-
-    new_table = pd.DataFrame({"ticker": tickers, "amount_usd": [amt_map.get(t, 0.0) for t in tickers]})
-    if len(new_table) > MAX_TICKERS:
-        new_table = new_table.iloc[:MAX_TICKERS]
-        return new_table, f"Reached max of {MAX_TICKERS}."
-    return new_table, f"Added {symbol}."
-
-def lock_ticker_column(tb: Optional[pd.DataFrame]):
-    if not isinstance(tb, pd.DataFrame) or tb.empty:
-        return pd.DataFrame(columns=["ticker", "amount_usd"])
-    tickers = [str(x).upper() for x in tb["ticker"].tolist()]
-    amounts = pd.to_numeric(tb["amount_usd"], errors="coerce").fillna(0.0).tolist()
-    val = validate_tickers(tickers, years=DEFAULT_LOOKBACK_YEARS)
-    tickers = [t for t in tickers if t in val]
-    amounts = amounts[:len(tickers)] + [0.0] * max(0, len(tickers) - len(amounts))
-    return pd.DataFrame({"ticker": tickers, "amount_usd": amounts})
-
-# -------------- main compute --------------
-UNIVERSE: List[str] = [MARKET_TICKER, "QQQ", "VTI", "SOXX", "IBIT"]
-
-def compute(
-    years_lookback: int,
-    table: Optional[pd.DataFrame],
-    risk_band: str,
-    use_embeddings: bool,
-    pick_idx: int
-):
-    print("Compute: start")
-    # sanitize table
-    if isinstance(table, pd.DataFrame):
-        df = table.copy()
-    else:
-        df = pd.DataFrame(columns=["ticker", "amount_usd"])
-    df = df.dropna(how="all")
-    if "ticker" not in df.columns: df["ticker"] = []
-    if "amount_usd" not in df.columns: df["amount_usd"] = []
-    df["ticker"] = df["ticker"].astype(str).str.upper().str.strip()
-    df["amount_usd"] = pd.to_numeric(df["amount_usd"], errors="coerce").fillna(0.0)
-
-    symbols = [t for t in df["ticker"].tolist() if t]
-    if len(symbols) == 0:
-        return None, "Add at least one ticker.", "Universe empty.", empty_positions_df(), empty_suggestion_df(), None, gr.update()
-
-    symbols = validate_tickers(symbols, years_lookback)
-    print("Compute: validated", symbols)
-    if len(symbols) == 0:
-        return None, "Could not validate any tickers.", "Universe invalid.", empty_positions_df(), empty_suggestion_df(), None, gr.update()
-
-    global UNIVERSE
-    UNIVERSE = list(sorted(set([s for s in symbols if s != MARKET_TICKER] + [MARKET_TICKER])))[:MAX_TICKERS]
-
-    df = df[df["ticker"].isin(symbols)].copy()
-    amounts = {r["ticker"]: float(r["amount_usd"]) for _, r in df.iterrows()}
-    rf_ann = RF_ANN
-
-    # Moments
-    moms = estimate_all_moments_aligned(symbols, years_lookback, rf_ann)
-    betas, covA, erp_ann, sigma_mkt = moms["betas"], moms["cov_ann"], moms["erp_ann"], moms["sigma_m_ann"]
-    print("Compute: moments ok; sigma_mkt=", sigma_mkt, "erp=", erp_ann)
-
-    # Weights
-    gross = sum(abs(v) for v in amounts.values())
-    if gross <= 1e-12:
-        return None, "All amounts are zero.", "Universe ok.", empty_positions_df(), empty_suggestion_df(), None, gr.update()
-    weights = {k: v / gross for k, v in amounts.items()}
-
-    # Portfolio stats (X uses historical sigma; Y uses CAPM E[r])
-    beta_p, mu_capm, sigma_hist = portfolio_stats(weights, covA, betas, rf_ann, erp_ann)
-    sigma_capm = abs(beta_p) * sigma_mkt
-
-    # Efficient alternatives (on CML)
-    a_sigma, b_sigma, mu_eff_sigma = efficient_same_sigma(sigma_hist, rf_ann, erp_ann, sigma_mkt)
-    a_mu, b_mu, sigma_eff_mu = efficient_same_return(mu_capm, rf_ann, erp_ann, sigma_mkt)
-
-    # Synthetic dataset & suggestions
-    synth = build_synthetic_dataset(UNIVERSE, covA, betas, rf_ann, erp_ann, sigma_mkt, n_rows=SYNTH_ROWS)
-    csv_path = os.path.join(DATA_DIR, f"investor_profiles_{int(time.time())}.csv")
-    synth.to_csv(csv_path, index=False)
-
-    top3 = top3_by_return_in_band(synth, risk_band, sigma_mkt)
-    if use_embeddings:
-        top3 = rerank_with_embeddings(top3, risk_band)
-    if top3.empty:
-        top3 = synth.sort_values("mu_capm", ascending=False).head(3).reset_index(drop=True)
-        top3.insert(0, "pick", [1, 2, 3][: len(top3)])
-
-    idx = max(1, min(3, int(pick_idx))) - 1
-    row = top3.iloc[idx]
-
-    sugg_mu = float(row["mu_capm"])
-    sugg_sigma = float(row["sigma_capm"])
-
-    # suggestion holdings (% and $)
-    ts = [t.strip() for t in str(row["tickers"]).split(",")]
-    ws = [float(x) for x in str(row["weights"]).split(",")]
-    s = sum(ws) if ws else 1.0
-    ws = [max(0.0, w) / s for w in ws]
-    budget = gross if gross > 0 else 1.0
-    sugg_table = pd.DataFrame(
-        [{"ticker": t, "weight_%": round(w*100.0, 2), "amount_$": round(w*budget, 0)} for t, w in zip(ts, ws)],
-        columns=["ticker", "weight_%", "amount_$"]
-    )
-
-    # positions table
-    pos_table = pd.DataFrame(
-        [{
-            "ticker": t,
-            "amount_usd": amounts.get(t, 0.0),
-            "weight_exposure": weights.get(t, 0.0),
-            "beta": 1.0 if t == MARKET_TICKER else betas.get(t, np.nan)
-        } for t in symbols],
-        columns=["ticker", "amount_usd", "weight_exposure", "beta"]
-    )
-
-    # plot (CAPM on CML; your point uses sigma_hist on X)
-    img = plot_cml(
-        rf_ann, erp_ann, sigma_mkt,
-        sigma_hist, mu_capm,
-        mu_same_sigma=mu_eff_sigma, sigma_same_mu=sigma_eff_mu,
-        sugg_mu=sugg_mu, sugg_sigma=sugg_sigma
-    )
-
-    info = "\n".join([
-        "### Inputs",
-        f"- Lookback years {years_lookback}",
-        f"- Horizon years {int(round(HORIZON_YEARS))}",
-        f"- Risk-free {rf_ann:.2%} from {RF_CODE}",
-        f"- Market ERP {erp_ann:.2%}",
-        f"- Market σ {sigma_mkt:.2%}",
-        "",
-        "### Your portfolio (CAPM on CML axes)",
-        f"- Beta {beta_p:.2f}",
-        f"- Expected return (CAPM / SML) {mu_capm:.2%}",
-        f"- σ (historical) {sigma_hist:.2%}",
-        f"- σ on CML for same β (|β|×σ_mkt) {sigma_capm:.2%}",
-        "",
-        "### Efficient alternatives on CML",
-        f"- Same σ as your portfolio (historical): Market weight {a_sigma:.2f}, Bills weight {b_sigma:.2f}, return {mu_eff_sigma:.2%}",
-        f"- Same return (CAPM): Market weight {a_mu:.2f}, Bills weight {b_mu:.2f}, σ {sigma_eff_mu:.2%}",
-        "",
-        "### Dataset-based suggestions (risk: " + risk_band + ")",
-        f"- Showing Pick **#{idx+1}** → CAPM return {sugg_mu:.2%}, CAPM σ {sugg_sigma:.2%}",
-        "",
-        "_Plot shows CAPM E[r] vs σ; your point uses historical σ; efficient references are market/bills on the CML._"
-    ])
-
-    uni_msg = f"Universe set to: {', '.join(UNIVERSE)}"
-    print("Compute: done")
-    return img, info, uni_msg, pos_table, sugg_table, csv_path, gr.update(label=f"Pick #{idx+1} of 3")
-
-# -------------- UI --------------
-def inc_pick(i: int): return min(3, max(1, int(i or 1) + 1))
-def dec_pick(i: int): return max(1, min(3, int(i or 1) - 1))
-
-with gr.Blocks(title="Efficient Portfolio Advisor", analytics_enabled=False) as demo:
-    gr.Markdown(
-        "## Efficient Portfolio Advisor\n"
-        "Search symbols, enter **dollar amounts**, set horizon. Returns use Yahoo Finance monthly data; risk-free from FRED. "
-        "Plot shows **CAPM point (E[r]) vs historical σ** plus efficient CML points."
-    )
-
-    with gr.Row():
-        with gr.Column(scale=1):
-            q = gr.Textbox(label="Search symbol")
-            search_note = gr.Markdown()
-            matches = gr.Dropdown(choices=[], label="Matches")
-            search_btn = gr.Button("Search")
-            add_btn = gr.Button("Add selected to portfolio")
-
-            gr.Markdown("### Portfolio positions (enter $ amounts; negatives allowed for shorts)")
-            table = gr.Dataframe(
-                headers=["ticker", "amount_usd"],
-                datatype=["str", "number"],
-                type="pandas",
-                row_count=0,
-                col_count=(2, "fixed")
-            )
-
-            horizon = gr.Number(label="Horizon in years (1–100)", value=HORIZON_YEARS, precision=0)
-            lookback = gr.Slider(1, 15, value=DEFAULT_LOOKBACK_YEARS, step=1, label="Lookback years for betas & covariances")
-
-            gr.Markdown("### Suggestions")
-            risk_band = gr.Radio(["Low", "Medium", "High"], value="Medium", label="Risk tolerance")
-            use_emb = gr.Checkbox(value=True, label="Use finance embeddings to refine picks")
-
-            with gr.Row():
-                prev_btn = gr.Button("◀ Prev")
-                pick_idx = gr.Number(value=1, precision=0, label="Carousel")
-                next_btn = gr.Button("Next ▶")
-
-            run_btn = gr.Button("Compute (build dataset & suggest)")
-        with gr.Column(scale=1):
-            plot = gr.Image(label="Capital Market Line (CAPM)", type="pil")
-            summary = gr.Markdown(label="Inputs & Results")
-            universe_msg = gr.Textbox(label="Universe status", interactive=False)
-            positions = gr.Dataframe(
-                label="Computed positions",
-                headers=["ticker", "amount_usd", "weight_exposure", "beta"],
-                datatype=["str", "number", "number", "number"],
-                type="pandas",
-                col_count=(4, "fixed"),
-                value=empty_positions_df(),
-                interactive=False
-            )
-            sugg_table = gr.Dataframe(
-                label="Selected suggestion (carousel) — holdings shown in % and $",
-                headers=["ticker", "weight_%", "amount_$"],
-                datatype=["str", "number", "number"],
-                type="pandas",
-                col_count=(3, "fixed"),
-                value=empty_suggestion_df(),
-                interactive=False
-            )
-            dl = gr.File(label="Generated dataset CSV", value=None, visible=True)
-
-    # wire search / add / locking / horizon
-    search_btn.click(fn=search_tickers_cb, inputs=q, outputs=[search_note, matches])
-    add_btn.click(fn=add_symbol, inputs=[matches, table], outputs=[table, search_note])
-    table.change(fn=lock_ticker_column, inputs=table, outputs=table)
-    horizon.change(fn=set_horizon, inputs=horizon, outputs=universe_msg)
-
-    # carousel buttons update pick index and then recompute
-    prev_btn.click(fn=dec_pick, inputs=pick_idx, outputs=pick_idx).then(
-        fn=compute,
-        inputs=[lookback, table, risk_band, use_emb, pick_idx],
-        outputs=[plot, summary, universe_msg, positions, sugg_table, dl, pick_idx]
-    )
-    next_btn.click(fn=inc_pick, inputs=pick_idx, outputs=pick_idx).then(
-        fn=compute,
-        inputs=[lookback, table, risk_band, use_emb, pick_idx],
-        outputs=[plot, summary, universe_msg, positions, sugg_table, dl, pick_idx]
-    )
-
-    # main compute
-    run_btn.click(
-        fn=compute,
-        inputs=[lookback, table, risk_band, use_emb, pick_idx],
-        outputs=[plot, summary, universe_msg, positions, sugg_table, dl, pick_idx]
-    )
-
-# initialize risk-free at launch
-RF_CODE = fred_series_for_horizon(HORIZON_YEARS)
-RF_ANN = fetch_fred_yield_annual(RF_CODE)
-
-if __name__ == "__main__":
-    # IMPORTANT for Spaces/Docker: bind to 0.0.0.0 and the correct PORT
-    demo.queue(concurrency_count=8).launch(
-        server_name="0.0.0.0",
-        server_port=int(os.environ.get("PORT", "7860")),
-        show_error=True,
-        share=False
-    )
+FROM python:3.10-slim-bullseye
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1 \
+    PATH="/home/user/.local/bin:${PATH}" \
+    MPLCONFIGDIR="/home/user/.config/matplotlib" \
+    HF_HOME="/home/user/.cache/huggingface" \
+    SENTENCE_TRANSFORMERS_HOME="/home/user/.cache/sentencetransformers" \
+    GRADIO_SERVER_NAME="0.0.0.0" \
+    GRADIO_SERVER_PORT="7860"
+
+# System deps for plotting, ffmpeg, etc.
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    git git-lfs ffmpeg \
+    libglib2.0-0 libsm6 libxext6 libxrender1 libgl1 \
+    fonts-dejavu-core \
+ && rm -rf /var/lib/apt/lists/* \
+ && git lfs install
+
+# Non-root user so pip installs land in /home/user/.local
+RUN useradd -m -u 1000 user
+USER user
+WORKDIR /home/user/app
+
+# Pre-create writable caches
+RUN mkdir -p /home/user/.config/matplotlib \
+             /home/user/.cache/huggingface/hub \
+             /home/user/.cache/sentencetransformers \
+             /home/user/.cache/pip
+
+COPY --chown=user:user requirements.txt ./requirements.txt
+RUN python -m pip install --upgrade pip && pip install --no-cache-dir -r requirements.txt
+
+COPY --chown=user:user . .
+
+EXPOSE 7860
+CMD ["python", "app.py"]