Update app.py

app.py

@@ -1,11 +1,22 @@
+# app.py
 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")
+# --- make common caches writable even on locked-down containers ---
+APP_ROOT = os.path.abspath(os.path.dirname(__file__))
+DATA_DIR = os.path.join(APP_ROOT, "data")
+os.makedirs(DATA_DIR, exist_ok=True)
+
+# Matplotlib cache
+os.environ.setdefault("MPLCONFIGDIR", os.path.join(DATA_DIR, ".mplconfig"))
+os.makedirs(os.environ["MPLCONFIGDIR"], exist_ok=True)
+
+# Hugging Face / Sentence Transformers caches
+os.environ.setdefault("HF_HOME", os.path.join(DATA_DIR, ".huggingface"))
+os.environ.setdefault("HUGGINGFACE_HUB_CACHE", os.path.join(DATA_DIR, ".huggingface", "hub"))
+os.environ.setdefault("SENTENCE_TRANSFORMERS_HOME", os.path.join(DATA_DIR, ".sentencetransformers"))
+for d in [os.environ["HF_HOME"], os.environ["HUGGINGFACE_HUB_CACHE"], os.environ["SENTENCE_TRANSFORMERS_HOME"]]:
+    os.makedirs(d, exist_ok=True)
 
 from typing import List, Tuple, Dict, Optional
 
@@ -24,9 +35,6 @@ from sklearn.neighbors import KNeighborsRegressor
 # =========================
 # Config
 # =========================
-DATA_DIR = "data"
-os.makedirs(DATA_DIR, exist_ok=True)
-
 DEFAULT_LOOKBACK_YEARS = 5
 MAX_TICKERS = 30
 MARKET_TICKER = "VOO"        # proxy for market portfolio
@@ -125,6 +133,7 @@ def monthly_returns(prices: pd.DataFrame) -> pd.DataFrame:
     return prices.pct_change().dropna()
 
 def validate_tickers(symbols: List[str], years: int) -> List[str]:
+    """Return subset of symbols that have enough data over lookback."""
     symbols = [s.strip().upper() for s in symbols if s and isinstance(s, str)]
     base = [s for s in symbols if s != MARKET_TICKER]
     px = fetch_prices_monthly(base + [MARKET_TICKER], years)
@@ -206,12 +215,14 @@ def portfolio_stats(weights: Dict[str, float],
 # Efficient (CML) alternatives
 # =========================
 def efficient_same_sigma(sigma_target: float, rf_ann: float, erp_ann: float, sigma_mkt: float):
+    """Weights (a on Market, b on Bills) and expected return on CML with same sigma."""
     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):
+    """Weights (a on Market, b on Bills) and sigma on CML with same expected return."""
     if abs(erp_ann) <= 1e-12:
         return 0.0, 1.0, 0.0
     a = (mu_target - rf_ann) / erp_ann
@@ -248,11 +259,14 @@ def plot_cml(
     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)
 
+    # Your portfolio point uses CAPM expected return + historical sigma
     plt.scatter([_pct_arr(pt_sigma_hist)], [_pct_arr(pt_mu_capm)], label="Your portfolio (CAPM)", zorder=6)
 
+    # Efficient matches
     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)
 
+    # helper 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")
@@ -336,6 +350,9 @@ def mmr_select(query_emb: np.ndarray,
                cand_embs: np.ndarray,
                k: int = 3,
                lambda_param: float = MMR_LAMBDA) -> List[int]:
+    """
+    Maximal Marginal Relevance: pick k diverse-yet-relevant indices.
+    """
     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)
@@ -483,157 +500,183 @@ def _weights_dict_from_row(r: pd.Series) -> Dict[str, float]:
     return {k: v / gross for k, v in wmap.items()}
 
 def compute(lookback_years: int,
-            table: Optional[pd.DataFrame],
+            table_input,
             risk_bucket: str,
             horizon_years: float):
 
-    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)
-        })
-
-    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
-    )
+    try:
+        # --- coerce incoming table to DataFrame (Gradio 5 may pass list-like) ---
+        if table_input is None:
+            df = pd.DataFrame(columns=["ticker", "amount_usd"])
+        elif isinstance(table_input, pd.DataFrame):
+            df = table_input.copy()
+        else:
+            df = pd.DataFrame(table_input, columns=["ticker", "amount_usd"])
+
+        df = df.dropna(how="all")
+        if df.empty:
+            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.")
+
+        # --- sanitize
+        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, int(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 & 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:
+            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()}
+
+        # --- 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, int(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)
+
+        # --- risk buckets by sigma (absolute percentage points around median)
+        median_sigma = float(synth["sigma"].median()) if len(synth) else sigma_p
+        low_max  = max(float(synth["sigma"].min()), median_sigma - 0.05)   # 5% below median
+        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:  # Medium
+            cand_df = synth[(synth["sigma"] > low_max) & (synth["sigma"] < high_min)].copy()
+
+        if len(cand_df) == 0:
+            cand_df = synth.copy()
+
+        # --- embed all candidates + query, and pick 3 via MMR for diversity
+        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
+        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)
+            })
+
+        # --- 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
+        )
 
-    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)
+        # --- 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.")
+
+        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)
+
+    except Exception as e:
+        msg = f"⚠️ Compute failed: {type(e).__name__}: {e}"
+        empty = pd.DataFrame()
+        return (None, msg, "Error", empty, empty, empty, empty, empty, empty, "[]", 1, msg)
 
 def on_pick_change(idx: int, meta_json: str):
     try:
@@ -674,9 +717,13 @@ with gr.Blocks(title="Efficient Portfolio Advisor", css="""
                     datatype=["str", "number"],
                     row_count=0,
                     col_count=(2, "fixed"),
-                    wrap=True
+                    wrap=True,
+                    type="pandas"    # important for Gradio 5
                 )
 
+                # Handy sample
+                sample_btn = gr.Button("Load sample portfolio")
+
             with gr.Column(scale=1):
                 horizon = gr.Slider(1, 30, value=DEFAULT_LOOKBACK_YEARS, step=1, label="Investment horizon (years)")
                 lookback = gr.Slider(1, 10, value=DEFAULT_LOOKBACK_YEARS, step=1, label="Lookback (years) for β and σ")
@@ -687,13 +734,15 @@ with gr.Blocks(title="Efficient Portfolio Advisor", css="""
                 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, gr.State()])
+                horizon.change(fn=set_horizon, inputs=horizon, outputs=[rf_msg, gr.State()])  # rf_msg + silent
+                sample_btn.click(lambda: pd.DataFrame({"ticker": ["AAPL","MSFT","VOO"], "amount_usd": [3000, 2000, 5000]}),
+                                 inputs=None, outputs=table)
 
     with gr.Tab("Results"):
         with gr.Row():
             with gr.Column(scale=1):
                 plot = gr.Image(label="Capital Market Line", type="pil")
-                summary = gr.Markdown(label="Summary")
+                summary = gr.Markdown()
                 universe_msg = gr.Textbox(label="Universe status", interactive=False)
 
             with gr.Column(scale=1):
@@ -702,14 +751,15 @@ with gr.Blocks(title="Efficient Portfolio Advisor", css="""
                     headers=POS_COLS,
                     datatype=["str", "number", "number", "number"],
                     col_count=(len(POS_COLS), "fixed"),
-                    interactive=False
+                    interactive=False,
+                    type="pandas"
                 )
 
                 gr.Markdown("### Recommendations (always from embeddings)")
                 with gr.Row():
-                    sugg1 = gr.Dataframe(label="Pick #1", interactive=False)
-                    sugg2 = gr.Dataframe(label="Pick #2", interactive=False)
-                    sugg3 = gr.Dataframe(label="Pick #3", interactive=False)
+                    sugg1 = gr.Dataframe(label="Pick #1", interactive=False, type="pandas")
+                    sugg2 = gr.Dataframe(label="Pick #2", interactive=False, type="pandas")
+                    sugg3 = gr.Dataframe(label="Pick #3", interactive=False, type="pandas")
 
                 with gr.Row():
                     pick_idx = gr.Slider(1, 3, value=1, step=1, label="Carousel: show Pick #")
@@ -717,8 +767,8 @@ with gr.Blocks(title="Efficient Portfolio Advisor", css="""
                 pick_msg = gr.Markdown("")
 
                 gr.Markdown("### Efficient alternatives on the CML")
-                eff_same_sigma_tbl = gr.Dataframe(label="Efficient: Same σ", interactive=False)
-                eff_same_mu_tbl    = gr.Dataframe(label="Efficient: Same μ", interactive=False)
+                eff_same_sigma_tbl = gr.Dataframe(label="Efficient: Same σ", interactive=False, type="pandas")
+                eff_same_mu_tbl    = gr.Dataframe(label="Efficient: Same μ", interactive=False, type="pandas")
 
         run_btn.click(
             fn=compute,
@@ -747,9 +797,5 @@ with gr.Blocks(title="Efficient Portfolio Advisor", css="""
         )
 
 if __name__ == "__main__":
-    # Important for HF Spaces proxy
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=int(os.environ.get("PORT", 7860)),
-        show_error=True,
-    )
+    # On HF Spaces you don't need share=True; binding to 0.0.0.0 is enough.
+    demo.launch(server_name="0.0.0.0", server_port=7860)