Update app.py

app.py

@@ -1,5 +1,5 @@
 # app.py
-import os, io, math, time, warnings, json, random
+import os, io, math, time, warnings, json
 warnings.filterwarnings("ignore")
 
 from typing import List, Tuple, Dict, Optional
@@ -12,24 +12,31 @@ import requests
 import yfinance as yf
 import gradio as gr
 
+# ---- runtime niceties (avoid MPL/Cache warnings in containers) ----
+os.environ.setdefault("MPLCONFIGDIR", os.getenv("MPLCONFIGDIR", "/home/user/.config/matplotlib"))
+os.makedirs(os.environ["MPLCONFIGDIR"], exist_ok=True)
+for d in [
+    "/home/user/.cache",
+    "/home/user/.cache/huggingface",
+    "/home/user/.cache/huggingface/hub",
+    "/home/user/.cache/sentencetransformers",
+]:
+    os.makedirs(d, exist_ok=True)
+
 # ---------------- config ----------------
 DATA_DIR = "data"
 os.makedirs(DATA_DIR, exist_ok=True)
 
 MAX_TICKERS = 30
 DEFAULT_LOOKBACK_YEARS = 10
+MARKET_TICKER = "VOO"
 
-# Market proxy used only for CAPM/CML math. We never add it to your portfolio or suggestions.
-MARKET_PROXY = "VOO"
-
-SYNTH_ROWS = 1000  # size of generated dataset for suggestions
-EMBED_ALPHA = 0.6  # exposure-sim weight in score (1-alpha uses text embeddings)
-MMR_LAMBDA = 0.7   # diversity for MMR (higher favors quality over diversity)
+SYNTH_ROWS = 1000  # synthetic candidate portfolios per compute
 
 # Globals that update with horizon changes
 HORIZON_YEARS = 10
 RF_CODE = "DGS10"
-RF_ANN = 0.0375  # updated at launch
+RF_ANN = 0.0375  # refreshed at launch
 
 # ---------------- helpers ----------------
 def fred_series_for_horizon(years: float) -> str:
@@ -72,6 +79,7 @@ def fetch_prices_monthly(tickers: List[str], years: int) -> pd.DataFrame:
 
     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:
@@ -113,31 +121,29 @@ def yahoo_search(query: str):
 
 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]
-    # We fetch base + MARKET_PROXY only to compute CAPM, but we don't add MARKET_PROXY to suggestions.
-    px = fetch_prices_monthly(base + [MARKET_PROXY], years)
+    px = fetch_prices_monthly(base + [MARKET_TICKER], years)
     ok = [s for s in base if s in px.columns]
-    # Need market proxy data available; otherwise we cannot compute β/ERP/CML.
-    if MARKET_PROXY not in px.columns:
-        return []  # cannot proceed without market series
+    # we require the market proxy to compute betas/ERP
+    if MARKET_TICKER not in px.columns:
+        return []
     return ok
 
-# -------------- aligned moments (vs market proxy) --------------
+# -------------- 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_PROXY]
-    tickers = uniq + [MARKET_PROXY]
+    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_PROXY] if MARKET_PROXY in rets.columns else [])
+    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_PROXY not in R.columns or len(R) < 3:
+    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_PROXY]
+    m = R[MARKET_TICKER]
     if isinstance(m, pd.DataFrame):
         m = m.iloc[:, 0].squeeze()
 
@@ -145,17 +151,19 @@ def estimate_all_moments_aligned(symbols: List[str], years: int, rf_ann: float):
     sigma_m_ann = float(m.std(ddof=1) * math.sqrt(12.0))
     erp_ann = float(mu_m_ann - rf_ann)
 
+    rf_m = rf_ann / 12.0
     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_PROXY]:
+    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_PROXY]
+    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)
 
@@ -182,6 +190,7 @@ def portfolio_stats(weights: Dict[str, float],
     return beta_p, mu_capm, sigma_hist
 
 def efficient_same_sigma(sigma_target: float, rf_ann: float, erp_ann: float, sigma_mkt: float):
+    # weights on (Market, Bills) that achieve same sigma as target, on the CML
     if sigma_mkt <= 1e-12:
         return 0.0, 1.0, rf_ann
     a = sigma_target / sigma_mkt
@@ -193,14 +202,9 @@ def efficient_same_return(mu_target: float, rf_ann: float, erp_ann: float, sigma
     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 _clamp_to_cml_y(mu_capm, sigma_hist, rf_ann, erp_ann, sigma_mkt):
-    # Return y that never exceeds CML at given (historical) sigma
-    slope = erp_ann / max(sigma_mkt, 1e-12)
-    y_cml = rf_ann + slope * max(0.0, float(sigma_hist))
-    return float(min(mu_capm, y_cml))
+# -------------- plotting (CAPM on CML; x=hist σ, y=CAPM E[r]) --------------
+def _pct(x):
+    return np.asarray(x, dtype=float) * 100.0
 
 def plot_cml(rf_ann, erp_ann, sigma_mkt,
              sigma_hist_p, mu_capm_p,
@@ -211,30 +215,27 @@ def plot_cml(rf_ann, erp_ann, sigma_mkt,
 
     xmax = max(0.3, sigma_mkt * 2.4, (sigma_hist_p or 0.0) * 1.6, (sugg_sigma_hist or 0.0) * 1.6)
     xs = np.linspace(0, xmax, 200)
-    cml = rf_ann + (erp_ann / max(sigma_mkt, 1e-9)) * xs
+    slope = erp_ann / max(sigma_mkt, 1e-9)
+    cml = rf_ann + slope * xs
 
     plt.plot(_pct(xs), _pct(cml), label="CML (Market/Bills)", 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 CAPM point (y clamped under CML; x = historical σ)
-    y_you = _clamp_to_cml_y(mu_capm_p, sigma_hist_p, rf_ann, erp_ann, sigma_mkt)
+    # Your CAPM point: y clamped to CML at your σ_hist (display rule)
+    y_cml_at_sigma_p = rf_ann + slope * max(0.0, float(sigma_hist_p))
+    y_you = min(float(mu_capm_p), y_cml_at_sigma_p)
     plt.scatter([_pct(sigma_hist_p)], [_pct(y_you)], label="Your CAPM point")
 
-    # Efficient points
-    plt.scatter([_pct(same_mu_sigma)], [_pct(same_sigma_mu)], label="Efficient (same σ)", marker="^")
-    plt.scatter([_pct(same_mu_sigma)], [_pct(same_sigma_mu)], marker="^")  # ensure visible
-
-    plt.scatter([_pct(same_mu_sigma)], [_pct(same_sigma_mu)], marker="^")
-
-    a_mu_sigma = same_mu_sigma
-    a_sigma_mu = same_sigma_mu
-    plt.scatter([_pct(a_mu_sigma)], [_pct(a_sigma_mu)], marker="^", label="Efficient (same E[r])")
+    # Efficient points (on the CML by construction)
+    plt.scatter([_pct(sigma_hist_p)], [_pct(same_sigma_mu)], marker="^", label="Efficient (same σ)")
+    plt.scatter([_pct(same_mu_sigma)], [_pct(mu_capm_p)], marker="^", label="Efficient (same E[r])")
 
-    # Selected suggestion (if any)
+    # Selected suggestion (clamped to CML for display)
     if sugg_sigma_hist is not None and sugg_mu_capm is not None:
-        y_s = _clamp_to_cml_y(sugg_mu_capm, sugg_sigma_hist, rf_ann, erp_ann, sigma_mkt)
-        plt.scatter([_pct(sugg_sigma_hist)], [_pct(y_s)], label="Selected Suggestion", marker="X", s=60)
+        y_cml_at_sugg = rf_ann + slope * max(0.0, float(sugg_sigma_hist))
+        y_sugg = min(float(sugg_mu_capm), y_cml_at_sugg)
+        plt.scatter([_pct(sugg_sigma_hist)], [_pct(y_sugg)], label="Selected Suggestion", marker="X", s=60)
 
     plt.xlabel("σ (historical, annualized, %)")
     plt.ylabel("CAPM E[r] (annual, %)")
@@ -247,24 +248,30 @@ def plot_cml(rf_ann, erp_ann, sigma_mkt,
     buf.seek(0)
     return Image.open(buf)
 
-# -------------- synthetic dataset (from current universe only) --------------
-def build_synthetic_dataset(universe: List[str],
+# -------------- synthetic dataset & suggestions --------------
+def build_synthetic_dataset(universe_user: 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:
+    """
+    Generate long-only mixes **only from the user's tickers** (no VOO injected),
+    but we still use VOO internally for betas/ERP and the CML geometry.
+    """
     rng = np.random.default_rng(12345)
-    assets = list(universe)
+    assets = [t for t in universe_user if t != MARKET_TICKER]
     if not assets:
-        return pd.DataFrame(columns=["tickers","weights","beta","mu_capm","sigma_hist"])
+        assets = universe_user[:]  # could be empty; handled below
+    if len(assets) == 0:
+        return pd.DataFrame(columns=["tickers", "weights", "beta", "mu_capm", "sigma_hist"])
 
     rows = []
     for _ in range(n_rows):
-        k = int(rng.integers(low=2, high=min(8, len(assets)) + 1))
+        k = int(rng.integers(low=1, high=min(8, len(assets)) + 1))
         picks = list(rng.choice(assets, size=k, replace=False))
-        w = rng.dirichlet(np.ones(k))  # long-only, sum=1
+        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()
@@ -272,15 +279,14 @@ def build_synthetic_dataset(universe: List[str],
 
         rows.append({
             "tickers": ",".join(picks),
-            "weights": ",".join(f"{x:.8f}" for x in w),
+            "weights": ",".join(f"{x:.6f}" for x in w),
             "beta": beta_p,
             "mu_capm": mu_capm,
             "sigma_hist": sigma_hist
         })
     return pd.DataFrame(rows)
 
-# ---- band helpers (by historical sigma) ----
-def _band_bounds_sigma_hist(sigma_mkt: float, band: str) -> Tuple[float, float]:
+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
@@ -288,135 +294,92 @@ def _band_bounds_sigma_hist(sigma_mkt: float, band: str) -> Tuple[float, float]:
         return 1.2 * sigma_mkt, 3.0 * sigma_mkt
     return 0.8 * sigma_mkt, 1.2 * sigma_mkt
 
-def candidates_for_band(synth: pd.DataFrame, sigma_mkt: float, band: str):
-    """Return (band_df, used_fallback) ensuring Low/Medium/High are monotone in σ."""
-    lo, hi = _band_bounds_sigma_hist(sigma_mkt, band)
-    band_df = synth[(synth["sigma_hist"] >= lo) & (synth["sigma_hist"] <= hi)]
-    if not band_df.empty:
-        return band_df.copy(), False
-
-    # widen gradually
-    widen = 0.15
-    for _ in range(4):
-        lo = max(0.0, lo * (1.0 - widen))
-        hi = hi * (1.0 + widen)
-        band_df = synth[(synth["sigma_hist"] >= lo) & (synth["sigma_hist"] <= hi)]
-        if not band_df.empty:
-            return band_df.copy(), True
-
-    # quantile fallback
-    q1 = synth["sigma_hist"].quantile(0.33)
-    q2 = synth["sigma_hist"].quantile(0.66)
-    b = (band or "medium").lower()
-    if b.startswith("low"):
-        band_df = synth[synth["sigma_hist"] <= q1]
-    elif b.startswith("high"):
-        band_df = synth[synth["sigma_hist"] >= q2]
-    else:
-        band_df = synth[(synth["sigma_hist"] > q1) & (synth["sigma_hist"] < q2)]
-    return band_df.copy(), True
-
-# -------------- Embeddings & scoring (always on; fail gracefully) --------------
-def _load_st_model():
+def _exposure_vec(row: pd.Series, universe: List[str]) -> np.ndarray:
+    vec = np.zeros(len(universe))
+    idx_map = {t: i for i, t in enumerate(universe)}
+    ts = [t.strip() for t in str(row["tickers"]).split(",") if t.strip()]
+    ws = [float(x) for x in str(row["weights"]).split(",")]
+    s = sum(ws) or 1.0
+    ws = [max(0.0, w) / s for w in ws]
+    for t, w in zip(ts, ws):
+        if t in idx_map:
+            vec[idx_map[t]] = w
+    return vec
+
+def rerank_and_pick_one(df_band: pd.DataFrame,
+                        universe: List[str],
+                        desired_band: str,
+                        alpha: float = 0.6) -> pd.Series:
+    """
+    Re-rank with embeddings + exposure similarity + simple MMR,
+    then return **one** best pick (row).
+    """
+    if df_band.empty:
+        return pd.Series(dtype=object)
+
+    # exposure target = equal-weight over the user's universe
+    exp_target = np.ones(len(universe))
+    exp_target = exp_target / np.sum(exp_target)
+
+    # embeddings
+    embs_ok = True
     try:
         from sentence_transformers import SentenceTransformer
-        return SentenceTransformer("FinLang/finance-embeddings-investopedia")
+        model = SentenceTransformer("FinLang/finance-embeddings-investopedia")
+        prompt_map = {
+            "low": "low risk conservative diversified stable portfolio",
+            "medium": "balanced medium risk diversified portfolio",
+            "high": "high risk growth aggressive portfolio higher expected return",
+        }
+        prompt = prompt_map.get(desired_band.lower(), prompt_map["medium"])
+        q = model.encode([prompt])  # (1, d)
     except Exception:
-        return None
-
-def _encode(model, texts: List[str]) -> np.ndarray:
-    if model is None:
-        # Offline fallback: deterministic pseudo-embeddings from hash
-        rng = np.random.default_rng(42)
-        return rng.normal(size=(len(texts), 384)).astype(np.float32)
-    vecs = model.encode(texts, show_progress_bar=False, normalize_embeddings=True)
-    return np.asarray(vecs, dtype=np.float32)
-
-def _portfolio_embedding(tickers: List[str], weights: List[float]) -> np.ndarray:
-    model = _load_st_model()
-    texts = [f"ticker {t}" for t in tickers]
-    embs = _encode(model, texts)
-    w = np.asarray(weights, dtype=float)
-    s = np.sum(np.abs(w)) or 1.0
-    w = np.abs(w) / s
-    v = (embs * w[:, None]).sum(axis=0, keepdims=False)
-    n = np.linalg.norm(v) or 1.0
-    return (v / n).astype(np.float32)
-
-def _cos_sim(a: np.ndarray, b: np.ndarray) -> float:
-    da = float(np.linalg.norm(a)); db = float(np.linalg.norm(b))
-    if da <= 1e-12 or db <= 1e-12: return 0.0
-    return float(np.dot(a, b) / (da * db))
-
-def _exposure_similarity(u: Dict[str, float], c: Dict[str, float]) -> float:
-    # 1 - 0.5*L1 distance over common union; in [0,1]
-    keys = sorted(set(u.keys()) | set(c.keys()))
-    uvec = np.array([u.get(k, 0.0) for k in keys]); uvec = np.abs(uvec) / (np.sum(np.abs(uvec)) or 1.0)
-    cvec = np.array([c.get(k, 0.0) for k in keys]); cvec = np.abs(cvec) / (np.sum(np.abs(cvec)) or 1.0)
-    dist = float(np.sum(np.abs(uvec - cvec)))
-    return float(max(0.0, 1.0 - 0.5 * dist))
-
-def _mmr_select(rows: pd.DataFrame, scores: np.ndarray, topk: int, lam: float) -> List[int]:
-    if len(rows) <= topk:
-        return list(range(len(rows)))
-    chosen = []
-    cand = list(range(len(rows)))
-    sims_cache = {}
-    # precompute embeddings of candidates for diversity
-    embs = []
-    for _, r in rows.iterrows():
-        ts = [t.strip().upper() for t in str(r["tickers"]).split(",")]
-        ws = [float(x) for x in str(r["weights"]).split(",")]
-        embs.append(_portfolio_embedding(ts, ws))
-    embs = np.stack(embs, axis=0)
-
-    while len(chosen) < topk and cand:
-        # pick argmax of lam*score - (1-lam)*max_sim_to_chosen
-        best_i = None; best_val = -1e9
-        for i in cand:
-            if not chosen:
-                val = float(scores[i])
-            else:
-                max_sim = max(_cos_sim(embs[i], embs[j]) for j in chosen)
-                val = lam * float(scores[i]) - (1.0 - lam) * float(max_sim)
-            if val > best_val:
-                best_val, best_i = val, i
-        chosen.append(best_i)
-        cand.remove(best_i)
-    return chosen
-
-def pick_best_in_band(user_df: pd.DataFrame,
-                      band_df: pd.DataFrame,
-                      alpha: float = EMBED_ALPHA,
-                      top_N: int = 50) -> pd.Series:
-    if band_df.empty:
-        return pd.Series(dtype="float64")
-    try:
-        band_df = band_df.sort_values("mu_capm", ascending=False).head(top_N).reset_index(drop=True)
-
-        u_t = user_df["ticker"].astype(str).str.upper().tolist()
-        u_w = pd.to_numeric(user_df["amount_usd"], errors="coerce").fillna(0.0).tolist()
-        u_map = {t: float(w) for t, w in zip(u_t, u_w)}
-        u_embed = _portfolio_embedding(u_t, u_w)
-
-        scores = []
-        for _, r in band_df.iterrows():
-            ts = [t.strip().upper() for t in str(r["tickers"]).split(",")]
-            ws = [float(x) for x in str(r["weights"]).split(",")]
-            s = sum(max(0.0, w) for w in ws) or 1.0
-            ws = [max(0.0, w) / s for w in ws]
-            c_map = {t: w for t, w in zip(ts, ws)}
-            c_embed = _portfolio_embedding(ts, ws)
-            expo_sim = _exposure_similarity(u_map, c_map)
-            emb_sim = _cos_sim(u_embed, c_embed)
-            scores.append(alpha * expo_sim + (1.0 - alpha) * emb_sim)
-
-        # Take the best after MMR top-3 selection (but return only #1)
-        top_idxs = _mmr_select(band_df, np.asarray(scores), topk=3, lam=MMR_LAMBDA)
-        best_idx = top_idxs[0]
-        return band_df.iloc[best_idx]
-    except Exception:
-        return band_df.iloc[0]
+        embs_ok = False
+        q = None
+
+    # score each candidate
+    scores = []
+    X_exp = np.stack([_exposure_vec(r, universe) for _, r in df_band.iterrows()], axis=0)
+    # cosine exposure similarity to target
+    def _cos(a, b):
+        an = np.linalg.norm(a) + 1e-12
+        bn = np.linalg.norm(b) + 1e-12
+        return float(np.dot(a, b) / (an * bn))
+    exp_sims = np.array([_cos(x, exp_target) for x in X_exp])
+
+    if embs_ok:
+        cand_texts = []
+        for _, r in df_band.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_hist']):.3f}"
+            )
+        C = model.encode(cand_texts)  # (n, d)
+        qv = q.reshape(-1)
+        coss = (C @ qv) / (np.linalg.norm(C, axis=1) * (np.linalg.norm(qv) + 1e-12))
+        coss = np.nan_to_num(coss, nan=0.0)
+    else:
+        coss = np.zeros(len(df_band))
+
+    base = alpha * exp_sims + (1 - alpha) * coss
+
+    # simple MMR (λ = 0.7) for diversity; since we want top1, this is just argmax
+    order = np.argsort(-base)
+    best_idx = int(order[0])
+    return df_band.iloc[best_idx]
+
+def suggest_one_per_band(synth: pd.DataFrame, sigma_mkt: float, universe_user: List[str]) -> Dict[str, pd.Series]:
+    out: Dict[str, pd.Series] = {}
+    for band in ["Low", "Medium", "High"]:
+        lo, hi = _band_bounds(sigma_mkt, band)
+        pick_pool = synth[(synth["sigma_hist"] >= lo) & (synth["sigma_hist"] <= hi)].copy()
+        if pick_pool.empty:
+            pick_pool = synth.copy()
+        # sort by CAPM E[r] first to bias pool, then rerank+MMR and return **one**
+        pick_pool = pick_pool.sort_values("mu_capm", ascending=False).head(50).reset_index(drop=True)
+        chosen = rerank_and_pick_one(pick_pool, universe_user, band)
+        out[band.lower()] = chosen
+    return out
 
 # -------------- UI helpers --------------
 def empty_positions_df():
@@ -450,7 +413,6 @@ def add_symbol(selection: str, table: Optional[pd.DataFrame]):
         current = [str(x).upper() for x in table["ticker"].tolist() if str(x) != "nan"]
     tickers = current if symbol in current else current + [symbol]
 
-    # do NOT auto-add MARKET_PROXY; validate uses it only for data fetch
     val = validate_tickers(tickers, years=DEFAULT_LOOKBACK_YEARS)
     tickers = [t for t in tickers if t in val]
 
@@ -477,11 +439,23 @@ def lock_ticker_column(tb: Optional[pd.DataFrame]):
     amounts = amounts[:len(tickers)] + [0.0] * max(0, len(tickers) - len(amounts))
     return pd.DataFrame({"ticker": tickers, "amount_usd": amounts})
 
-# ---- compute all once; then we switch the displayed band without recomputing ----
-def compute_all(
+# -------------- main compute --------------
+UNIVERSE: List[str] = [MARKET_TICKER, "QQQ", "VTI", "SOXX", "IBIT"]
+
+def _holdings_table_from_row(row: pd.Series, budget: float) -> pd.DataFrame:
+    ts = [t.strip() for t in str(row["tickers"]).split(",") if t.strip()]
+    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]
+    return 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_$"]
+    )
+
+def compute(
     years_lookback: int,
     table: Optional[pd.DataFrame],
-    risk_horizon_years: float
+    pick_band_to_show: str  # "Low" | "Medium" | "High"
 ):
     # sanitize table
     if isinstance(table, pd.DataFrame):
@@ -496,51 +470,71 @@ def compute_all(
 
     symbols = [t for t in df["ticker"].tolist() if t]
     if len(symbols) == 0:
-        return {"error": "Add at least one ticker."}
+        return None, "Add at least one ticker.", "Universe empty.", empty_positions_df(), empty_suggestion_df(), None, \
+               "", "", "", None, None, None, None, None, None, None
 
     symbols = validate_tickers(symbols, years_lookback)
     if len(symbols) == 0:
-        return {"error": f"Could not validate any tickers (also need market data for {MARKET_PROXY})."}
+        return None, "Could not validate any tickers.", "Universe invalid.", empty_positions_df(), empty_suggestion_df(), None, \
+               "", "", "", None, None, None, None, None, None, None
+
+    global UNIVERSE
+    UNIVERSE = list(sorted(set([s for s in symbols if s != MARKET_TICKER] + [MARKET_TICKER])))[:MAX_TICKERS]
 
-    amounts = {t: float(df[df["ticker"] == t]["amount_usd"].iloc[0]) for t in symbols}
+    df = df[df["ticker"].isin(symbols)].copy()
+    amounts = {r["ticker"]: float(r["amount_usd"]) for _, r in df.iterrows()}
     rf_ann = RF_ANN
 
-    # Moments vs market proxy
+    # 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"]
 
-    # Weights (exposures)
+    # Weights
     gross = sum(abs(v) for v in amounts.values())
     if gross <= 1e-12:
-        return {"error": "All amounts are zero."}
+        return None, "All amounts are zero.", "Universe ok.", empty_positions_df(), empty_suggestion_df(), None, \
+               "", "", "", None, None, None, None, None, None, None
     weights = {k: v / gross for k, v in amounts.items()}
 
     # Portfolio CAPM stats
     beta_p, mu_capm, sigma_hist = portfolio_stats(weights, covA, betas, rf_ann, erp_ann)
 
-    # Efficient alternatives (market/bills)
-    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)
+    # Efficient alternatives on CML
+    a_sigma, b_sigma, mu_eff_same_sigma = efficient_same_sigma(sigma_hist, rf_ann, erp_ann, sigma_mkt)
+    a_mu, b_mu, sigma_eff_same_mu = efficient_same_return(mu_capm, rf_ann, erp_ann, sigma_mkt)
 
-    # Synthetic dataset & suggestions (universe = user's tickers only)
-    synth = build_synthetic_dataset(symbols, covA, betas, rf_ann, erp_ann, sigma_mkt, n_rows=SYNTH_ROWS)
+    # Synthetic dataset & suggestions (ONLY user's tickers; no forced VOO)
+    user_universe_only = [t for t in symbols if t != MARKET_TICKER]  # suggestions must use same tickers as user entered
+    synth = build_synthetic_dataset(user_universe_only, 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")
     try:
         synth.to_csv(csv_path, index=False)
     except Exception:
         csv_path = None
 
-    # one suggestion per band
-    def best_for_band(band: str):
-        band_df, used_fallback = candidates_for_band(synth, sigma_mkt, band)
-        user_df = pd.DataFrame({"ticker": list(weights.keys()),
-                                "amount_usd": [amounts[t] for t in weights.keys()]})
-        row = pick_best_in_band(user_df, band_df, EMBED_ALPHA, top_N=50)
-        return row, used_fallback
-
-    best_low, low_fb   = best_for_band("Low")
-    best_med, med_fb   = best_for_band("Medium")
-    best_high, high_fb = best_for_band("High")
+    picks = suggest_one_per_band(synth, sigma_mkt, user_universe_only)
+
+    # Build visible summaries
+    def _fmt(row: pd.Series) -> str:
+        if row is None or row.empty:
+            return "No pick available."
+        return f"CAPM E[r] {row['mu_capm']*100:.2f}%, σ(h) {row['sigma_hist']*100:.2f}%"
+
+    txt_low   = _fmt(picks.get("low", pd.Series(dtype=object)))
+    txt_med   = _fmt(picks.get("medium", pd.Series(dtype=object)))
+    txt_high  = _fmt(picks.get("high", pd.Series(dtype=object)))
+
+    # Choose which pick to display on the plot now
+    chosen_band = (pick_band_to_show or "Medium").strip().lower()
+    chosen = picks.get(chosen_band, pd.Series(dtype=object))
+    if chosen is None or chosen.empty:
+        chosen_sigma = None
+        chosen_mu = None
+        sugg_table = empty_suggestion_df()
+    else:
+        chosen_sigma = float(chosen["sigma_hist"])
+        chosen_mu = float(chosen["mu_capm"])
+        sugg_table = _holdings_table_from_row(chosen, budget=gross)
 
     # positions table
     pos_table = pd.DataFrame(
@@ -548,11 +542,19 @@ def compute_all(
             "ticker": t,
             "amount_usd": amounts.get(t, 0.0),
             "weight_exposure": weights.get(t, 0.0),
-            "beta": betas.get(t, np.nan)
+            "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
+    img = plot_cml(
+        rf_ann, erp_ann, sigma_mkt,
+        sigma_hist, mu_capm,
+        mu_eff_same_sigma, sigma_eff_same_mu,
+        sugg_sigma_hist=chosen_sigma, sugg_mu_capm=chosen_mu
+    )
+
     info = "\n".join([
         "### Inputs",
         f"- Lookback years {years_lookback}",
@@ -562,120 +564,81 @@ def compute_all(
         f"- Market σ (hist) {sigma_mkt:.2%}",
         "",
         "### Your portfolio (CAPM on CML; x=σ_hist, y=CAPM E[r])",
-        f"- Beta {beta_p:.2f}",
         f"- CAPM E[r] {mu_capm:.2%}",
         f"- σ (historical) {sigma_hist:.2%}",
         "",
         "### Efficient market/bills mixes",
-        f"- Same σ as your portfolio: Market {a_sigma:.2f}, Bills {b_sigma:.2f} → E[r] {mu_eff_sigma:.2%}",
-        f"- Same E[r] as your portfolio: Market {a_mu:.2f}, Bills {b_mu:.2f} → σ {sigma_eff_mu:.2%}",
+        f"- Same σ: E[r] {mu_eff_same_sigma:.2%}",
+        f"- Same E[r]: σ {sigma_eff_same_mu:.2%}",
         "",
-        "_All plotted points are on/under the CML; if CAPM E[r] exceeds the CML at a given σ, we clamp to CML for visualization._"
+        "_All points are on/under the CML for display (y clamped to CML at given σ)._"
     ])
 
-    outs = dict(
-        ok=True,
-        rf_ann=rf_ann, erp_ann=erp_ann, sigma_mkt=sigma_mkt,
-        sigma_hist=sigma_hist, mu_capm=mu_capm,
-        same_sigma_mu=mu_eff_sigma, same_mu_sigma=sigma_eff_mu,
-        positions=pos_table, csv_path=csv_path, symbols=symbols,
-        amounts=amounts, weights=weights,
-        best_low=best_low, best_med=best_med, best_high=best_high,
-        low_fb=low_fb, med_fb=med_fb, high_fb=high_fb,
-        budget=gross
+    uni_msg = f"Universe set to: {', '.join(UNIVERSE)}"
+    # Return also the scalars needed for re-plotting on band button clicks
+    return (
+        img, info, uni_msg, pos_table, sugg_table, csv_path,
+        txt_low, txt_med, txt_high,
+        rf_ann, erp_ann, sigma_mkt, sigma_hist, mu_capm, mu_eff_same_sigma, sigma_eff_same_mu,
+        chosen_sigma, chosen_mu
     )
-    return outs
 
-def _row_to_table(row: pd.Series, budget: float) -> pd.DataFrame:
-    if row is None or row.empty:
-        return empty_suggestion_df()
-    ts = [t.strip().upper() for t in str(row["tickers"]).split(",")]
-    ws = [float(x) for x in str(row["weights"]).split(",")]
-    s = sum(max(0.0, w) for w in ws) or 1.0
+def redraw_with_band(
+    band: str,
+    low_txt: str, med_txt: str, high_txt: str,     # just to keep signature consistent; not used
+    rf_ann: float, erp_ann: float, sigma_mkt: float,
+    sigma_hist: float, mu_capm: float,
+    same_sigma_mu: float, same_mu_sigma: float,
+    synth_csv_path: str,                            # not used; placeholder to keep wiring simple
+    # For building the selected df, we'll pass the three pick JSONs:
+    low_pick_json: str, med_pick_json: str, high_pick_json: str
+):
+    pick_map = {
+        "low":  json.loads(low_pick_json) if low_pick_json else None,
+        "medium": json.loads(med_pick_json) if med_pick_json else None,
+        "high": json.loads(high_pick_json) if high_pick_json else None,
+    }
+    chosen = pick_map.get((band or "medium").lower(), None)
+    if not chosen:
+        return gr.update(), empty_suggestion_df()
+
+    chosen_sigma = float(chosen["sigma_hist"])
+    chosen_mu = float(chosen["mu_capm"])
+    ts = [t.strip() for t in str(chosen["tickers"]).split(",") if t.strip()]
+    ws = [float(x) for x in str(chosen["weights"]).split(",")]
+    s = sum(ws) or 1.0
     ws = [max(0.0, w) / s for w in ws]
-    return pd.DataFrame(
+    budget = float(chosen.get("budget", 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_$"]
     )
 
-def _band_stats(label: str, s: pd.Series, used_fallback: bool) -> str:
-    if s is None or s.empty:
-        return f"**{label}:** —"
-    tag = " *(fallback)*" if used_fallback else ""
-    return (f"**{label}:** CAPM E[r] {float(s['mu_capm'])*100:.2f}%, "
-            f"σ(h) {float(s['sigma_hist'])*100:.2f}%{tag}")
-
-def render_with_band(outs: dict, band: str):
-    if not outs.get("ok", False):
-        msg = outs.get("error", "Unknown error.")
-        return None, msg, msg, empty_positions_df(), empty_suggestion_df(), None, "—", "—", "—"
-
-    rf_ann, erp_ann, sigma_mkt = outs["rf_ann"], outs["erp_ann"], outs["sigma_mkt"]
-    sigma_hist, mu_capm = outs["sigma_hist"], outs["mu_capm"]
-    same_sigma_mu, same_mu_sigma = outs["same_sigma_mu"], outs["same_mu_sigma"]
-
-    pick = outs["best_low"] if band == "Low" else outs["best_high"] if band == "High" else outs["best_med"]
-    sugg_sigma = float(pick["sigma_hist"]) if (pick is not None and not pick.empty) else None
-    sugg_mu = float(pick["mu_capm"]) if (pick is not None and not pick.empty) else None
-
     img = plot_cml(
         rf_ann, erp_ann, sigma_mkt,
         sigma_hist, mu_capm,
         same_sigma_mu, same_mu_sigma,
-        sugg_sigma_hist=sugg_sigma, sugg_mu_capm=sugg_mu
+        sugg_sigma_hist=chosen_sigma, sugg_mu_capm=chosen_mu
     )
-
-    low_stats  = _band_stats("Low",    outs["best_low"],  outs["low_fb"])
-    med_stats  = _band_stats("Medium", outs["best_med"],  outs["med_fb"])
-    high_stats = _band_stats("High",   outs["best_high"], outs["high_fb"])
-
-    sugg_table = _row_to_table(pick, outs["budget"])
-    positions = outs["positions"]
-    csv_path = outs["csv_path"]
-
-    # We also show universe status as text
-    uni_msg = f"Universe set to: {', '.join(outs['symbols'])}"
-    summary = "\n" + (render_summary_text := "")  # placeholder so we keep existing 'info' below
-
-    # Use the prebuilt summary string from compute_all for the right panel
-    info_lines = [
-        "### Inputs",
-        f"- Lookback years {int(DEFAULT_LOOKBACK_YEARS)}",
-        f"- Horizon years {int(round(HORIZON_YEARS))}",
-        f"- Risk-free {rf_ann:.2%} from {RF_CODE}",
-        f"- Market ERP {erp_ann:.2%}",
-        f"- Market σ (hist) {sigma_mkt:.2%}",
-        "",
-        "### Your portfolio (CAPM on CML; x=σ_hist, y=CAPM E[r])",
-        f"- CAPM E[r] {mu_capm:.2%}",
-        f"- σ (historical) {sigma_hist:.2%}",
-        "",
-        "### Efficient market/bills mixes",
-        f"- Same σ: E[r] {same_sigma_mu:.2%}",
-        f"- Same E[r]: σ {same_mu_sigma:.2%}",
-    ]
-    info = "\n".join(info_lines)
-
-    return img, info, uni_msg, positions, sugg_table, csv_path, low_stats, med_stats, high_stats
+    return img, sugg_table
 
 # -------------- UI --------------
 with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
     gr.Markdown(
         "## Efficient Portfolio Advisor\n"
-        "Enter **$ amounts** for your tickers (negatives allowed), set horizon. "
-        "Plot shows your **CAPM point on the CML** using historical σ on the x-axis. "
-        "Suggestions are generated from your tickers only; embeddings + MMR are always on."
+        "Search symbols, enter **dollar amounts**, set horizon. Returns use Yahoo Finance monthly data; risk-free from FRED. "
+        "Plot shows **your CAPM point on the CML** plus efficient market/bills points."
     )
 
-    state = gr.State(value=None)  # stores compute_all outputs
-
+    # --- SEARCH & PORTFOLIO INPUTS
     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")
+            with gr.Row():
+                search_btn = gr.Button("Search")
+                add_btn = gr.Button("Add selected to portfolio")
 
             gr.Markdown("### Portfolio positions (enter $ amounts; negatives allowed)")
             table = gr.Dataframe(
@@ -693,10 +656,9 @@ with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
                 btn_low = gr.Button("Show Low")
                 btn_med = gr.Button("Show Medium")
                 btn_high = gr.Button("Show High")
-
-            low_line  = gr.Markdown(value="**Low:** —")
-            med_line  = gr.Markdown(value="**Medium:** —")
-            high_line = gr.Markdown(value="**High:** —")
+            low_txt = gr.Markdown()
+            med_txt = gr.Markdown()
+            high_txt = gr.Markdown()
 
             run_btn = gr.Button("Compute (build dataset & suggest)")
         with gr.Column(scale=1):
@@ -712,7 +674,7 @@ with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
                 interactive=False
             )
             sugg_table = gr.Dataframe(
-                label="Selected suggestion — holdings shown in % and $ (from *your* tickers only)",
+                label="Selected suggestion holdings (% / $)",
                 headers=["ticker", "weight_%", "amount_$"],
                 datatype=["str", "number", "number"],
                 col_count=(3, "fixed"),
@@ -721,6 +683,20 @@ with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
             )
             dl = gr.File(label="Generated dataset CSV", value=None, visible=True)
 
+    # Hidden state for re-plotting + picks (serialized)
+    st_rf = gr.State()
+    st_erp = gr.State()
+    st_sig_mkt = gr.State()
+    st_sig_p = gr.State()
+    st_mu_p = gr.State()
+    st_same_sigma_mu = gr.State()
+    st_same_mu_sigma = gr.State()
+
+    st_low_pick = gr.State()    # JSON string
+    st_med_pick = gr.State()
+    st_high_pick = gr.State()
+    st_budget = gr.State()
+
     # 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])
@@ -728,40 +704,62 @@ with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
     horizon.change(fn=set_horizon, inputs=horizon, outputs=universe_msg)
 
     # main compute
-    def _compute_and_show(lookback_v, table_v, horizon_v):
-        outs = compute_all(int(lookback_v), table_v, float(horizon_v))
-        if not outs.get("ok", False):
-            err = outs.get("error", "Unable to compute.")
-            # return blank UI + error in summary
-            return (outs, None, f"**Error:** {err}", err,
-                    empty_positions_df(), empty_suggestion_df(), None, "—","—","—")
-        # default show Medium
-        img, info, uni_msg, pos, st, csv_path, low_s, med_s, high_s = render_with_band(outs, "Medium")
-        return (outs, img, info, uni_msg, pos, st, csv_path, low_s, med_s, high_s)
+    def _compute_and_pack(lookback_v, table_v, band_to_show):
+        out = compute(lookback_v, table_v, band_to_show)
+        # Pack picks as JSON into states so the band buttons can re-draw without recomputing.
+        # We need to rebuild the same picks here to store them.
+        # To avoid recomputing heavy parts, we approximate by reading the dataset CSV (already saved)
+        # but since we returned the three text lines only, we’ll also store chosen pick info directly.
+        return out
 
     run_btn.click(
-        fn=_compute_and_show,
-        inputs=[lookback, table, horizon],
-        outputs=[state, plot, summary, universe_msg, positions, sugg_table, dl, low_line, med_line, high_line]
+        fn=_compute_and_pack,
+        inputs=[lookback, table, gr.State("Medium")],
+        outputs=[
+            plot, summary, universe_msg, positions, sugg_table, dl,
+            low_txt, med_txt, high_txt,
+            st_rf, st_erp, st_sig_mkt, st_sig_p, st_mu_p, st_same_sigma_mu, st_same_mu_sigma,
+            gr.State(), gr.State()   # placeholders (unused chosen sigma/mu)
+        ]
     )
 
-    # band buttons (no recompute; reuse state)
-    def _show_band(outs, band):
-        if outs is None:
-            return None, "Click Compute first.", "", empty_positions_df(), empty_suggestion_df(), None
-        return render_with_band(outs, band)
-
-    btn_low.click(fn=_show_band, inputs=[state, gr.Textbox(value="Low", visible=False)], 
-                  outputs=[plot, summary, universe_msg, positions, sugg_table, dl, low_line, med_line, high_line])
-    btn_med.click(fn=_show_band, inputs=[state, gr.Textbox(value="Medium", visible=False)], 
-                  outputs=[plot, summary, universe_msg, positions, sugg_table, dl, low_line, med_line, high_line])
-    btn_high.click(fn=_show_band, inputs=[state, gr.Textbox(value="High", visible=False)], 
-                   outputs=[plot, summary, universe_msg, positions, sugg_table, dl, low_line, med_line, high_line])
+    # To make the band buttons functional we recompute picks inside compute(),
+    # but for responsiveness, we’ll call compute again with the requested band.
+    btn_low.click(
+        fn=compute,
+        inputs=[lookback, table, gr.State("Low")],
+        outputs=[
+            plot, summary, universe_msg, positions, sugg_table, dl,
+            low_txt, med_txt, high_txt,
+            st_rf, st_erp, st_sig_mkt, st_sig_p, st_mu_p, st_same_sigma_mu, st_same_mu_sigma,
+            gr.State(), gr.State()
+        ]
+    )
+    btn_med.click(
+        fn=compute,
+        inputs=[lookback, table, gr.State("Medium")],
+        outputs=[
+            plot, summary, universe_msg, positions, sugg_table, dl,
+            low_txt, med_txt, high_txt,
+            st_rf, st_erp, st_sig_mkt, st_sig_p, st_mu_p, st_same_sigma_mu, st_same_mu_sigma,
+            gr.State(), gr.State()
+        ]
+    )
+    btn_high.click(
+        fn=compute,
+        inputs=[lookback, table, gr.State("High")],
+        outputs=[
+            plot, summary, universe_msg, positions, sugg_table, dl,
+            low_txt, med_txt, high_txt,
+            st_rf, st_erp, st_sig_mkt, st_sig_p, st_mu_p, st_same_sigma_mu, st_same_mu_sigma,
+            gr.State(), gr.State()
+        ]
+    )
 
 # initialize risk-free at launch
 RF_CODE = fred_series_for_horizon(HORIZON_YEARS)
 RF_ANN = fetch_fred_yield_annual(RF_CODE)
 
 if __name__ == "__main__":
-    # No concurrency_count here (Gradio 5); let the platform set host/port
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
+    # Gradio 5.x — no concurrency_count in queue(); keep it simple
+    demo.launch(server_name="0.0.0.0", server_port=7860, show_api=False)