Update app.py

app.py

@@ -1,6 +1,12 @@
-import os, io, math, json, traceback, warnings
+import os, io, math, json, warnings
 warnings.filterwarnings("ignore")
 
+# --- make caches writable BEFORE importing matplotlib / transformers ---
+os.environ.setdefault("MPLCONFIGDIR", "/home/user/.config/matplotlib")
+os.environ.setdefault("HF_HOME", "/home/user/.cache/huggingface")
+os.environ.setdefault("SENTENCE_TRANSFORMERS_HOME", "/home/user/.cache/sentencetransformers")
+os.environ.setdefault("GRADIO_ANALYTICS_ENABLED", "false")
+
 from typing import List, Tuple, Dict, Optional
 
 import numpy as np
@@ -12,6 +18,8 @@ import requests
 import yfinance as yf
 
 from sentence_transformers import SentenceTransformer, util as st_util
+from sklearn.preprocessing import StandardScaler
+from sklearn.neighbors import KNeighborsRegressor
 
 # =========================
 # Config
@@ -30,12 +38,10 @@ POS_COLS  = ["ticker", "amount_usd", "weight_exposure", "beta"]
 SUG_COLS  = ["ticker", "weight_%", "amount_$"]
 EFF_COLS  = ["asset", "weight_%", "amount_$"]
 
-N_SYNTH    = 1000            # synthetic dataset size
-MMR_K      = 40              # shortlist size before MMR
+N_SYNTH   = 1000             # size of synthetic dataset per run
+MMR_K     = 40               # shortlist size before MMR
 MMR_LAMBDA = 0.65            # similarity vs diversity tradeoff
 
-DEBUG = True  # if True, surface tracebacks in the UI summary when something fails
-
 # ---------------- FRED mapping (risk-free source) ----------------
 FRED_MAP = [
     (1,  "DGS1"),
@@ -46,7 +52,7 @@ FRED_MAP = [
     (10, "DGS10"),
     (20, "DGS20"),
     (30, "DGS30"),
-    (100,"DGS30"),
+    (100, "DGS30"),
 ]
 
 def fred_series_for_horizon(years: float) -> str:
@@ -57,6 +63,7 @@ def fred_series_for_horizon(years: float) -> str:
     return "DGS30"
 
 def fetch_fred_yield_annual(code: str) -> float:
+    # FRED CSV endpoint (no API key required). Fallback to 3% if it fails.
     url = f"https://fred.stlouisfed.org/graph/fredgraph.csv?id={code}"
     try:
         r = requests.get(url, timeout=10)
@@ -70,88 +77,61 @@ def fetch_fred_yield_annual(code: str) -> float:
 # =========================
 # Data helpers
 # =========================
-def _to_cols_close(df: pd.DataFrame, tickers: List[str]) -> pd.DataFrame:
-    """
-    Coerce yfinance download to single-level columns of closes/adj closes.
-    Handles Series, single-level, and MultiIndex frames safely.
-    """
+def _to_cols_close(df: pd.DataFrame) -> pd.DataFrame:
+    """Coerce yfinance download to a single-level columns DataFrame of adjusted closes."""
     if df is None or df.empty:
         return pd.DataFrame()
-
-    # If Series (one ticker)
     if isinstance(df, pd.Series):
         df = df.to_frame("Close")
-
-    # MultiIndex columns: (ticker, field)
     if isinstance(df.columns, pd.MultiIndex):
+        level0 = df.columns.get_level_values(0).unique().tolist()
         fields = df.columns.get_level_values(1).unique().tolist()
         field = "Adj Close" if "Adj Close" in fields else ("Close" if "Close" in fields else fields[0])
         out = {}
-        for t in dict.fromkeys(tickers):
+        for t in level0:
             col = (t, field)
             if col in df.columns:
-                out[t] = pd.to_numeric(df[col], errors="coerce")
-        return pd.DataFrame(out)
-
-    # Single-level columns: try common names
-    if "Adj Close" in df.columns:
-        col = pd.to_numeric(df["Adj Close"], errors="coerce")
-        col.name = tickers[0] if tickers else "SINGLE"
-        return col.to_frame()
-    if "Close" in df.columns:
-        col = pd.to_numeric(df["Close"], errors="coerce")
-        col.name = tickers[0] if tickers else "SINGLE"
-        return col.to_frame()
-
-    # Fallback to first numeric column
-    num_cols = [c for c in df.columns if pd.api.types.is_numeric_dtype(df[c])]
-    if num_cols:
-        col = pd.to_numeric(df[num_cols[0]], errors="coerce")
-        col.name = tickers[0] if tickers else "SINGLE"
-        return col.to_frame()
-
-    return pd.DataFrame()
-
-def fetch_prices_monthly(tickers: List[str], years: int) -> pd.DataFrame:
-    tickers = [t for t in dict.fromkeys(tickers) if t]
-    if not tickers:
+                out[t] = df[col]
+        out_df = pd.DataFrame(out)
+        return out_df
+    else:
+        if "Adj Close" in df.columns:
+            return df[["Adj Close"]].rename(columns={"Adj Close": "SINGLE"})
+        if "Close" in df.columns:
+            return df[["Close"]].rename(columns={"Close": "SINGLE"})
+        num_cols = [c for c in df.columns if pd.api.types.is_numeric_dtype(df[c])]
+        if num_cols:
+            return df[[num_cols[0]]].rename(columns={num_cols[0]: "SINGLE"})
         return pd.DataFrame()
 
+def fetch_prices_monthly(tickers: List[str], years: int) -> pd.DataFrame:
     start = (pd.Timestamp.today(tz="UTC") - pd.DateOffset(years=int(years), days=7)).date()
     end   = pd.Timestamp.today(tz="UTC").date()
-
     df_raw = yf.download(
-        tickers, start=start, end=end,
+        list(dict.fromkeys(tickers)),
+        start=start, end=end,
         interval="1mo", auto_adjust=True, progress=False, group_by="ticker",
         threads=True,
     )
-    df = _to_cols_close(df_raw, tickers)
+    df = _to_cols_close(df_raw).copy()
     if df.empty:
         return df
-    df = df.dropna(how="all").fillna(method="ffill")
-    # Keep only requested columns if present
-    keep = [t for t in tickers if t in df.columns]
-    if not keep and df.shape[1] == 1:
-        # Single column; rename if needed
+    if df.shape[1] == 1 and "SINGLE" in df.columns:
         df.columns = [tickers[0]]
-        keep = [tickers[0]]
-    return df[keep] if keep else pd.DataFrame()
+    df = df.dropna(how="all").fillna(method="ffill")
+    return df
 
 def monthly_returns(prices: pd.DataFrame) -> pd.DataFrame:
-    if prices is None or prices.empty:
-        return pd.DataFrame()
-    return prices.pct_change().dropna(how="all")
+    return prices.pct_change().dropna()
 
 def validate_tickers(symbols: List[str], years: int) -> List[str]:
-    """Return subset of symbols that have monthly data."""
     symbols = [s.strip().upper() for s in symbols if s and isinstance(s, str)]
-    if not symbols:
-        return []
     base = [s for s in symbols if s != MARKET_TICKER]
     px = fetch_prices_monthly(base + [MARKET_TICKER], years)
-    if px.empty:
-        return [s for s in symbols if s == MARKET_TICKER]  # maybe only market survives
-    ok = [s for s in symbols if s in px.columns]
+    ok = []
+    for s in symbols:
+        if s in px.columns:
+            ok.append(s)
     return ok
 
 # =========================
@@ -166,15 +146,13 @@ def get_aligned_monthly_returns(symbols: List[str], years: int) -> pd.DataFrame:
         uniq.append(MARKET_TICKER)
     px = fetch_prices_monthly(uniq, years)
     rets = monthly_returns(px)
-    if rets.empty:
-        return pd.DataFrame()
     cols = [c for c in uniq if c in rets.columns]
     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 + [MARKET_TICKER], years)
-    if R.empty or MARKET_TICKER not in R.columns or R.shape[0] < 3:
+    if MARKET_TICKER not in R.columns or R.shape[0] < 3:
         raise ValueError("Not enough aligned data to estimate moments.")
     rf_m = rf_ann / 12.0
 
@@ -195,7 +173,8 @@ def estimate_all_moments_aligned(symbols: List[str], years: int, rf_ann: float):
         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
+
+    betas[MARKET_TICKER] = 1.0  # by definition
 
     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))
@@ -212,8 +191,6 @@ def portfolio_stats(weights: Dict[str, float],
                     rf_ann: float,
                     erp_ann: float) -> Tuple[float, float, float]:
     tickers = list(weights.keys())
-    if not tickers:
-        return 0.0, rf_ann, 0.0
     w = np.array([weights[t] for t in tickers], dtype=float)
     gross = float(np.sum(np.abs(w)))
     if gross <= 1e-12:
@@ -244,15 +221,25 @@ def efficient_same_return(mu_target: float, rf_ann: float, erp_ann: float, sigma
 # Plot
 # =========================
 def _pct_arr(x):
-    return np.asarray(x, dtype=float) * 100.0
-
-def plot_cml(rf_ann, erp_ann, sigma_mkt,
-             pt_sigma_hist, pt_mu_capm,
-             same_sigma_sigma, same_sigma_mu,
-             same_mu_sigma, same_mu_mu) -> Image.Image:
+    x = np.asarray(x, dtype=float)
+    return x * 100.0
+
+def plot_cml(
+    rf_ann, erp_ann, sigma_mkt,
+    pt_sigma_hist, pt_mu_capm,
+    same_sigma_sigma, same_sigma_mu,
+    same_mu_sigma, same_mu_mu,
+) -> Image.Image:
     fig = plt.figure(figsize=(6.6, 4.4), dpi=130)
 
-    xmax = max(0.3, sigma_mkt * 2.0, pt_sigma_hist * 1.4, same_mu_sigma * 1.4, same_sigma_sigma * 1.4)
+    xmax = max(
+        0.3,
+        sigma_mkt * 2.0,
+        pt_sigma_hist * 1.4,
+        same_mu_sigma * 1.4,
+        same_sigma_sigma * 1.4,
+    )
+
     xs = np.linspace(0, xmax, 160)
     slope = erp_ann / max(sigma_mkt, 1e-12)
     cml = rf_ann + slope * xs
@@ -260,11 +247,12 @@ def plot_cml(rf_ann, erp_ann, sigma_mkt,
     plt.plot(_pct_arr(xs), _pct_arr(cml), label="CML via VOO", linewidth=1.8)
     plt.scatter([0.0], [_pct_arr(rf_ann)], label="Risk-free", zorder=5)
     plt.scatter([_pct_arr(sigma_mkt)], [_pct_arr(rf_ann + erp_ann)], label="Market (VOO)", zorder=5)
+
     plt.scatter([_pct_arr(pt_sigma_hist)], [_pct_arr(pt_mu_capm)], label="Your portfolio (CAPM)", zorder=6)
+
     plt.scatter([_pct_arr(same_sigma_sigma)], [_pct_arr(same_sigma_mu)], label="Efficient: same σ", zorder=5)
-    plt.scatter([_pct_arr(same_mu_sigma)], [_pct_arr(same_mu_mu)], label="Efficient: same μ", zorder=5)
+    plt.scatter([_pct_arr(same_mu_sigma)],    [_pct_arr(same_mu_mu)], label="Efficient: same μ", zorder=5)
 
-    # Guides
     plt.plot([_pct_arr(pt_sigma_hist), _pct_arr(same_sigma_sigma)],
              [_pct_arr(pt_mu_capm),    _pct_arr(same_sigma_mu)],
              ls="--", lw=1.1, alpha=0.7, color="gray")
@@ -301,12 +289,10 @@ def build_synth_dataset(universe: List[str],
     rng = np.random.default_rng(seed)
     U = [u for u in universe if u != MARKET_TICKER] + [MARKET_TICKER]
     rows = []
-    if not U:
-        return pd.DataFrame()
     for i in range(n_rows):
-        k = int(rng.integers(low=max(1, min(2, len(U))), high=min(8, len(U)) + 1))
+        k = rng.integers(low=min(2, len(U)), high=min(8, len(U)) + 1)
         picks = list(rng.choice(U, size=k, replace=False))
-        w = dirichlet_signed(k, rng)
+        w = dirichlet_signed(k, rng)  # exposure weights (can include short)
         gross = float(np.sum(np.abs(w)))
         if gross <= 1e-12:
             continue
@@ -321,7 +307,8 @@ def build_synth_dataset(universe: List[str],
             "er_capm": float(er_capm_i),
             "sigma": float(sigma_i),
         })
-    return pd.DataFrame(rows)
+    df = pd.DataFrame(rows)
+    return df
 
 # =========================
 # Embeddings + MMR selection
@@ -345,7 +332,10 @@ def row_to_sentence(row: pd.Series) -> str:
             f"beta {row['beta']:.3f}, "
             f"exposures {pairs}")
 
-def mmr_select(query_emb, cand_embs, k: int = 3, lambda_param: float = MMR_LAMBDA) -> List[int]:
+def mmr_select(query_emb: np.ndarray,
+               cand_embs: np.ndarray,
+               k: int = 3,
+               lambda_param: float = MMR_LAMBDA) -> List[int]:
     if cand_embs.shape[0] <= k:
         return list(range(cand_embs.shape[0]))
     sim_to_query = st_util.cos_sim(query_emb, cand_embs).cpu().numpy().reshape(-1)
@@ -357,11 +347,9 @@ def mmr_select(query_emb, cand_embs, k: int = 3, lambda_param: float = MMR_LAMBD
     while len(chosen) < k and candidate_indices:
         max_score = -1e9
         max_idx = candidate_indices[0]
-        # compute diversity term against already chosen
-        chosen_stack = cand_embs[chosen]
         for idx in candidate_indices:
             sim_q = sim_to_query[idx]
-            sim_d = float(st_util.cos_sim(cand_embs[idx], chosen_stack).max().cpu().numpy())
+            sim_d = max(st_util.cos_sim(cand_embs[idx], cand_embs[chosen]).cpu().numpy().reshape(-1))
             mmr_score = lambda_param * sim_q - (1.0 - lambda_param) * sim_d
             if mmr_score > max_score:
                 max_score = mmr_score
@@ -396,22 +384,16 @@ def yahoo_search(query: str):
     except Exception:
         return [f"{query.strip().upper()}  |  typed symbol  |  n/a"]
 
-_last_matches = []
+_last_matches = []  # updated on each search
 
 # =========================
 # Formatting helpers
 # =========================
 def fmt_pct(x: float) -> str:
-    try:
-        return f"{float(x)*100:.2f}%"
-    except Exception:
-        return "n/a"
+    return f"{x*100:.2f}%"
 
 def fmt_money(x: float) -> str:
-    try:
-        return f"${float(x):,.0f}"
-    except Exception:
-        return "n/a"
+    return f"${x:,.0f}"
 
 # =========================
 # Gradio callbacks
@@ -435,7 +417,7 @@ def add_symbol(selection: str, table: pd.DataFrame):
         return table, "Pick a row from Matches first."
 
     current = []
-    if isinstance(table, pd.DataFrame) and len(table) > 0 and "ticker" in table.columns:
+    if table is not None and len(table) > 0:
         current = [str(x).upper() for x in table["ticker"].tolist() if str(x) != "nan"]
 
     tickers = current if symbol in current else current + [symbol]
@@ -445,7 +427,7 @@ def add_symbol(selection: str, table: pd.DataFrame):
     tickers = [t for t in tickers if t in val]
 
     amt_map = {}
-    if isinstance(table, pd.DataFrame) and len(table) > 0:
+    if table is not None and len(table) > 0:
         for _, r in table.iterrows():
             t = str(r.get("ticker", "")).upper()
             if t in tickers:
@@ -476,7 +458,7 @@ def set_horizon(years: float):
     HORIZON_YEARS = y
     RF_CODE = code
     RF_ANN = rf
-    return f"Risk-free series {code}. Latest annual rate {rf:.2%}. Computations will use this."
+    return f"Risk-free series {code}. Latest annual rate {rf:.2%}. Computations will use this.", rf
 
 def _table_from_weights(weights: Dict[str, float], gross_amt: float) -> pd.DataFrame:
     items = []
@@ -485,20 +467,13 @@ def _table_from_weights(weights: Dict[str, float], gross_amt: float) -> pd.DataF
         amt = float(w) * gross_amt
         items.append({"ticker": t, "weight_%": round(pct * 100.0, 2), "amount_$": round(amt, 2)})
     df = pd.DataFrame(items, columns=SUG_COLS)
-    if df.empty:
-        return pd.DataFrame(columns=SUG_COLS)
     df["absw"] = df["weight_%"].abs()
     df = df.sort_values("absw", ascending=False).drop(columns=["absw"])
     return df
 
 def _weights_dict_from_row(r: pd.Series) -> Dict[str, float]:
-    ts = [t.strip().upper() for t in str(r.get("tickers","")).split(",") if t]
-    ws = []
-    for x in str(r.get("weights","")).split(","):
-        try:
-            ws.append(float(x))
-        except Exception:
-            ws.append(0.0)
+    ts = [t.strip().upper() for t in str(r["tickers"]).split(",")]
+    ws = [float(x) for x in str(r["weights"]).split(",")]
     wmap = {}
     for i in range(min(len(ts), len(ws))):
         wmap[ts[i]] = ws[i]
@@ -512,182 +487,153 @@ def compute(lookback_years: int,
             risk_bucket: str,
             horizon_years: float):
 
-    try:
-        # --- sanitize input table
-        if table is None or len(table) == 0:
-            empty = pd.DataFrame(columns=POS_COLS)
-            emptyS = pd.DataFrame(columns=SUG_COLS)
-            emptyE = pd.DataFrame(columns=EFF_COLS)
-            return (None, "Add at least one ticker", "", empty,
-                    emptyS, emptyS, emptyS, emptyE, emptyE, "[]", 1, "No suggestions yet.")
-
-        df = table.copy().dropna(how="all")
-        if df.empty or "ticker" not in df.columns or "amount_usd" not in df.columns:
-            empty = pd.DataFrame(columns=POS_COLS)
-            emptyS = pd.DataFrame(columns=SUG_COLS)
-            emptyE = pd.DataFrame(columns=EFF_COLS)
-            return (None, "Positions table is empty or malformed.", "", empty,
-                    emptyS, emptyS, emptyS, emptyE, emptyE, "[]", 1, "No suggestions yet.")
-
-        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]
-        symbols = validate_tickers(symbols, lookback_years)
-        if len(symbols) == 0:
-            empty = pd.DataFrame(columns=POS_COLS)
-            emptyS = pd.DataFrame(columns=SUG_COLS)
-            emptyE = pd.DataFrame(columns=EFF_COLS)
-            return (None, "Could not validate any tickers", "Universe invalid",
-                    empty, emptyS, emptyS, emptyS, emptyE, emptyE, "[]", 1, "No suggestions.")
-
-        # --- universe & amounts
-        universe = sorted(set([s for s in symbols if s != MARKET_TICKER] + [MARKET_TICKER]))
-        df = df[df["ticker"].isin(symbols)].copy()
-        amounts = {r["ticker"]: float(r["amount_usd"]) for _, r in df.iterrows()}
-        gross_amt = sum(abs(v) for v in amounts.values())
-        if gross_amt <= 1e-9:
-            empty = pd.DataFrame(columns=POS_COLS)
-            emptyS = pd.DataFrame(columns=SUG_COLS)
-            emptyE = pd.DataFrame(columns=EFF_COLS)
-            return (None, "All amounts are zero", "Universe ok",
-                    empty, emptyS, emptyS, emptyS, emptyE, emptyE, "[]", 1, "No suggestions.")
-
-        weights = {k: v / gross_amt for k, v in amounts.items()}
-
-        # --- risk free & moments
-        rf_code = fred_series_for_horizon(horizon_years)
-        rf_ann  = fetch_fred_yield_annual(rf_code)
-        moms    = estimate_all_moments_aligned(universe, lookback_years, rf_ann)
-        betas, covA, erp_ann, sigma_mkt = moms["betas"], moms["cov_ann"], moms["erp_ann"], moms["sigma_m_ann"]
-
-        # --- portfolio stats (CAPM return + historical sigma)
-        beta_p, er_capm_p, sigma_p = portfolio_stats(weights, covA, betas, rf_ann, erp_ann)
-
-        # --- efficient alternatives on CML
-        a_sigma, b_sigma, mu_eff_sigma = efficient_same_sigma(sigma_p, rf_ann, erp_ann, sigma_mkt)
-        a_mu, b_mu, sigma_eff_mu       = efficient_same_return(er_capm_p, rf_ann, erp_ann, sigma_mkt)
-
-        eff_same_sigma_tbl = _table_from_weights({MARKET_TICKER: a_sigma, BILLS_TICKER: b_sigma}, gross_amt)
-        eff_same_mu_tbl    = _table_from_weights({MARKET_TICKER: a_mu,    BILLS_TICKER: b_mu},   gross_amt)
-
-        # --- build synthetic dataset (based ONLY on this universe)
-        synth = build_synth_dataset(universe, covA, betas, rf_ann, erp_ann, n_rows=N_SYNTH, seed=777)
-        if synth.empty:
-            # fall back to trivial 3 variants of (market/bills) if universe too thin
-            fallback = []
-            for a in [0.2, 0.5, 0.8]:
-                w = {MARKET_TICKER: a, BILLS_TICKER: 1-a}
-                beta_i, er_capm_i, sigma_i = portfolio_stats(w, pd.DataFrame(), {MARKET_TICKER:1.0}, rf_ann, erp_ann)
-                fallback.append({"tickers": ",".join(w.keys()),
-                                 "weights": ",".join(f"{v:.6f}" for v in w.values()),
-                                 "beta": beta_i, "er_capm": er_capm_i, "sigma": sigma_i})
-            synth = pd.DataFrame(fallback)
-
-        # --- risk buckets by sigma (absolute +/- 5% around median)
-        median_sigma = float(synth["sigma"].median())
-        low_max  = max(float(synth["sigma"].min()), median_sigma - 0.05)
-        high_min = median_sigma + 0.05
-
-        if risk_bucket == "Low":
-            cand_df = synth[synth["sigma"] <= low_max].copy()
-        elif risk_bucket == "High":
-            cand_df = synth[synth["sigma"] >= high_min].copy()
-        else:
-            cand_df = synth[(synth["sigma"] > low_max) & (synth["sigma"] < high_min)].copy()
-        if len(cand_df) == 0:
-            cand_df = synth.copy()
-
-        # --- embeddings + MMR for 3 diverse picks
-        embed = get_embedder()
-        cand_sentences = cand_df.apply(row_to_sentence, axis=1).tolist()
-        cur_pairs = ", ".join([f"{k}:{v:+.2f}" for k, v in sorted(weights.items())])
-        q_sentence = f"user portfolio ({risk_bucket} risk); capm_target {er_capm_p:.4f}; sigma_hist {sigma_p:.4f}; exposures {cur_pairs}"
-
-        cand_embs = embed.encode(cand_sentences, convert_to_tensor=True, normalize_embeddings=True, batch_size=64, show_progress_bar=False)
-        q_emb     = embed.encode([q_sentence], convert_to_tensor=True, normalize_embeddings=True)[0]
-
-        sims = st_util.cos_sim(q_emb, cand_embs)[0]
-        top_idx = sims.topk(k=min(MMR_K, len(cand_df))).indices.cpu().numpy().tolist()
-        shortlist_embs = cand_embs[top_idx]
-        mmr_local = mmr_select(q_emb, shortlist_embs, k=3, lambda_param=MMR_LAMBDA)
-        chosen = [top_idx[i] for i in mmr_local]
-        recs = cand_df.iloc[chosen].reset_index(drop=True)
-
-        # --- suggestion tables for 3 picks
-        sugg_tables = []
-        sugg_meta   = []
-        for _, r in recs.iterrows():
-            wmap = _weights_dict_from_row(r)
-            sugg_tables.append(_table_from_weights(wmap, gross_amt))
-            sugg_meta.append({"er_capm": float(r["er_capm"]), "sigma": float(r["sigma"]), "beta": float(r["beta"])})
-
-        # --- plot
-        img = plot_cml(
-            rf_ann, erp_ann, sigma_mkt,
-            sigma_p, er_capm_p,
-            same_sigma_sigma=sigma_p, same_sigma_mu=mu_eff_sigma,
-            same_mu_sigma=sigma_eff_mu, same_mu_mu=er_capm_p
-        )
+    if table is None or len(table) == 0:
+        return (None, "Add at least one ticker", "", pd.DataFrame(columns=POS_COLS),
+                pd.DataFrame(columns=SUG_COLS), pd.DataFrame(columns=SUG_COLS),
+                pd.DataFrame(columns=SUG_COLS), pd.DataFrame(columns=EFF_COLS),
+                pd.DataFrame(columns=EFF_COLS), json.dumps([]), 1, "No suggestions yet.")
+
+    df = table.copy().dropna()
+    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]
+    symbols = validate_tickers(symbols, lookback_years)
+    if len(symbols) == 0:
+        return (None, "Could not validate any tickers", "Universe invalid",
+                pd.DataFrame(columns=POS_COLS),
+                pd.DataFrame(columns=SUG_COLS), pd.DataFrame(columns=SUG_COLS),
+                pd.DataFrame(columns=SUG_COLS), pd.DataFrame(columns=EFF_COLS),
+                pd.DataFrame(columns=EFF_COLS), json.dumps([]), 1, "No suggestions.")
+
+    universe = sorted(set([s for s in symbols if s != MARKET_TICKER] + [MARKET_TICKER]))
+    df = df[df["ticker"].isin(symbols)].copy()
+    amounts = {r["ticker"]: float(r["amount_usd"]) for _, r in df.iterrows()}
+    gross_amt = sum(abs(v) for v in amounts.values())
+    if gross_amt <= 1e-9:
+        return (None, "All amounts are zero", "Universe ok", pd.DataFrame(columns=POS_COLS),
+                pd.DataFrame(columns=SUG_COLS), pd.DataFrame(columns=SUG_COLS),
+                pd.DataFrame(columns=SUG_COLS), pd.DataFrame(columns=EFF_COLS),
+                pd.DataFrame(columns=EFF_COLS), json.dumps([]), 1, "No suggestions.")
+
+    weights = {k: v / gross_amt for k, v in amounts.items()}
+
+    rf_code = fred_series_for_horizon(horizon_years)
+    rf_ann  = fetch_fred_yield_annual(rf_code)
+    moms    = estimate_all_moments_aligned(universe, lookback_years, rf_ann)
+    betas, covA, erp_ann, sigma_mkt = moms["betas"], moms["cov_ann"], moms["erp_ann"], moms["sigma_m_ann"]
+
+    beta_p, er_capm_p, sigma_p = portfolio_stats(weights, covA, betas, rf_ann, erp_ann)
+
+    a_sigma, b_sigma, mu_eff_sigma = efficient_same_sigma(sigma_p, rf_ann, erp_ann, sigma_mkt)
+    a_mu, b_mu, sigma_eff_mu       = efficient_same_return(er_capm_p, rf_ann, erp_ann, sigma_mkt)
+
+    eff_same_sigma_tbl = _table_from_weights({MARKET_TICKER: a_sigma, BILLS_TICKER: b_sigma}, gross_amt)
+    eff_same_mu_tbl    = _table_from_weights({MARKET_TICKER: a_mu,    BILLS_TICKER: b_mu},   gross_amt)
+
+    synth = build_synth_dataset(universe, covA, betas, rf_ann, erp_ann, n_rows=N_SYNTH, seed=777)
+
+    median_sigma = float(synth["sigma"].median()) if len(synth) else sigma_p
+    low_max  = max(float(synth["sigma"].min()), median_sigma - 0.05)
+    high_min = median_sigma + 0.05
+
+    if risk_bucket == "Low":
+        cand_df = synth[synth["sigma"] <= low_max].copy()
+    elif risk_bucket == "High":
+        cand_df = synth[synth["sigma"] >= high_min].copy()
+    else:
+        cand_df = synth[(synth["sigma"] > low_max) & (synth["sigma"] < high_min)].copy()
+
+    if len(cand_df) == 0:
+        cand_df = synth.copy()
+
+    embed = get_embedder()
+    cand_sentences = cand_df.apply(row_to_sentence, axis=1).tolist()
+
+    cur_pairs = ", ".join([f"{k}:{v:+.2f}" for k, v in sorted(weights.items())])
+    q_sentence = f"user portfolio ({risk_bucket} risk); capm_target {er_capm_p:.4f}; sigma_hist {sigma_p:.4f}; exposures {cur_pairs}"
+
+    cand_embs = embed.encode(cand_sentences, convert_to_tensor=True, normalize_embeddings=True, batch_size=64, show_progress_bar=False)
+    q_emb     = embed.encode([q_sentence], convert_to_tensor=True, normalize_embeddings=True)[0]
+
+    sims = st_util.cos_sim(q_emb, cand_embs)[0]
+    top_idx = sims.topk(k=min(MMR_K, len(cand_df))).indices.cpu().numpy().tolist()
+    shortlist_embs = cand_embs[top_idx]
+    mmr_local = mmr_select(q_emb, shortlist_embs, k=3, lambda_param=MMR_LAMBDA)
+    chosen = [top_idx[i] for i in mmr_local]
+    recs = cand_df.iloc[chosen].reset_index(drop=True)
+
+    suggs = []
+    for _, r in recs.iterrows():
+        wmap = _weights_dict_from_row(r)
+        suggs.append({
+            "weights": wmap,
+            "er_capm": float(r["er_capm"]),
+            "sigma": float(r["sigma"]),
+            "beta": float(r["beta"]),
+            "table": _table_from_weights(wmap, gross_amt)
+        })
 
-        # --- positions table (computed)
-        rows = []
-        for t in universe:
-            if t == MARKET_TICKER:
-                continue
-            rows.append({
-                "ticker": t,
-                "amount_usd": round(amounts.get(t, 0.0), 2),
-                "weight_exposure": round(weights.get(t, 0.0), 6),
-                "beta": round(betas.get(t, np.nan), 4) if t != MARKET_TICKER else 1.0
-            })
-        pos_table = pd.DataFrame(rows, columns=POS_COLS)
-
-        # --- info summary
-        info_lines = []
-        info_lines.append("### Inputs")
-        info_lines.append(f"- Lookback years **{int(lookback_years)}**")
-        info_lines.append(f"- Horizon years **{int(round(horizon_years))}**")
-        info_lines.append(f"- Risk-free **{fmt_pct(rf_ann)}** from **{rf_code}**")
-        info_lines.append(f"- Market ERP **{fmt_pct(erp_ann)}**")
-        info_lines.append(f"- Market σ **{fmt_pct(sigma_mkt)}**")
-        info_lines.append("")
-        info_lines.append("### Your portfolio (plotted as CAPM return, historical σ)")
-        info_lines.append(f"- Beta **{beta_p:.2f}**")
-        info_lines.append(f"- σ (historical) **{fmt_pct(sigma_p)}**")
-        info_lines.append(f"- E[return] (CAPM / SML) **{fmt_pct(er_capm_p)}**")
-        info_lines.append("")
-        info_lines.append("### Efficient alternatives on CML")
-        info_lines.append(f"- Same σ → Market **{a_sigma:.2f}**, Bills **{b_sigma:.2f}**, Return **{fmt_pct(mu_eff_sigma)}**")
-        info_lines.append(f"- Same μ → Market **{a_mu:.2f}**, Bills **{b_mu:.2f}**, σ **{fmt_pct(sigma_eff_mu)}**")
-        info_lines.append("")
-        info_lines.append(f"### Dataset-based suggestions (risk: **{risk_bucket}**)")
-        info_lines.append("Use the selector to flip between **Pick #1 / #2 / #3**. Table shows % exposure and $ amounts.")
-
-        # pad to exactly 3 tables for outputs
-        while len(sugg_tables) < 3:
-            sugg_tables.append(pd.DataFrame(columns=SUG_COLS))
-
-        pick_idx_default = 1
-        pick_msg_default = (f"Pick #1 — E[μ] {fmt_pct(sugg_meta[0]['er_capm'])}, "
-                            f"σ {fmt_pct(sugg_meta[0]['sigma'])}, β {sugg_meta[0]['beta']:.2f}") if sugg_meta else "No suggestion."
-
-        return (img,
-                "\n".join(info_lines),
-                f"Universe set to {', '.join(universe)}",
-                pos_table,
-                sugg_tables[0], sugg_tables[1], sugg_tables[2],
-                eff_same_sigma_tbl, eff_same_mu_tbl,
-                json.dumps(sugg_meta), pick_idx_default, pick_msg_default)
+    img = plot_cml(
+        rf_ann, erp_ann, sigma_mkt,
+        sigma_p, er_capm_p,
+        same_sigma_sigma=sigma_p, same_sigma_mu=mu_eff_sigma,
+        same_mu_sigma=sigma_eff_mu, same_mu_mu=er_capm_p
+    )
 
-    except Exception as e:
-        empty = pd.DataFrame(columns=POS_COLS)
-        emptyS = pd.DataFrame(columns=SUG_COLS)
-        emptyE = pd.DataFrame(columns=EFF_COLS)
-        msg = f"⚠️ Compute failed: {e}"
-        if DEBUG:
-            msg += "\n\n```\n" + traceback.format_exc() + "\n```"
-        return (None, msg, "Error", empty, emptyS, emptyS, emptyS, emptyE, emptyE, "[]", 1, "No suggestions.")
+    rows = []
+    for t in universe:
+        if t == MARKET_TICKER:
+            continue
+        rows.append({
+            "ticker": t,
+            "amount_usd": round(amounts.get(t, 0.0), 2),
+            "weight_exposure": round(weights.get(t, 0.0), 6),
+            "beta": round(betas.get(t, np.nan), 4) if t != MARKET_TICKER else 1.0
+        })
+    pos_table = pd.DataFrame(rows, columns=POS_COLS)
+
+    info_lines = []
+    info_lines.append("### Inputs")
+    info_lines.append(f"- Lookback years **{int(lookback_years)}**")
+    info_lines.append(f"- Horizon years **{int(round(horizon_years))}**")
+    info_lines.append(f"- Risk-free **{fmt_pct(rf_ann)}** from **{rf_code}**")
+    info_lines.append(f"- Market ERP **{fmt_pct(erp_ann)}**")
+    info_lines.append(f"- Market σ **{fmt_pct(sigma_mkt)}**")
+    info_lines.append("")
+    info_lines.append("### Your portfolio (plotted as CAPM return, historical σ)")
+    info_lines.append(f"- Beta **{beta_p:.2f}**")
+    info_lines.append(f"- σ (historical) **{fmt_pct(sigma_p)}**")
+    info_lines.append(f"- E[return] (CAPM / SML) **{fmt_pct(er_capm_p)}**")
+    info_lines.append("")
+    info_lines.append("### Efficient alternatives on CML")
+    info_lines.append(f"- Same σ → Market **{a_sigma:.2f}**, Bills **{b_sigma:.2f}**, Return **{fmt_pct(mu_eff_sigma)}**")
+    info_lines.append(f"- Same μ → Market **{a_mu:.2f}**, Bills **{b_mu:.2f}**, σ **{fmt_pct(sigma_eff_mu)}**")
+    info_lines.append("")
+    info_lines.append(f"### Dataset-based suggestions (risk: **{risk_bucket}**)")
+    info_lines.append("Use the selector to flip between **Pick #1 / #2 / #3**. Table shows % exposure and $ amounts.")
+
+    current_idx = 1
+    current = suggs[current_idx - 1] if suggs else None
+    current_tbl = current["table"] if current else pd.DataFrame(columns=SUG_COLS)
+    current_msg = ("Pick #1 — "
+                   f"E[μ] {fmt_pct(current['er_capm'])}, σ {fmt_pct(current['sigma'])}, β {current['beta']:.2f}"
+                   ) if current else "No suggestion."
+
+    return (img,
+            "\n".join(info_lines),
+            f"Universe set to {', '.join(universe)}",
+            pos_table,
+            suggs[0]["table"] if len(suggs) >= 1 else pd.DataFrame(columns=SUG_COLS),
+            suggs[1]["table"] if len(suggs) >= 2 else pd.DataFrame(columns=SUG_COLS),
+            suggs[2]["table"] if len(suggs) >= 3 else pd.DataFrame(columns=SUG_COLS),
+            eff_same_sigma_tbl,
+            eff_same_mu_tbl,
+            json.dumps([{
+                "er_capm": s["er_capm"], "sigma": s["sigma"], "beta": s["beta"],
+            } for s in suggs]),
+            current_idx,
+            current_msg)
 
 def on_pick_change(idx: int, meta_json: str):
     try:
@@ -704,7 +650,9 @@ def on_pick_change(idx: int, meta_json: str):
 # =========================
 # UI
 # =========================
-with gr.Blocks(title="Efficient Portfolio Advisor", css="#small-note {font-size: 12px; color:#666;}") as demo:
+with gr.Blocks(title="Efficient Portfolio Advisor", css="""
+#small-note {font-size: 12px; color:#666;}
+""") as demo:
 
     gr.Markdown("## Efficient Portfolio Advisor\n"
                 "Search symbols, enter **$ amounts**, set your **horizon**. "
@@ -739,7 +687,7 @@ with gr.Blocks(title="Efficient Portfolio Advisor", css="#small-note {font-size:
                 search_btn.click(fn=do_search, 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=[rf_msg])  # FIX: single output
+                horizon.change(fn=set_horizon, inputs=horizon, outputs=[rf_msg, gr.State()])
 
     with gr.Tab("Results"):
         with gr.Row():
@@ -799,4 +747,9 @@ with gr.Blocks(title="Efficient Portfolio Advisor", css="#small-note {font-size:
         )
 
 if __name__ == "__main__":
-    demo.launch()
+    # Important for HF Spaces proxy
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=int(os.environ.get("PORT", 7860)),
+        show_error=True,
+    )