Update app.py

app.py

@@ -1,4 +1,3 @@
-
 import os, io, math, json, warnings
 warnings.filterwarnings("ignore")
 
@@ -106,7 +105,6 @@ def _extract_close(df: pd.DataFrame) -> pd.DataFrame:
                 return c
             except Exception:
                 pass
-        # fallback: take first level
         lvl0 = list(dict.fromkeys(df.columns.get_level_values(0)))
         return df.xs(lvl0[0], axis=1, level=0)
     else:
@@ -119,7 +117,7 @@ def _extract_close(df: pd.DataFrame) -> pd.DataFrame:
         return df
 
 def fetch_prices_monthly(tickers: List[str], years: int) -> pd.DataFrame:
-    tickers = list(dict.fromkeys([t for t in tickers if t]))  # unique, keep order
+    tickers = list(dict.fromkeys([t 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()
@@ -136,11 +134,9 @@ def fetch_prices_monthly(tickers: List[str], years: int) -> pd.DataFrame:
     if isinstance(df, pd.DataFrame):
         df = _extract_close(df)
     df = df.dropna(how="all").fillna(method="ffill")
-    # When single ticker, columns might be 1 col named by ticker or "Close"
     if df.shape[1] == 1:
         col = df.columns[0]
         if col in ("Close", "Adj Close"):
-            # rename to ticker if only one requested
             if len(tickers) == 1:
                 df.columns = [tickers[0]]
     return df
@@ -156,7 +152,6 @@ def get_aligned_monthly_returns(symbols: List[str], years: int) -> Tuple[pd.Data
     want = list(dict.fromkeys(uniq + MARKET_CANDIDATES))
     px = fetch_prices_monthly(want, years)
     rets = monthly_returns(px)
-    # pick first available market
     market = None
     for m in MARKET_CANDIDATES:
         if m in rets.columns:
@@ -232,11 +227,28 @@ def portfolio_stats(weights: Dict[str, float],
     return beta_p, er_capm, sigma_p
 
 # ==============================
-# Plot CML with CAPM point
+# Efficient points on the CML (back again)
+# ==============================
+def efficient_same_sigma(sigma_target: float, rf_ann: float, erp_ann: float, sigma_mkt: float):
+    if sigma_mkt <= 1e-12:
+        return 0.0, 1.0, rf_ann
+    a = sigma_target / sigma_mkt  # 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) -> Image.Image:
+             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)
@@ -253,6 +265,12 @@ def plot_cml(rf_ann: float, erp_ann: float, sigma_mkt: float,
     mu_user = capm_er(user_beta, rf_ann, erp_ann)
     plt.scatter([_pct(sig_user)], [_pct(mu_user)], label="Your CAPM point", s=35)
 
+    # 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)")
+
     # Optional suggestion point
     if suggestion is not None:
         plt.scatter([_pct(float(suggestion["sigma"]))],
@@ -366,7 +384,6 @@ 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)))}
-    # normalize just in case
     s = sum(abs(v) for v in wmap.values()) or 1.0
     return {k: v / s for k, v in wmap.items()}
 
@@ -374,7 +391,6 @@ def pick_top3_for_bucket(df: pd.DataFrame, bucket: str) -> List[Dict]:
     cand = select_bucket_candidates(df, bucket)
     if cand.empty:
         return []
-    # Rank by embedding similarity to a short query
     query_map = {
         "Low": "low risk, stable portfolio, conservative volatility",
         "Medium": "balanced risk portfolio, moderate volatility",
@@ -422,7 +438,7 @@ 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)  # also clears dropdown
+    return new_table, msg, gr.update(value=None)
 
 def lock_ticker_column(tb: pd.DataFrame):
     if tb is None or len(tb) == 0:
@@ -446,7 +462,9 @@ def set_horizon(years: float):
 
 def build_summary_md(lookback, rf_code, rf, erp, sigma_mkt,
                      beta_p, er_capm, sigma_cml_user,
-                     market_sym) -> str:
+                     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}")
@@ -459,6 +477,11 @@ def build_summary_md(lookback, rf_code, rf, erp, sigma_mkt,
     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:
@@ -511,7 +534,11 @@ def compute(years_lookback: int,
 
     # ---------- 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  # plotted, ensures point on CML
+    sigma_user_on_cml = abs(beta_p) * sigma_mkt  # on CML
+
+    # ---------- 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)
 
     # ---------- positions table ----------
     rows = []
@@ -552,7 +579,9 @@ def compute(years_lookback: int,
         "rf": float(rf_ann),
         "erp": float(erp_ann),
         "sigma_mkt": float(sigma_mkt),
-        "user_beta": float(beta_p)
+        "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)),
     }
 
     # ---------- decide which suggestion to show initially ----------
@@ -562,12 +591,19 @@ def compute(years_lookback: int,
     pick = picks_list[pick_idx] if pick_idx < len(picks_list) else (picks_list[0] if picks_list else None)
 
     # ---------- plot ----------
-    img = plot_cml(rf_ann, erp_ann, sigma_mkt, beta_p, suggestion=pick)
+    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
+        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
     )
 
     # ---------- suggestion UI ----------
@@ -591,7 +627,12 @@ def update_suggestion(risk: str, pick_name: str, state: dict):
     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]
-    img = plot_cml(state["rf"], state["erp"], state["sigma_mkt"], state["user_beta"], suggestion=pick)
+    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")
+    )
     sug_md = suggestion_metrics_md(pick)
     sug_table = pack_suggestion_table(pick, state.get("gross", 0.0))
     return img, sug_md, sug_table
@@ -607,8 +648,8 @@ with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
     gr.Markdown(
         "## Efficient Portfolio Advisor\n"
         "Search symbols, enter **dollar amounts**, set horizon. "
-        "Returns are from Yahoo Finance (monthly). Risk-free is from FRED. "
-        "Plot shows **CAPM point on the CML** (no historical returns plotted)."
+        "Returns use Yahoo Finance monthly data; risk-free from FRED. "
+        "Plot shows **CAPM point on the CML** plus efficient CML points."
     )
 
     with gr.Row():
@@ -663,7 +704,6 @@ with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
     # --- wiring ---
     def do_search(query):
         note, options = search_tickers_cb(query)
-        # Clear previous selection to avoid “not in choices”
         return note, gr.update(choices=options, value=None)
 
     search_btn.click(fn=do_search, inputs=q, outputs=[search_note, matches])
@@ -677,7 +717,6 @@ with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
         outputs=[plot, summary, universe_msg, positions, state, risk_selector, pick_selector, sugg_metrics, suggestions]
     )
 
-    # Update suggestion view without recomputing moments
     risk_selector.change(
         fn=update_suggestion,
         inputs=[risk_selector, pick_selector, state],