Update app.py

app.py

@@ -202,7 +202,7 @@ 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; x=hist σ, y=CAPM E[r]) --------------
+# -------------- plotting --------------
 def _pct(x):
     return np.asarray(x, dtype=float) * 100.0
 
@@ -222,16 +222,13 @@ def plot_cml(rf_ann, erp_ann, sigma_mkt,
     plt.scatter([_pct(0)], [_pct(rf_ann)], label="Risk-free")
     plt.scatter([_pct(sigma_mkt)], [_pct(rf_ann + erp_ann)], label="Market")
 
-    # Your point (y clamped to CML at your σ for display)
     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 (on CML)
     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 sugg_sigma_hist is not None and sugg_mu_capm is not None:
         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)
@@ -256,9 +253,6 @@ def build_synthetic_dataset(universe_user: List[str],
                             erp_ann: float,
                             sigma_mkt: float,
                             n_rows: int = SYNTH_ROWS) -> pd.DataFrame:
-    """
-    Generate long-only mixes **from exactly the user's tickers** (VOO included only if the user holds it).
-    """
     rng = np.random.default_rng(12345)
     assets = list(universe_user)
     if len(assets) == 0:
@@ -343,9 +337,10 @@ def rerank_and_pick_one(df_band: pd.DataFrame,
                 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}"
             )
+        from numpy.linalg import norm
         C = model.encode(cand_texts)
         qv = q.reshape(-1)
-        coss = (C @ qv) / (np.linalg.norm(C, axis=1) * (np.linalg.norm(qv) + 1e-12))
+        coss = (C @ qv) / (norm(C, axis=1) * (norm(qv) + 1e-12))
         coss = np.nan_to_num(coss, nan=0.0)
     else:
         coss = np.zeros(len(df_band))
@@ -393,14 +388,19 @@ def search_tickers_cb(q: str):
     opts = yahoo_search(q)
     if not opts:
         opts = ["No matches found"]
-    # First match auto-selected, helper info inside dropdown
-    first = opts[0] if opts and ("No matches" not in opts[0]) else None
-    info = "Select a symbol and click 'Add selected to portfolio'." if first else "No matches."
-    return gr.update(choices=opts, value=first, info=info)
+    # Pre-select the first result and put helper text into the box
+    return gr.update(
+        choices=opts,
+        value=opts[0],
+        info="Select a symbol and click 'Add selected to portfolio'."
+    )
 
 def add_symbol(selection: str, table: Optional[pd.DataFrame]):
     if (not selection) or ("No matches" in selection) or ("Select a symbol" in selection) or ("type above" in selection):
-        return table if isinstance(table, pd.DataFrame) else pd.DataFrame(columns=["ticker","amount_usd"]), "Pick a valid match first."
+        return (
+            table if isinstance(table, pd.DataFrame) else pd.DataFrame(columns=["ticker","amount_usd"]),
+            "Pick a valid match first."
+        )
     symbol = selection.split("|")[0].strip().upper()
 
     current = []
@@ -438,7 +438,20 @@ 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})
 
-# -------------- main compute --------------
+def current_ticker_choices(tb: Optional[pd.DataFrame]):
+    if not isinstance(tb, pd.DataFrame) or tb.empty:
+        return gr.update(choices=[], value=None)
+    tickers = [str(x).upper() for x in tb["ticker"].tolist() if str(x) != "nan"]
+    return gr.update(choices=tickers, value=None)
+
+def remove_selected_ticker(symbol: Optional[str], table: Optional[pd.DataFrame]):
+    if not isinstance(table, pd.DataFrame) or table.empty or not symbol:
+        # nothing to do
+        return table if isinstance(table, pd.DataFrame) else pd.DataFrame(columns=["ticker", "amount_usd"]), gr.update()
+    out = table[table["ticker"].str.upper() != symbol.upper()].copy()
+    return out, current_ticker_choices(out)
+
+# -------------- main compute (STREAMING to show progress) --------------
 UNIVERSE: List[str] = [MARKET_TICKER, "QQQ", "VTI", "SOXX", "IBIT"]
 
 def _holdings_table_from_row(row: pd.Series, budget: float) -> pd.DataFrame:
@@ -451,14 +464,23 @@ def _holdings_table_from_row(row: pd.Series, budget: float) -> pd.DataFrame:
         columns=["ticker", "weight_%", "amount_$"]
     )
 
-def compute(
+def compute_stream(
     years_lookback: int,
     table: Optional[pd.DataFrame],
     pick_band_to_show: str,  # "Low" | "Medium" | "High"
     progress=gr.Progress(track_tqdm=True),
 ):
-    progress(0.05, desc="Validating tickers...")
+    # Yield 0: show loading banner, keep right panel hidden
+    loading_banner = "**🔄 Computations running…** This can take a moment."
+    yield (
+        None, "", empty_positions_df(), empty_suggestion_df(), None,
+        "", "", "",
+        gr.update(visible=False),  # right_col
+        gr.update(visible=False),  # sugg_row
+        gr.update(value=loading_banner, visible=True)  # status_md
+    )
 
+    progress(0.05, desc="Validating inputs…")
     # sanitize table
     if isinstance(table, pd.DataFrame):
         df = table.copy()
@@ -472,19 +494,34 @@ def compute(
 
     symbols = [t for t in df["ticker"].tolist() if t]
     if len(symbols) == 0:
-        return (
-            None, "Add at least one ticker.", empty_positions_df(), empty_suggestion_df(), None,
+        # final yield with message; keep right panel hidden
+        yield (
+            None,
+            "Add at least one ticker.",
+            empty_positions_df(),
+            empty_suggestion_df(),
+            None,
             "", "", "",
-            None, None, None, None, None, None, None, None, None
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(value="", visible=False)
         )
+        return
 
     symbols = validate_tickers(symbols, years_lookback)
     if len(symbols) == 0:
-        return (
-            None, "Could not validate any tickers.", empty_positions_df(), empty_suggestion_df(), None,
+        yield (
+            None,
+            "Could not validate any tickers.",
+            empty_positions_df(),
+            empty_suggestion_df(),
+            None,
             "", "", "",
-            None, None, None, None, None, None, None, None, None
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(value="", visible=False)
         )
+        return
 
     global UNIVERSE
     UNIVERSE = list(sorted(set(symbols)))[:MAX_TICKERS]
@@ -493,32 +530,34 @@ def compute(
     amounts = {r["ticker"]: float(r["amount_usd"]) for _, r in df.iterrows()}
     rf_ann = RF_ANN
 
-    progress(0.25, desc="Downloading prices & computing moments...")
-
-    # Moments
+    progress(0.25, desc="Estimating betas & covariances…")
     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
     gross = sum(abs(v) for v in amounts.values())
     if gross <= 1e-12:
-        return (
-            None, "All amounts are zero.", empty_positions_df(), empty_suggestion_df(), None,
+        yield (
+            None,
+            "All amounts are zero.",
+            empty_positions_df(),
+            empty_suggestion_df(),
+            None,
             "", "", "",
-            rf_ann, erp_ann, sigma_mkt, None, None, None, None, None, None
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(value="", visible=False)
         )
+        return
+
     weights = {k: v / gross for k, v in amounts.items()}
 
-    # Portfolio CAPM stats
+    progress(0.45, desc="Computing portfolio statistics…")
     beta_p, mu_capm, sigma_hist = portfolio_stats(weights, covA, betas, rf_ann, erp_ann)
 
-    progress(0.55, desc="Building synthetic dataset...")
-
-    # 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 — exactly the user's tickers
+    progress(0.7, desc="Generating candidate portfolios…")
     user_universe = list(symbols)
     synth = build_synthetic_dataset(user_universe, 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")
@@ -527,8 +566,7 @@ def compute(
     except Exception:
         csv_path = None
 
-    progress(0.8, desc="Selecting suggestions...")
-
+    progress(0.85, desc="Selecting suggestions…")
     picks = suggest_one_per_band(synth, sigma_mkt, user_universe)
 
     def _fmt(row: pd.Series) -> str:
@@ -549,7 +587,6 @@ def compute(
     else:
         chosen_sigma = float(chosen["sigma_hist"])
         chosen_mu = float(chosen["mu_capm"])
-        # holdings table from chosen suggestion
         sugg_table = _holdings_table_from_row(chosen, budget=gross)
 
     pos_table = pd.DataFrame(
@@ -585,71 +622,78 @@ def compute(
         f"- **Same σ as your portfolio** → Market weight **{a_sigma:.2f}**, Bills weight **{b_sigma:.2f}** → E[r] **{mu_eff_same_sigma:.2%}**",
         f"- **Same E[r] as your portfolio** → Market weight **{a_mu:.2f}**, Bills weight **{b_mu:.2f}** → σ **{sigma_eff_same_mu:.2%}**",
         "",
-        "_How to replicate:_ use a broad market ETF (e.g., VOO) for the **Market** leg and a T-bill/money-market fund for **Bills**. ",
-        "Weights can be >1 or negative (e.g., Market > 1 and Bills < 0 implies leverage/borrowing). ",
-        "If leverage isn’t allowed, scale both weights proportionally toward 1.0 to fit your constraints.",
+        "_How to replicate:_ use a broad market ETF (e.g., VOO) for **Market** and a T-bill/money-market fund for **Bills**. ",
+        "Weights can be >1 or negative. If leverage isn’t allowed, scale both weights proportionally toward 1.0.",
     ])
 
-    progress(1.0, desc="Done")
-
-    return (
+    # Final yield: results + reveal right column and suggestion row; hide banner
+    yield (
         img, info, 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
+        gr.update(visible=True),
+        gr.update(visible=True),
+        gr.update(value="", visible=False)
     )
 
 # -------------- UI --------------
-APP_CSS = """
+custom_css = """
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;600;700&display=swap');
 :root {
-  --accent: hsl(340 70% 50%);
-  --radius: 14px;
+  --lensiq-accent: #8b5cf6;
+  --lensiq-bg: #0b1220;
+  --lensiq-card: #121a2b;
+  --lensiq-text: #e5e7eb;
 }
-* { font-family: ui-sans-serif, system-ui, -apple-system, "Inter", Segoe UI, Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif; }
-.gr-button { border-radius: var(--radius); }
-.gr-textbox, .gr-dropdown, .gr-slider, .gr-number, .gr-dataframe { border-radius: var(--radius); }
+.gradio-container { font-family: Inter, ui-sans-serif, system-ui, -apple-system !important; }
+.lensiq-card { background: var(--lensiq-card); border-radius: 14px; padding: 14px; }
+button, .gr-button { border-radius: 10px !important; }
+.lensiq-status { background: #1f2937; color: #e5e7eb; border-left: 4px solid var(--lensiq-accent); padding: 10px 12px; border-radius: 8px; }
 """
 
-with gr.Blocks(title="Efficient Portfolio Advisor", css=APP_CSS) as demo:
+with gr.Blocks(title="Efficient Portfolio Advisor", css=custom_css) as demo:
     gr.Markdown("## Efficient Portfolio Advisor")
 
-    # States to absorb extra returns
-    s1 = gr.State(); s2 = gr.State(); s3 = gr.State(); s4 = gr.State(); s5 = gr.State()
-    s6 = gr.State(); s7 = gr.State(); s8 = gr.State(); s9 = gr.State()
-
     with gr.Row():
+        # LEFT COLUMN (full width pre-compute)
         with gr.Column(scale=1) as left_col:
-            # --- Input column (full-width before compute) ---
-            q = gr.Textbox(label="Search symbol")
-            search_btn = gr.Button("Search")
-            matches = gr.Dropdown(choices=[], label="Matches", value=None, info="")
-            add_btn = gr.Button("Add selected to portfolio")
-
-            gr.Markdown("### Portfolio positions")
-            table = gr.Dataframe(
-                headers=["ticker", "amount_usd"],
-                datatype=["str", "number"],
-                row_count=0,
-                col_count=(2, "fixed")
-            )
-
-            horizon = gr.Number(label="Horizon in years (1–100)", value=HORIZON_YEARS, precision=0)
-            lookback = gr.Slider(1, 15, value=DEFAULT_LOOKBACK_YEARS, step=1, label="Lookback years for betas & covariances")
+            with gr.Group(elem_classes="lensiq-card"):
+                q = gr.Textbox(label="Search symbol")
+                search_btn = gr.Button("Search")
+                matches = gr.Dropdown(choices=[], label="Matches", info="Type a query and hit Search")
+                add_btn = gr.Button("Add selected to portfolio")
+
+            with gr.Group(elem_classes="lensiq-card"):
+                gr.Markdown("### Portfolio positions")
+                table = gr.Dataframe(
+                    headers=["ticker", "amount_usd"],
+                    datatype=["str", "number"],
+                    row_count=0,
+                    col_count=(2, "fixed")
+                )
+
+                # remove controls
+                with gr.Row():
+                    rm_dropdown = gr.Dropdown(choices=[], label="Remove ticker", value=None)
+                    rm_btn = gr.Button("Remove selected")
+
+            with gr.Group(elem_classes="lensiq-card"):
+                horizon = gr.Number(label="Horizon in years (1–100)", value=HORIZON_YEARS, precision=0)
+                lookback = gr.Slider(1, 15, value=DEFAULT_LOOKBACK_YEARS, step=1, label="Lookback years for betas & covariances")
+                run_btn = gr.Button("Compute (build dataset & suggest)")
+
+            # visible loading/status banner
+            status_md = gr.Markdown("", visible=False, elem_classes="lensiq-status")
 
-            # Compute button (shows progress bar while compute runs)
-            run_btn = gr.Button("Compute (build dataset & suggest)")
-
-            # Suggestions (hidden until first compute)
             sugg_hdr = gr.Markdown("### Suggestions", visible=False)
-            with gr.Row(visible=False) as sugg_btn_row:
+            with gr.Row(visible=False) as sugg_row:
                 btn_low = gr.Button("Show Low")
                 btn_med = gr.Button("Show Medium")
                 btn_high = gr.Button("Show High")
-            low_txt  = gr.Markdown(visible=False)
-            med_txt  = gr.Markdown(visible=False)
-            high_txt = gr.Markdown(visible=False)
+            low_txt = gr.Markdown()
+            med_txt = gr.Markdown()
+            high_txt = gr.Markdown()
 
-        # --- Output column (hidden until first compute) ---
+        # RIGHT COLUMN (hidden pre-compute)
         with gr.Column(scale=1, visible=False) as right_col:
             plot = gr.Image(label="Capital Market Line (CAPM)", type="pil")
             summary = gr.Markdown(label="Inputs & Results")
@@ -671,64 +715,47 @@ with gr.Blocks(title="Efficient Portfolio Advisor", css=APP_CSS) as demo:
             )
             dl = gr.File(label="Generated dataset CSV", value=None, visible=True)
 
-    # --- Wiring ---
+    # ---------- wiring ----------
+    # search / add
     search_btn.click(fn=search_tickers_cb, inputs=q, outputs=matches)
     add_btn.click(fn=add_symbol_table_only, inputs=[matches, table], outputs=table)
+
+    # keep tickers valid & refresh remove dropdown when table changes
     table.change(fn=lock_ticker_column, inputs=table, outputs=table)
-    horizon.change(fn=set_horizon, inputs=horizon, outputs=[])
+    table.change(fn=current_ticker_choices, inputs=table, outputs=rm_dropdown)
 
-    # Compute (default band = Medium) -> populate outputs
-    run_compute = run_btn.click(
-        fn=compute,
-        inputs=[lookback, table, gr.State("Medium")],
-        outputs=[
-            plot, summary, positions, sugg_table, dl,
-            low_txt, med_txt, high_txt,
-            s1, s2, s3, s4, s5, s6, s7, s8, s9
-        ],
-        show_progress=True,
-        scroll_to_output=True,
-    )
+    # remove a ticker
+    rm_btn.click(fn=remove_selected_ticker, inputs=[rm_dropdown, table], outputs=[table, rm_dropdown])
 
-    # After compute: reveal right column + suggestions
-    def _reveal():
-        return (
-            gr.update(visible=True),  # right_col
-            gr.update(visible=True),  # sugg_hdr
-            gr.update(visible=True),  # sugg_btn_row
-            gr.update(visible=True),  # low_txt
-            gr.update(visible=True),  # med_txt
-            gr.update(visible=True),  # high_txt
-        )
+    # horizon updates globals silently
+    horizon.change(fn=set_horizon, inputs=horizon, outputs=[])
 
-    run_compute.then(
-        fn=_reveal,
-        inputs=[],
-        outputs=[right_col, sugg_hdr, sugg_btn_row, low_txt, med_txt, high_txt]
+    # compute + reveal results (default Medium band); STREAMING for visible progress
+    run_btn.click(
+        fn=compute_stream,
+        inputs=[lookback, table, gr.State("Medium")],
+        outputs=[plot, summary, positions, sugg_table, dl, low_txt, med_txt, high_txt, right_col, sugg_row, status_md]
+    ).then(  # after results are visible, show Suggestions header too
+        lambda: (gr.update(visible=True),),
+        None,
+        [sugg_hdr]
     )
 
-    # Band buttons -> recompute quickly, keeping layout visible
-    def _band_low(): return "Low"
-    def _band_med(): return "Medium"
-    def _band_high(): return "High"
-
+    # band buttons recompute picks quickly (also stream with banner)
     btn_low.click(
-        fn=compute,
-        inputs=[lookback, table, gr.State(_band_low())],
-        outputs=[plot, summary, positions, sugg_table, dl, low_txt, med_txt, high_txt, s1, s2, s3, s4, s5, s6, s7, s8, s9],
-        show_progress=True
+        fn=compute_stream,
+        inputs=[lookback, table, gr.State("Low")],
+        outputs=[plot, summary, positions, sugg_table, dl, low_txt, med_txt, high_txt, right_col, sugg_row, status_md]
     )
     btn_med.click(
-        fn=compute,
-        inputs=[lookback, table, gr.State(_band_med())],
-        outputs=[plot, summary, positions, sugg_table, dl, low_txt, med_txt, high_txt, s1, s2, s3, s4, s5, s6, s7, s8, s9],
-        show_progress=True
+        fn=compute_stream,
+        inputs=[lookback, table, gr.State("Medium")],
+        outputs=[plot, summary, positions, sugg_table, dl, low_txt, med_txt, high_txt, right_col, sugg_row, status_md]
     )
     btn_high.click(
-        fn=compute,
-        inputs=[lookback, table, gr.State(_band_high())],
-        outputs=[plot, summary, positions, sugg_table, dl, low_txt, med_txt, high_txt, s1, s2, s3, s4, s5, s6, s7, s8, s9],
-        show_progress=True
+        fn=compute_stream,
+        inputs=[lookback, table, gr.State("High")],
+        outputs=[plot, summary, positions, sugg_table, dl, low_txt, med_txt, high_txt, right_col, sugg_row, status_md]
     )
 
 # initialize risk-free at launch
@@ -737,3 +764,4 @@ RF_ANN = fetch_fred_yield_annual(RF_CODE)
 
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860, show_api=False)
+