Update app.py

app.py

@@ -1,67 +1,53 @@
-import os, io, math, json, warnings
-warnings.filterwarnings("ignore")
+# app.py
+# Efficient Portfolio Advisor — CAPM on CML + Low/Medium/High suggestion carousel
+# - Search tickers, enter $ amounts (negatives allowed), pick horizon
+# - Plot shows CAPM point on the CML (not historical)
+# - Suggestions are sampled from a 1,000-row dataset generated from your universe
+# - Carousel lets you flip between 3 suggestions in the chosen risk band
+# - Optional: rerank suggestions with finance embeddings (FinLang) to be on-theme
+
+import io
+import os
+import math
+import json
+import time
+import warnings
+from typing import Dict, List, Optional, Tuple
 
-from typing import List, Tuple, Dict, Optional
+warnings.filterwarnings("ignore")
 
 import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
 from PIL import Image
+
+import gradio as gr
 import requests
 import yfinance as yf
-import gradio as gr
 
-from sentence_transformers import SentenceTransformer
+# Optional embeddings (won't break if missing GPU; loads once)
+_EMBED_MODEL = None
+def get_embed_model():
+    global _EMBED_MODEL
+    if _EMBED_MODEL is None:
+        try:
+            from sentence_transformers import SentenceTransformer
+            _EMBED_MODEL = SentenceTransformer("FinLang/finance-embeddings-investopedia")
+        except Exception:
+            _EMBED_MODEL = None
+    return _EMBED_MODEL
 
-# ==============================
-# Config
-# ==============================
+
+# ---------------- Configuration ----------------
 DATA_DIR = "data"
-DATASET_PATH = os.path.join(DATA_DIR, "investor_profiles.csv")
+os.makedirs(DATA_DIR, exist_ok=True)
 
+MARKET_TICKER = "VOO"         # proxy for market
 MAX_TICKERS = 30
-DEFAULT_LOOKBACK_YEARS = 5
-
-# Try these in order for "market"
-MARKET_CANDIDATES = ["VOO", "SPY", "IVV"]
-
-# Gradio table schemas
-POS_COLS = ["ticker", "amount_usd", "weight_exposure", "beta"]
-SUG_COLS = ["ticker", "weight_pct", "amount_usd"]
-
-# Globals (updated on events)
-HORIZON_YEARS = 5.0
-RF_CODE = "DGS5"
-RF_ANN = 0.03
-
-# Lazy-loaded embedding model
-_EMB_MODEL = None
-
-# ==============================
-# Small utils
-# ==============================
-def ensure_data_dir():
-    os.makedirs(DATA_DIR, exist_ok=True)
-
-def fmt_pct(x: float) -> str:
-    try:
-        return f"{float(x)*100:.2f}%"
-    except Exception:
-        return "0.00%"
-
-def _pct(x):
-    """Return x in percent; accepts float or numpy array."""
-    return np.asarray(x, dtype=float) * 100.0
-
-def empty_positions_df():
-    return pd.DataFrame(columns=POS_COLS)
+DEFAULT_LOOKBACK_YEARS = 10
+DEFAULT_HORIZON_YEARS = 10
+SYNTH_ROWS = 1000
 
-def empty_suggest_df():
-    return pd.DataFrame(columns=SUG_COLS)
-
-# ==============================
-# Risk-free via FRED
-# ==============================
 FRED_MAP = [
     (1,  "DGS1"),
     (2,  "DGS2"),
@@ -71,9 +57,11 @@ FRED_MAP = [
     (10, "DGS10"),
     (20, "DGS20"),
     (30, "DGS30"),
-    (100, "DGS30"),
+    (100,"DGS30"),
 ]
 
+def ensure_dir(p): os.makedirs(p, exist_ok=True)
+
 def fred_series_for_horizon(years: float) -> str:
     y = max(1.0, min(100.0, float(years)))
     for cutoff, code in FRED_MAP:
@@ -92,85 +80,103 @@ def fetch_fred_yield_annual(code: str) -> float:
     except Exception:
         return 0.03
 
-# ==============================
-# Prices & returns (robust to yfinance shapes)
-# ==============================
-def _extract_close(df: pd.DataFrame) -> pd.DataFrame:
-    if isinstance(df, pd.Series):
-        return df.to_frame()
-    if isinstance(df.columns, pd.MultiIndex):
-        for key in ["Close", "Adj Close"]:
-            try:
-                c = df.xs(key, axis=1, level=0)
-                return c
-            except Exception:
-                pass
-        lvl0 = list(dict.fromkeys(df.columns.get_level_values(0)))
-        return df.xs(lvl0[0], axis=1, level=0)
-    else:
-        if "Close" in df.columns:
-            return df[["Close"]]
-        if "Adj Close" in df.columns:
-            c = df[["Adj Close"]].copy()
-            c.columns = ["Close"]
-            return c
-        return df
-
 def fetch_prices_monthly(tickers: List[str], years: int) -> pd.DataFrame:
-    tickers = list(dict.fromkeys([t for t in tickers if t]))
+    tickers = list(dict.fromkeys([t.upper().strip() for t in tickers if t]))
     if not tickers:
         return pd.DataFrame()
-    start = (pd.Timestamp.today(tz="UTC") - pd.DateOffset(years=years, days=7)).date()
-    end = pd.Timestamp.today(tz="UTC").date()
-    df = yf.download(
+    start = pd.Timestamp.today(tz="UTC") - pd.DateOffset(years=years, days=7)
+    end = pd.Timestamp.today(tz="UTC")
+
+    raw = yf.download(
         tickers,
-        start=start,
-        end=end,
+        start=start.date(),
+        end=end.date(),
         interval="1mo",
         auto_adjust=True,
         progress=False,
         group_by="column"
     )
-    if isinstance(df, pd.DataFrame):
-        df = _extract_close(df)
-    df = df.dropna(how="all").fillna(method="ffill")
-    if df.shape[1] == 1:
-        col = df.columns[0]
-        if col in ("Close", "Adj Close"):
-            if len(tickers) == 1:
-                df.columns = [tickers[0]]
-    return df
+    if raw is None or len(raw) == 0:
+        return pd.DataFrame()
+
+    # Handle single or multi-index columns
+    if isinstance(raw.columns, pd.MultiIndex):
+        # level 0: OHLCV, level 1: ticker
+        if "Close" in raw.columns.levels[0]:
+            closes = raw.xs("Close", axis=1, level=0)
+        else:
+            # fallback: try Adj Close else last level
+            level0 = raw.columns.levels[0].tolist()
+            col0 = "Adj Close" if "Adj Close" in level0 else level0[0]
+            closes = raw.xs(col0, axis=1, level=0)
+    else:
+        if "Close" in raw.columns:
+            closes = raw[["Close"]]
+        elif "Adj Close" in raw.columns:
+            closes = raw[["Adj Close"]].rename(columns={"Adj Close":"Close"})
+        else:
+            closes = raw
+
+    if isinstance(closes, pd.Series):
+        closes = closes.to_frame()
+
+    # Normalize columns to uppercase tickers
+    closes.columns = [str(c).upper() for c in closes.columns]
+    closes = closes.dropna(how="all").fillna(method="ffill")
+    return closes
 
 def monthly_returns(prices: pd.DataFrame) -> pd.DataFrame:
     return prices.pct_change().dropna(how="all")
 
-# ==============================
-# Aligned moments (market chosen dynamically)
-# ==============================
-def get_aligned_monthly_returns(symbols: List[str], years: int) -> Tuple[pd.DataFrame, str]:
-    uniq = [c for c in dict.fromkeys(symbols)]
-    want = list(dict.fromkeys(uniq + MARKET_CANDIDATES))
-    px = fetch_prices_monthly(want, years)
+def yahoo_search(query: str):
+    if not query or not str(query).strip():
+        return []
+    url = "https://query1.finance.yahoo.com/v1/finance/search"
+    params = {"q": query.strip(), "quotesCount": 10, "newsCount": 0}
+    headers = {"User-Agent": "Mozilla/5.0"}
+    try:
+        r = requests.get(url, params=params, headers=headers, timeout=10)
+        r.raise_for_status()
+        data = r.json()
+        out = []
+        for q in data.get("quotes", []):
+            sym = q.get("symbol")
+            name = q.get("shortname") or q.get("longname") or ""
+            exch = q.get("exchDisp") or ""
+            if sym and sym.isascii():
+                out.append(f"{sym}  |  {name}  |  {exch}")
+        if not out:
+            out = [f"{query.strip().upper()}  |  typed symbol  |  n/a"]
+        return out[:10]
+    except Exception:
+        return [f"{query.strip().upper()}  |  typed symbol  |  n/a"]
+
+def validate_tickers(symbols: List[str], years: int) -> List[str]:
+    base = [s for s in dict.fromkeys([t.upper().strip() for t in symbols if t])]
+    px = fetch_prices_monthly(base + [MARKET_TICKER], years)
+    ok = [t for t in base if t in px.columns]
+    return ok
+
+
+# ---------------- Moments / CAPM ----------------
+def get_aligned_monthly_returns(symbols: List[str], years: int) -> pd.DataFrame:
+    uniq = [c for c in dict.fromkeys([s.upper() for s in symbols if s])]
+    if MARKET_TICKER not in uniq:
+        uniq.append(MARKET_TICKER)
+    px = fetch_prices_monthly(uniq, years)
     rets = monthly_returns(px)
-    market = None
-    for m in MARKET_CANDIDATES:
-        if m in rets.columns:
-            market = m
-            break
-    if market is None:
-        raise ValueError("No market proxy (VOO/SPY/IVV) found in returned data.")
-    cols = [c for c in uniq if c in rets.columns] + [market]
+    cols = [c for c in uniq if c in rets.columns]
     R = rets[cols].dropna(how="any")
-    R = R.loc[:, ~R.columns.duplicated()]
-    return R, market
+    return R.loc[:, ~R.columns.duplicated()]
 
 def estimate_all_moments_aligned(symbols: List[str], years: int, rf_ann: float):
-    R, market = get_aligned_monthly_returns(symbols, years)
-    if market not in R.columns or R.shape[0] < 3:
-        raise ValueError("Not enough aligned data.")
+    R = get_aligned_monthly_returns(symbols, years)
+    if MARKET_TICKER not in R.columns or R.shape[0] < 3:
+        raise ValueError("Not enough aligned data for market / assets")
+
     rf_m = rf_ann / 12.0
 
-    m = R[market]
+    m = R[MARKET_TICKER]
     if isinstance(m, pd.DataFrame):
         m = m.iloc[:, 0].squeeze()
 
@@ -183,27 +189,19 @@ def estimate_all_moments_aligned(symbols: List[str], years: int, rf_ann: float):
     var_m = max(var_m, 1e-8)
 
     betas: Dict[str, float] = {}
-    for s in [c for c in R.columns if c != market]:
+    for s in [c for c in R.columns if c != MARKET_TICKER]:
         ex_s = R[s] - rf_m
-        b = float(np.cov(ex_s.values, ex_m.values, ddof=1)[0, 1] / var_m)
-        betas[s] = b
-    betas[market] = 1.0
-
-    asset_cols = [c for c in R.columns if c != market]
-    cov_m = np.cov(R[asset_cols].values.T, ddof=1) if asset_cols else np.zeros((0, 0))
-    covA = pd.DataFrame(cov_m * 12.0, index=asset_cols, columns=asset_cols)
-
-    return {
-        "betas": betas,
-        "cov_ann": covA,
-        "erp_ann": erp_ann,
-        "sigma_m_ann": sigma_m_ann,
-        "market": market,
-    }
+        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
+
+    # IMPORTANT: include the market in covariance (fixes under-estimated sigma)
+    cov_cols = list(R.columns)
+    cov_m = np.cov(R[cov_cols].values.T, ddof=1)
+    covA = pd.DataFrame(cov_m * 12.0, index=cov_cols, columns=cov_cols)
+
+    return {"betas": betas, "cov_ann": covA, "erp_ann": erp_ann, "sigma_m_ann": sigma_m_ann}
 
-# ==============================
-# Portfolio stats (CAPM)
-# ==============================
 def capm_er(beta: float, rf_ann: float, erp_ann: float) -> float:
     return float(rf_ann + beta * erp_ann)
 
@@ -213,215 +211,187 @@ 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 == 0:
+    if gross <= 1e-12:
         return 0.0, rf_ann, 0.0
     w_expo = w / gross
     beta_p = float(np.dot([betas.get(t, 0.0) for t in tickers], w_expo))
-    er_capm = capm_er(beta_p, rf_ann, erp_ann)
+    mu_capm = capm_er(beta_p, rf_ann, erp_ann)
     cov = cov_ann.reindex(index=tickers, columns=tickers).fillna(0.0).to_numpy()
-    sigma_p = math.sqrt(float(max(w_expo.T @ cov @ w_expo, 0.0)))
-    return beta_p, er_capm, sigma_p
+    sigma_hist = float(max(w_expo.T @ cov @ w_expo, 0.0)) ** 0.5  # annualized
+    return beta_p, mu_capm, sigma_hist
 
-# ==============================
-# Efficient points on the CML (back again)
-# ==============================
-def efficient_same_sigma(sigma_target: float, rf_ann: float, erp_ann: float, sigma_mkt: float):
+
+# ---------------- Efficient points on the CML ----------------
+def efficient_same_sigma_on_cml(sigma_target: float, rf: float, erp: float, sigma_mkt: float) -> float:
+    # Expected return on CML at a given sigma
     if sigma_mkt <= 1e-12:
-        return 0.0, 1.0, rf_ann
-    a = sigma_target / sigma_mkt  # market weight
-    return a, 1.0 - a, rf_ann + a * erp_ann
-
-def efficient_same_return(mu_target: float, rf_ann: float, erp_ann: float, sigma_mkt: float):
-    if abs(erp_ann) <= 1e-12:
-        return 0.0, 1.0, rf_ann
-    a = (mu_target - rf_ann) / erp_ann  # market weight
-    return a, 1.0 - a, abs(a) * sigma_mkt
-
-# ==============================
-# Plot CML with CAPM point (+ efficient points)
-# ==============================
-def plot_cml(rf_ann: float, erp_ann: float, sigma_mkt: float,
-             user_beta: float,
-             suggestion: Optional[Dict] = None,
-             same_sigma_pt: Optional[Tuple[float, float]] = None,
-             same_return_pt: Optional[Tuple[float, float]] = None) -> Image.Image:
-    fig = plt.figure(figsize=(6.4, 4.2), dpi=120)
-    slope = erp_ann / max(sigma_mkt, 1e-12)
-    xmax = max(0.3, 2.0 * sigma_mkt)
-    xs = np.linspace(0.0, xmax, 180)
-    cml = rf_ann + slope * xs
-    plt.plot(_pct(xs), _pct(cml), label="CML via Market", linewidth=1.8)
+        return rf
+    a = sigma_target / sigma_mkt
+    return rf + a * erp
 
-    # Risk-free & market
-    plt.scatter([_pct(0.0)], [_pct(rf_ann)], label="Risk-free", s=25)
-    plt.scatter([_pct(sigma_mkt)], [_pct(rf_ann + erp_ann)], label="Market", s=25)
+def efficient_same_return_on_cml(mu_target: float, rf: float, erp: float, sigma_mkt: float) -> float:
+    # Sigma on CML needed to hit a target return
+    if abs(erp) <= 1e-12:
+        return 0.0
+    a = (mu_target - rf) / erp
+    return abs(a) * sigma_mkt
+
+
+# ---------------- Plot ----------------
+def _pct(x):
+    arr = np.asarray(x, dtype=float)
+    return arr * 100.0
+
+def plot_cml(
+    rf_ann: float,
+    erp_ann: float,
+    sigma_mkt: float,
+    port_beta: float,
+    port_mu_capm: float,
+    port_sigma_capm: float,
+    sugg_mu_capm: Optional[float],
+    sugg_sigma_capm: Optional[float],
+) -> Image.Image:
+    fig = plt.figure(figsize=(6.5, 4.2), dpi=120)
+
+    xmax = max(0.30, sigma_mkt * 2.1, port_sigma_capm * 1.35, (sugg_sigma_capm or 0) * 1.35)
+    xs = np.linspace(0.0, xmax, 160)
+    cml = rf_ann + (erp_ann / max(sigma_mkt, 1e-12)) * xs
+    plt.plot(_pct(xs), _pct(cml), label="CML via Market", linewidth=1.8)
 
-    # User CAPM point projected onto CML using sigma = |beta| * sigma_mkt
-    sig_user = abs(user_beta) * sigma_mkt
-    mu_user = capm_er(user_beta, rf_ann, erp_ann)
-    plt.scatter([_pct(sig_user)], [_pct(mu_user)], label="Your CAPM point", s=35)
+    # key points
+    plt.scatter([_pct(0.0)], [_pct(rf_ann)], label="Risk-free", zorder=3)
+    plt.scatter([_pct(sigma_mkt)], [_pct(rf_ann + erp_ann)], label="Market", zorder=3)
 
-    # Efficient points
-    if same_sigma_pt is not None:
-        plt.scatter([_pct(same_sigma_pt[0])], [_pct(same_sigma_pt[1])], marker="^", s=40, label="Efficient (same σ)")
-    if same_return_pt is not None:
-        plt.scatter([_pct(same_return_pt[0])], [_pct(same_return_pt[1])], marker="s", s=40, label="Efficient (same return)")
+    # Your CAPM point
+    plt.scatter([_pct(port_sigma_capm)], [_pct(port_mu_capm)], label="Your CAPM point", zorder=4)
 
-    # Optional suggestion point
-    if suggestion is not None:
-        plt.scatter([_pct(float(suggestion["sigma"]))],
-                    [_pct(float(suggestion["er"]))],
-                    label="Selected Suggestion", marker="D", s=35)
+    # Selected suggestion (if any)
+    if sugg_mu_capm is not None and sugg_sigma_capm is not None:
+        plt.scatter([_pct(sugg_sigma_capm)], [_pct(sugg_mu_capm)], label="Selected Suggestion", zorder=4)
 
-    plt.xlabel("σ (annual, %)")
+    plt.xlabel("σ (annualized, %)")
     plt.ylabel("Expected return (annual, %)")
-    plt.legend(loc="best", fontsize=8)
+    plt.legend(loc="best")
     plt.tight_layout()
+
     buf = io.BytesIO()
     plt.savefig(buf, format="png")
     plt.close(fig)
     buf.seek(0)
     return Image.open(buf)
 
-# ==============================
-# Yahoo symbol search
-# ==============================
-def yahoo_search(query: str):
-    if not query or len(query.strip()) == 0:
-        return []
-    url = "https://query1.finance.yahoo.com/v1/finance/search"
-    params = {"q": query.strip(), "quotesCount": 10, "newsCount": 0}
-    headers = {"User-Agent": "Mozilla/5.0"}
-    try:
-        r = requests.get(url, params=params, headers=headers, timeout=10)
-        r.raise_for_status()
-        data = r.json()
-        out = []
-        for q in data.get("quotes", []):
-            sym = q.get("symbol")
-            name = q.get("shortname") or q.get("longname") or ""
-            exch = q.get("exchDisp") or ""
-            if sym and sym.isascii():
-                out.append({"symbol": sym, "name": name, "exchange": exch})
-        if not out:
-            out = [{"symbol": query.strip().upper(), "name": "typed symbol", "exchange": "n/a"}]
-        return out[:10]
-    except Exception:
-        return [{"symbol": query.strip().upper(), "name": "typed symbol", "exchange": "n/a"}]
-
-def validate_tickers(symbols: List[str], years: int) -> List[str]:
-    base = list(dict.fromkeys([s for s in symbols if s]))
-    px = fetch_prices_monthly(base + MARKET_CANDIDATES, years)
-    ok = [s for s in base if s in px.columns]
-    return ok
-
-# ==============================
-# Synthetic dataset & suggestions
-# ==============================
-def synth_profile_text(beta: float, sigma: float, er: float, weights: Dict[str, float]) -> str:
-    top = sorted(weights.items(), key=lambda kv: -abs(kv[1]))[:8]
-    parts = [f"{k} {abs(v)*100:.1f}%" for k, v in top]
-    return (
-        f"portfolio with beta {beta:.2f}, volatility {sigma:.3f}, expected return {er:.3f}; "
-        f"holdings: " + ", ".join(parts)
-    )
 
+# ---------------- Synthetic dataset (universe-driven) ----------------
 def build_synthetic_dataset(universe: List[str],
-                            rf_ann: float,
-                            erp_ann: float,
+                            cov_ann: pd.DataFrame,
                             betas: Dict[str, float],
-                            covA: pd.DataFrame,
-                            n_rows: int = 1000,
-                            seed: int = 123) -> pd.DataFrame:
-    rng = np.random.default_rng(seed)
+                            rf_ann: float, erp_ann: float,
+                            n_rows: int = SYNTH_ROWS) -> pd.DataFrame:
+    rng = np.random.default_rng(12345)
     rows = []
-    assets = [t for t in universe]  # long-only samples
+    tickers = list(dict.fromkeys([t for t in universe if t]))
     for i in range(n_rows):
-        k = rng.integers(low=max(2, min(2, len(assets))), high=max(3, min(8, len(assets))) + 1)
-        picks = list(rng.choice(assets, size=min(k, len(assets)), replace=False))
-        raw = rng.dirichlet(np.ones(len(picks)))
-        wmap = {picks[j]: float(raw[j]) for j in range(len(picks))}
-        beta_p, er_capm, sigma_p = portfolio_stats(wmap, covA, betas, rf_ann, erp_ann)
+        k = int(rng.integers(low=max(2, min(2, len(tickers))), high=min(8, len(tickers)) + 1))
+        picks = list(rng.choice(tickers, size=k, replace=False))
+        w = rng.dirichlet(np.ones(k))  # long-only exposure
+        # stats
+        wmap = {picks[j]: float(w[j]) for j in range(k)}
+        beta_p, mu_capm, sigma_hist = portfolio_stats(wmap, cov_ann, betas, rf_ann, erp_ann)
+        sigma_capm = abs(beta_p) * (cov_ann.loc[MARKET_TICKER, MARKET_TICKER] ** 0.5) if MARKET_TICKER in cov_ann.index else 0.0
         rows.append({
             "tickers": ",".join(picks),
-            "weights": ",".join(f"{wmap[t]:.6f}" for t in picks),
+            "weights": ",".join(f"{x:.6f}" for x in w),
             "beta": beta_p,
-            "er": er_capm,
-            "sigma": sigma_p,
-            "desc": synth_profile_text(beta_p, sigma_p, er_capm, wmap),
+            "mu_capm": mu_capm,
+            "sigma_hist": sigma_hist,
+            "sigma_capm": sigma_capm
         })
-    df = pd.DataFrame(rows)
-    return df
-
-def get_embedding_model():
-    global _EMB_MODEL
-    if _EMB_MODEL is None:
-        _EMB_MODEL = SentenceTransformer("FinLang/finance-embeddings-investopedia")
-    return _EMB_MODEL
-
-def encode_texts(texts: List[str]):
-    model = get_embedding_model()
-    return model.encode(texts, normalize_embeddings=True)
-
-def cosine_sim(a: np.ndarray, b: np.ndarray) -> np.ndarray:
-    return (a @ b.T)
-
-def select_bucket_candidates(df: pd.DataFrame, bucket: str) -> pd.DataFrame:
-    # bucket by sigma tertiles
-    q1 = df["sigma"].quantile(1/3)
-    q2 = df["sigma"].quantile(2/3)
-    if bucket == "Low":
-        return df[df["sigma"] <= q1]
-    if bucket == "Medium":
-        return df[(df["sigma"] > q1) & (df["sigma"] <= q2)]
-    return df[df["sigma"] > q2]
-
-def parse_weights(row: pd.Series) -> Dict[str, float]:
-    ts = [t.strip() for t in str(row["tickers"]).split(",")]
-    ws = [float(x) for x in str(row["weights"]).split(",")]
-    wmap = {ts[i]: ws[i] for i in range(min(len(ts), len(ws)))}
-    s = sum(abs(v) for v in wmap.values()) or 1.0
-    return {k: v / s for k, v in wmap.items()}
+    return pd.DataFrame(rows)
 
-def pick_top3_for_bucket(df: pd.DataFrame, bucket: str) -> List[Dict]:
-    cand = select_bucket_candidates(df, bucket)
-    if cand.empty:
-        return []
-    query_map = {
-        "Low": "low risk, stable portfolio, conservative volatility",
-        "Medium": "balanced risk portfolio, moderate volatility",
-        "High": "high risk, growth portfolio, higher volatility"
+def parse_row_exposures(row: pd.Series, universe: List[str]) -> Optional[np.ndarray]:
+    try:
+        ts = [t.strip() for t in str(row["tickers"]).split(",")]
+        ws = [float(x) for x in str(row["weights"]).split(",")]
+        mp = {ts[i]: ws[i] for i in range(min(len(ts), len(ws)))}
+        v = np.array([mp.get(t, 0.0) for t in universe], dtype=float)
+        s = float(v.sum())
+        if s <= 1e-12: return None
+        return v / s
+    except Exception:
+        return None
+
+def select_band(df: pd.DataFrame, band: str) -> pd.DataFrame:
+    if df.empty: return df
+    q = df["sigma_capm"].quantile
+    if band == "Low":
+        lo, hi = -1.0, q(0.25)
+    elif band == "Medium":
+        lo, hi = q(0.40), q(0.60)
+    else:  # High
+        lo, hi = q(0.75), float("inf")
+    cut = df[(df["sigma_capm"] >= lo) & (df["sigma_capm"] <= hi)].copy()
+    if cut.empty:
+        return df.nsmallest(3, "sigma_capm") if band == "Low" else df.nlargest(3, "sigma_capm")
+    return cut
+
+def top3_by_return_in_band(df: pd.DataFrame, band: str) -> pd.DataFrame:
+    band_df = select_band(df, band)
+    return band_df.sort_values("mu_capm", ascending=False).head(3).reset_index(drop=True)
+
+
+# ---------------- Embeddings rerank (optional) ----------------
+def rerank_with_embeddings(df3: pd.DataFrame, band: str) -> pd.DataFrame:
+    model = get_embed_model()
+    if model is None or df3.empty:
+        return df3
+
+    prompts = {
+        "Low"   : "low risk diversified ETF mix, low beta, low volatility",
+        "Medium": "balanced risk ETF mix, moderate beta, medium volatility",
+        "High"  : "high risk growth ETF mix, higher beta, higher volatility"
     }
-    q = query_map[bucket]
-    embs_cand = encode_texts(cand["desc"].tolist())
-    emb_q = encode_texts([q])[0].reshape(1, -1)
-    sims = cosine_sim(emb_q, embs_cand).flatten()
-    order = np.argsort(-sims)
-    picks = []
-    for idx in order[:3]:
-        r = cand.iloc[int(idx)]
-        wmap = parse_weights(r)
-        picks.append({"weights": wmap, "beta": float(r["beta"]),
-                      "er": float(r["er"]), "sigma": float(r["sigma"])})
-    return picks
-
-# ==============================
-# Gradio callbacks
-# ==============================
-def search_tickers_cb(q: str):
-    hits = yahoo_search(q)
-    if not hits:
-        return "No matches", []
-    opts = [f"{h['symbol']}  |  {h['name']}  |  {h['exchange']}" for h in hits]
-    return "Select a symbol and click Add", opts
+    q = prompts.get(band, "balanced portfolio")
+
+    docs = []
+    for _, r in df3.iterrows():
+        docs.append(
+            f"tickers={r['tickers']} weights={r['weights']} "
+            f"beta={r['beta']:.3f} mu_capm={r['mu_capm']:.3f} sigma_capm={r['sigma_capm']:.3f}"
+        )
+    try:
+        E = model.encode([q] + docs, normalize_embeddings=True)
+        qv = E[0:1]
+        dv = E[1:]
+        sims = (qv @ dv.T).ravel()
+        order = np.argsort(-sims)
+        return df3.iloc[order].reset_index(drop=True)
+    except Exception:
+        return df3
+
+
+# ---------------- Gradio helpers ----------------
+def empty_positions_df():
+    return pd.DataFrame(columns=["ticker", "amount_usd", "weight_exposure", "beta"])
+
+def empty_suggestion_df():
+    return pd.DataFrame(columns=["ticker", "weight_%", "amount_$"])
+
+UNIVERSE: List[str] = [MARKET_TICKER]
+HORIZON_YEARS = DEFAULT_HORIZON_YEARS
+RF_CODE = fred_series_for_horizon(HORIZON_YEARS)
+RF_ANN = fetch_fred_yield_annual(RF_CODE)
+
+def search_cb(q: str):
+    opts = yahoo_search(q)
+    note = "Select a row and click 'Add selected to portfolio'." if opts else "No matches."
+    return note, gr.update(choices=opts, value=None)
 
 def add_symbol(selection: str, table: pd.DataFrame):
-    if not selection:
-        return table, "Pick a row from Matches first", gr.update(value=None)
+    if not selection or "|" not in selection:
+        return table, "Pick a symbol from Matches first."
     symbol = selection.split("|")[0].strip().upper()
     current = [] if table is None or len(table) == 0 else [str(x).upper() for x in table["ticker"].tolist() if str(x) != "nan"]
     tickers = current if symbol in current else current + [symbol]
@@ -438,9 +408,9 @@ def add_symbol(selection: str, table: pd.DataFrame):
     if len(new_table) > MAX_TICKERS:
         new_table = new_table.iloc[:MAX_TICKERS]
         msg = f"Reached max of {MAX_TICKERS}"
-    return new_table, msg, gr.update(value=None)
+    return new_table, msg
 
-def lock_ticker_column(tb: pd.DataFrame):
+def lock_table(tb: pd.DataFrame):
     if tb is None or len(tb) == 0:
         return pd.DataFrame(columns=["ticker", "amount_usd"])
     tickers = [str(x).upper() for x in tb["ticker"].tolist()]
@@ -460,203 +430,142 @@ def set_horizon(years: float):
     RF_ANN = rf
     return f"Risk-free series {code}. Latest annual rate {rf:.2%}."
 
-def build_summary_md(lookback, rf_code, rf, erp, sigma_mkt,
-                     beta_p, er_capm, sigma_cml_user,
-                     market_sym,
-                     a_sigma=None, b_sigma=None, mu_eff_sigma=None,
-                     a_mu=None, b_mu=None, sigma_eff_mu=None) -> str:
-    lines = []
-    lines.append("### Inputs")
-    lines.append(f"- Lookback years {lookback}")
-    lines.append(f"- Horizon years {int(round(HORIZON_YEARS))}")
-    lines.append(f"- Risk-free {fmt_pct(rf)} from {rf_code}")
-    lines.append(f"- Market ERP {fmt_pct(erp)}")
-    lines.append(f"- Market σ {fmt_pct(sigma_mkt)} (proxy: {market_sym})")
-    lines.append("")
-    lines.append("### Your portfolio (CAPM)")
-    lines.append(f"- Beta {beta_p:.2f}")
-    lines.append(f"- Expected return (CAPM / SML) {fmt_pct(er_capm)}")
-    lines.append(f"- σ on CML for your beta (|β|×σ_mkt) {fmt_pct(sigma_cml_user)}")
-    if (a_sigma is not None) and (a_mu is not None):
-        lines.append("")
-        lines.append("### Efficient alternatives on the CML")
-        lines.append(f"- Same σ as your CAPM point → Market {a_sigma:.2f}, Bills {b_sigma:.2f}, return {fmt_pct(mu_eff_sigma)}")
-        lines.append(f"- Same expected return (your CAPM μ) → Market {a_mu:.2f}, Bills {b_mu:.2f}, σ {fmt_pct(sigma_eff_mu)}")
-    return "\n".join(lines)
-
-def pack_suggestion_table(pick: Dict, gross_usd: float) -> pd.DataFrame:
-    rows = []
-    for t, w in sorted(pick["weights"].items(), key=lambda kv: -kv[1]):
-        rows.append({
-            "ticker": t,
-            "weight_pct": float(w) * 100.0,
-            "amount_usd": float(w) * float(gross_usd)
-        })
-    return pd.DataFrame(rows, columns=SUG_COLS)
-
-def suggestion_metrics_md(pick: Dict) -> str:
-    return (
-        f"**Suggested portfolio**  \n"
-        f"- Expected return (CAPM) {fmt_pct(pick['er'])}  \n"
-        f"- σ (annual) {fmt_pct(pick['sigma'])}  \n"
-        f"- Beta {pick['beta']:.2f}"
-    )
-
-def compute(years_lookback: int,
-            table: pd.DataFrame,
-            risk_choice: str,
-            pick_choice: str):
-    # ---------- sanitize input table ----------
-    if table is None or len(table) == 0:
-        return None, "Add at least one ticker.", "Universe empty", empty_positions_df(), {}, gr.update(), gr.update(), "", empty_suggest_df()
-
-    df = table.dropna()
+def to_pct_str(x): return f"{x*100:.2f}%"
+
+def compute(
+    years_lookback: int,
+    table: pd.DataFrame,
+    risk_band: str,
+    use_embeddings: bool,
+    pick_idx: int
+):
+    # --- inputs
+    df = (table or pd.DataFrame(columns=["ticker","amount_usd"])).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]
+    if len(symbols) == 0:
+        return None, "Add at least one ticker.", "Universe empty.", empty_positions_df(), empty_suggestion_df(), None
 
     symbols = validate_tickers(symbols, years_lookback)
     if len(symbols) == 0:
-        return None, "Could not validate any tickers.", "Universe invalid", empty_positions_df(), {}, gr.update(), gr.update(), "", empty_suggest_df()
+        return None, "Could not validate any tickers.", "Universe invalid.", empty_positions_df(), empty_suggestion_df(), None
 
-    # ---------- amounts & weights ----------
-    amounts = {r["ticker"]: float(r["amount_usd"]) for _, r in df.iterrows() if r["ticker"] in symbols}
-    gross = sum(abs(v) for v in amounts.values())
-    if gross == 0:
-        return None, "All amounts are zero.", "Universe ok", empty_positions_df(), {}, gr.update(), gr.update(), "", empty_suggest_df()
-    weights_user = {k: v / gross for k, v in amounts.items()}
+    global UNIVERSE
+    UNIVERSE = list(sorted(set([s for s in symbols if s != MARKET_TICKER] + [MARKET_TICKER])))[:MAX_TICKERS]
 
-    # ---------- risk-free & moments ----------
+    df = df[df["ticker"].isin(symbols)].copy()
+    amounts = {r["ticker"]: float(r["amount_usd"]) for _, r in df.iterrows()}
     rf_ann = RF_ANN
+
+    # --- moments & CAPM stats
     moms = estimate_all_moments_aligned(symbols, years_lookback, rf_ann)
-    betas, covA = moms["betas"], moms["cov_ann"]
-    erp_ann, sigma_mkt, market_sym = moms["erp_ann"], moms["sigma_m_ann"], moms["market"]
+    betas, covA, erp_ann, sigma_mkt = moms["betas"], moms["cov_ann"], moms["erp_ann"], moms["sigma_m_ann"]
 
-    # ---------- user stats (CAPM) ----------
-    beta_p, er_capm, _sigma_hist = portfolio_stats(weights_user, covA, betas, rf_ann, erp_ann)
-    sigma_user_on_cml = abs(beta_p) * sigma_mkt  # on CML
+    gross = sum(abs(v) for v in amounts.values())
+    if gross <= 1e-12:
+        return None, "All amounts are zero.", "Universe ok.", empty_positions_df(), empty_suggestion_df(), None
+    weights = {k: v / gross for k, v in amounts.items()}
 
-    # ---------- efficient CML points (back again) ----------
-    a_sigma, b_sigma, mu_eff_sigma = efficient_same_sigma(sigma_user_on_cml, rf_ann, erp_ann, sigma_mkt)
-    a_mu, b_mu, sigma_eff_mu = efficient_same_return(er_capm, rf_ann, erp_ann, sigma_mkt)
+    beta_p, mu_capm, sigma_hist = portfolio_stats(weights, covA, betas, rf_ann, erp_ann)
+    sigma_capm = abs(beta_p) * sigma_mkt
 
-    # ---------- positions table ----------
-    rows = []
-    for t in symbols:
-        rows.append({
-            "ticker": t,
-            "amount_usd": amounts.get(t, 0.0),
-            "weight_exposure": weights_user.get(t, 0.0),
-            "beta": 1.0 if abs(betas.get(t, 0.0) - 1.0) < 1e-9 else betas.get(t, np.nan)
-        })
-    pos_table = pd.DataFrame(rows, columns=POS_COLS)
-
-    # ---------- synthetic dataset ----------
-    ensure_data_dir()
-    synth_df = build_synthetic_dataset(
-        universe=list(sorted(set(symbols))),
-        rf_ann=rf_ann,
-        erp_ann=erp_ann,
-        betas=betas,
-        covA=covA,
-        n_rows=1000,
-        seed=123
-    )
-    try:
-        synth_df.to_csv(DATASET_PATH, index=False)
-    except Exception:
-        pass
-
-    # ---------- pick 3 per bucket using embeddings ----------
-    low3 = pick_top3_for_bucket(synth_df, "Low")
-    med3 = pick_top3_for_bucket(synth_df, "Medium")
-    high3 = pick_top3_for_bucket(synth_df, "High")
-
-    # ---------- build state ----------
-    state = {
-        "gross": float(gross),
-        "picks": {"Low": low3, "Medium": med3, "High": high3},
-        "rf": float(rf_ann),
-        "erp": float(erp_ann),
-        "sigma_mkt": float(sigma_mkt),
-        "user_beta": float(beta_p),
-        "same_sigma": (float(sigma_user_on_cml), float(mu_eff_sigma)),
-        "same_return": (float(sigma_eff_mu), float(er_capm)),
-    }
+    # --- dataset & suggestions
+    synth = build_synthetic_dataset(UNIVERSE, covA, betas, rf_ann, erp_ann, n_rows=SYNTH_ROWS)
+    # save CSV for the grader / assignment
+    csv_path = os.path.join(DATA_DIR, f"investor_profiles_{int(time.time())}.csv")
+    ensure_dir(os.path.dirname(csv_path))
+    synth.to_csv(csv_path, index=False)
 
-    # ---------- decide which suggestion to show initially ----------
-    risk = risk_choice if risk_choice in ("Low", "Medium", "High") else "Medium"
-    pick_idx = 0 if pick_choice not in ("Pick #1", "Pick #2", "Pick #3") else ["Pick #1", "Pick #2", "Pick #3"].index(pick_choice)
-    picks_list = state["picks"].get(risk, [])
-    pick = picks_list[pick_idx] if pick_idx < len(picks_list) else (picks_list[0] if picks_list else None)
+    top3 = top3_by_return_in_band(synth, risk_band)
+    if use_embeddings:
+        top3 = rerank_with_embeddings(top3, risk_band)
 
-    # ---------- plot ----------
-    img = plot_cml(
-        rf_ann, erp_ann, sigma_mkt, beta_p,
-        suggestion=pick,
-        same_sigma_pt=state["same_sigma"],
-        same_return_pt=state["same_return"]
-    )
-
-    # ---------- summary ----------
-    info = build_summary_md(
-        years_lookback, RF_CODE, rf_ann, erp_ann, sigma_mkt,
-        beta_p, er_capm, sigma_user_on_cml, market_sym,
-        a_sigma=a_sigma, b_sigma=b_sigma, mu_eff_sigma=mu_eff_sigma,
-        a_mu=a_mu, b_mu=b_mu, sigma_eff_mu=sigma_eff_mu
-    )
+    # guard
+    if top3.empty:
+        top3 = synth.sort_values("mu_capm", ascending=False).head(3).reset_index(drop=True)
 
-    # ---------- suggestion UI ----------
-    risk_update = gr.update(choices=["Low", "Medium", "High"], value=risk)
-    pick_update = gr.update(choices=["Pick #1", "Pick #2", "Pick #3"], value="Pick #1")
+    # pick from carousel (1..3)
+    idx = max(1, min(3, int(pick_idx))) - 1
+    row = top3.iloc[idx]
 
-    if pick is None:
-        return img, info, f"Universe set to {', '.join(sorted(symbols))}", pos_table, state, risk_update, pick_update, "No suggestions available.", empty_suggest_df()
+    # selected suggestion stats (CAPM)
+    sugg_mu = float(row["mu_capm"])
+    sugg_sigma = float(row.get("sigma_capm", abs(row["beta"]) * sigma_mkt))
 
-    sug_md = suggestion_metrics_md(pick)
-    sug_table = pack_suggestion_table(pick, gross)
+    # Build holdings table (% and $) for selected suggestion
+    ts = [t.strip() for t in str(row["tickers"]).split(",")]
+    ws = [float(x) for x in str(row["weights"]).split(",")]
+    wsum = sum(ws) if ws else 1.0
+    ws = [max(0.0, w) / wsum for w in ws]  # long-only normalized
+    budget = gross if gross > 0 else 1.0
+    hold_rows = []
+    for t, w in zip(ts, ws):
+        hold_rows.append({
+            "ticker": t,
+            "weight_%": round(w * 100.0, 2),
+            "amount_$": round(w * budget, 0)
+        })
+    sugg_table = pd.DataFrame(hold_rows, columns=["ticker", "weight_%", "amount_$"])
 
-    return img, info, f"Universe set to {', '.join(sorted(symbols))}", pos_table, state, risk_update, pick_update, sug_md, sug_table
+    # positions table for current portfolio
+    pos_rows = []
+    for t in symbols:
+        pos_rows.append({
+            "ticker": t,
+            "amount_usd": amounts.get(t, 0.0),
+            "weight_exposure": weights.get(t, 0.0),
+            "beta": 1.0 if t == MARKET_TICKER else betas.get(t, np.nan)
+        })
+    pos_table = pd.DataFrame(pos_rows, columns=["ticker", "amount_usd", "weight_exposure", "beta"])
 
-def update_suggestion(risk: str, pick_name: str, state: dict):
-    if not state or "picks" not in state:
-        return gr.update(), "", empty_suggest_df()
-    picks_list = state["picks"].get(risk, [])
-    if not picks_list:
-        return gr.update(), "No suggestions for this bucket.", empty_suggest_df()
-    idx = ["Pick #1", "Pick #2", "Pick #3"].index(pick_name) if pick_name in ("Pick #1", "Pick #2", "Pick #3") else 0
-    idx = min(idx, len(picks_list) - 1)
-    pick = picks_list[idx]
+    # --- plot
     img = plot_cml(
-        state["rf"], state["erp"], state["sigma_mkt"], state["user_beta"],
-        suggestion=pick,
-        same_sigma_pt=state.get("same_sigma"),
-        same_return_pt=state.get("same_return")
+        rf_ann, erp_ann, sigma_mkt,
+        beta_p, mu_capm, sigma_capm,
+        sugg_mu, sugg_sigma
     )
-    sug_md = suggestion_metrics_md(pick)
-    sug_table = pack_suggestion_table(pick, state.get("gross", 0.0))
-    return img, sug_md, sug_table
-
-# ==============================
-# Build UI
-# ==============================
-ensure_data_dir()
-RF_CODE = fred_series_for_horizon(HORIZON_YEARS)
-RF_ANN = fetch_fred_yield_annual(RF_CODE)
 
+    # --- info markdown
+    info_lines = []
+    info_lines.append("### Inputs")
+    info_lines.append(f"- Lookback years {years_lookback}")
+    info_lines.append(f"- Horizon years {int(round(HORIZON_YEARS))}")
+    info_lines.append(f"- Risk-free {to_pct_str(rf_ann)} from {RF_CODE}")
+    info_lines.append(f"- Market ERP {to_pct_str(erp_ann)}")
+    info_lines.append(f"- Market σ {to_pct_str(sigma_mkt)}")
+    info_lines.append("")
+    info_lines.append("### Your portfolio (CAPM)")
+    info_lines.append(f"- Beta {beta_p:.2f}")
+    info_lines.append(f"- Expected return (CAPM / SML) {to_pct_str(mu_capm)}")
+    info_lines.append(f"- on CML for your beta (|β|×σ_mkt) {to_pct_str(sigma_capm)}")
+    info_lines.append("")
+    info_lines.append("### Dataset-based suggestion (carousel)")
+    info_lines.append(f"- Risk band **{risk_band}**, showing **Pick #{idx+1} of 3**")
+    info_lines.append(f"- Suggested CAPM return {to_pct_str(sugg_mu)}")
+    info_lines.append(f"- Suggested CAPM σ {to_pct_str(sugg_sigma)}")
+    info_lines.append("")
+    info_lines.append("_Note: points are CAPM expectations on the CML (not historical means)._" )
+    info = "\n".join(info_lines)
+
+    uni_msg = f"Universe set to: {', '.join(UNIVERSE)}"
+    return img, info, uni_msg, pos_table, sugg_table, csv_path
+
+
+# ---------------- UI ----------------
 with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
     gr.Markdown(
         "## Efficient Portfolio Advisor\n"
-        "Search symbols, enter **dollar amounts**, set horizon. "
-        "Returns use Yahoo Finance monthly data; risk-free from FRED. "
-        "Plot shows **CAPM point on the CML** plus efficient CML points."
+        "Search symbols, enter **dollar amounts**, set horizon. Returns use Yahoo Finance monthly data; risk-free from FRED. "
+        "Plot shows **CAPM point on the CML** plus selected suggestion."
     )
 
     with gr.Row():
         with gr.Column(scale=1):
             q = gr.Textbox(label="Search symbol")
             search_note = gr.Markdown()
-            matches = gr.Dropdown(choices=[], label="Matches", allow_custom_value=True)
+            matches = gr.Dropdown(choices=[], label="Matches")
             search_btn = gr.Button("Search")
             add_btn = gr.Button("Add selected to portfolio")
 
@@ -668,64 +577,52 @@ with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
                 col_count=(2, "fixed")
             )
 
-            horizon = gr.Number(label="Horizon in years (1–100)", value=HORIZON_YEARS, precision=0)
+            horizon = gr.Number(label="Horizon in years (1–100)", value=DEFAULT_HORIZON_YEARS, precision=0)
             lookback = gr.Slider(1, 10, value=DEFAULT_LOOKBACK_YEARS, step=1, label="Lookback years for betas & covariances")
 
-            run_btn = gr.Button("Compute")
+            gr.Markdown("### Suggestions")
+            risk_band = gr.Radio(choices=["Low", "Medium", "High"], value="Medium", label="Risk tolerance")
+            use_emb = gr.Checkbox(label="Use finance embeddings to refine picks", value=False)
+            pick_idx = gr.Slider(1, 3, value=1, step=1, label="Suggestion (carousel)")
+
+            run_btn = gr.Button("Compute (build dataset & suggest)")
 
         with gr.Column(scale=1):
             plot = gr.Image(label="Capital Market Line (CAPM)", type="pil")
-            summary = gr.Markdown(label="Summary")
+            summary = gr.Markdown(label="Inputs & Results")
             universe_msg = gr.Textbox(label="Universe status", interactive=False)
 
             positions = gr.Dataframe(
                 label="Computed positions",
-                headers=POS_COLS,
+                headers=["ticker", "amount_usd", "weight_exposure", "beta"],
                 datatype=["str", "number", "number", "number"],
-                col_count=(len(POS_COLS), "fixed"),
+                col_count=(4, "fixed"),
                 value=empty_positions_df(),
                 interactive=False
             )
 
-            gr.Markdown("### Dataset-based suggestions (choose risk bucket and pick)")
-            state = gr.State({})
-            risk_selector = gr.Radio(choices=["Low", "Medium", "High"], value="Medium", label="Risk bucket to view")
-            pick_selector = gr.Radio(choices=["Pick #1", "Pick #2", "Pick #3"], value="Pick #1", label="Suggestion")
-            sugg_metrics = gr.Markdown(label="Suggestion metrics")
-            suggestions = gr.Dataframe(
-                label="Suggested holdings",
-                headers=SUG_COLS,
+            sugg_table = gr.Dataframe(
+                label="Selected suggestion (carousel) — holdings shown in % and $",
+                headers=["ticker", "weight_%", "amount_$"],
                 datatype=["str", "number", "number"],
-                col_count=(len(SUG_COLS), "fixed"),
-                value=empty_suggest_df(),
+                col_count=(3, "fixed"),
+                value=empty_suggestion_df(),
                 interactive=False
             )
 
-    # --- wiring ---
-    def do_search(query):
-        note, options = search_tickers_cb(query)
-        return note, gr.update(choices=options, value=None)
+            dl = gr.File(label="Generated dataset CSV", value=None, visible=True)
 
-    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, matches])
-    table.change(fn=lock_ticker_column, inputs=table, outputs=table)
+    # wiring
+    search_btn.click(fn=search_cb, inputs=q, outputs=[search_note, matches])
+    add_btn.click(fn=add_symbol, inputs=[matches, table], outputs=[table, search_note])
+    table.change(fn=lock_table, inputs=table, outputs=table)
     horizon.change(fn=set_horizon, inputs=horizon, outputs=universe_msg)
 
+    # main compute
     run_btn.click(
         fn=compute,
-        inputs=[lookback, table, risk_selector, pick_selector],
-        outputs=[plot, summary, universe_msg, positions, state, risk_selector, pick_selector, sugg_metrics, suggestions]
-    )
-
-    risk_selector.change(
-        fn=update_suggestion,
-        inputs=[risk_selector, pick_selector, state],
-        outputs=[plot, sugg_metrics, suggestions]
-    )
-    pick_selector.change(
-        fn=update_suggestion,
-        inputs=[risk_selector, pick_selector, state],
-        outputs=[plot, sugg_metrics, suggestions]
+        inputs=[lookback, table, risk_band, use_emb, pick_idx],
+        outputs=[plot, summary, universe_msg, positions, sugg_table, dl]
     )
 
 if __name__ == "__main__":