Update app.py

app.py

@@ -391,12 +391,20 @@ def set_horizon(years: float):
 
 def search_tickers_cb(q: str):
     opts = yahoo_search(q)
-    note = "Select a symbol and click 'Add selected to portfolio'." if opts else "No matches."
-    return note, gr.update(choices=opts, value=None)
+    if not opts:
+        opts = ["No matches found"]
+    # Put helper text into Matches box
+    return gr.update(
+        choices=opts,
+        value=None,
+        info="Select a symbol and click 'Add selected to portfolio'."
+    )
 
 def add_symbol(selection: str, table: Optional[pd.DataFrame]):
     if not selection:
         return table if isinstance(table, pd.DataFrame) else pd.DataFrame(columns=["ticker","amount_usd"]), "Pick a row in Matches first."
+    if "No matches" in str(selection):
+        return table if isinstance(table, pd.DataFrame) else pd.DataFrame(columns=["ticker","amount_usd"]), "No symbol to add."
     symbol = selection.split("|")[0].strip().upper()
 
     current = []
@@ -420,6 +428,11 @@ def add_symbol(selection: str, table: Optional[pd.DataFrame]):
         return new_table, f"Reached max of {MAX_TICKERS}."
     return new_table, f"Added {symbol}."
 
+def add_symbol_table_only(selection: str, table: Optional[pd.DataFrame]):
+    """Wrapper that only returns the updated table (no status string)."""
+    new_table, _ = add_symbol(selection, table)
+    return new_table
+
 def lock_ticker_column(tb: Optional[pd.DataFrame]):
     if not isinstance(tb, pd.DataFrame) or tb.empty:
         return pd.DataFrame(columns=["ticker", "amount_usd"])
@@ -447,9 +460,11 @@ def compute(
     years_lookback: int,
     table: Optional[pd.DataFrame],
     pick_band_to_show: str,  # "Low" | "Medium" | "High"
-    progress=gr.Progress(track_tqdm=True),
+    progress=gr.Progress(track_tqdm=True)
 ):
-    progress(0.03, desc="Validating tickers...")
+    # progress indicator
+    progress(0, desc="Validating inputs...")
+    time.sleep(0.05)
 
     # sanitize table
     if isinstance(table, pd.DataFrame):
@@ -464,18 +479,35 @@ def compute(
 
     symbols = [t for t in df["ticker"].tolist() if t]
     if len(symbols) == 0:
+        msg = "Add at least one ticker (and ensure VOO is present in data history)."
         return (
-            None, "Add at least one ticker.", empty_positions_df(), empty_suggestion_df(), None,
-            "", "", "",
-            None, None, None, None, None, None, None, None, None
+            gr.update(value=None, visible=True),  # plot placeholder stays blank
+            gr.update(value="### Error\n" + msg, visible=True),
+            gr.update(value=empty_positions_df(), visible=True),
+            gr.update(value=empty_suggestion_df(), visible=True),
+            gr.update(value=None, visible=False),
+            gr.update(value="", visible=True),
+            gr.update(value="", visible=True),
+            gr.update(value="", visible=True),
+            gr.update(visible=True),   # show outputs group so message is visible
+            gr.update(visible=True)    # show suggestions container (buttons/text)
         )
 
+    progress(0.15, desc="Validating tickers...")
     symbols = validate_tickers(symbols, years_lookback)
     if len(symbols) == 0:
+        msg = "Could not validate any tickers for the chosen lookback (VOO data required)."
         return (
-            None, "Could not validate any tickers.", empty_positions_df(), empty_suggestion_df(), None,
-            "", "", "",
-            None, None, None, None, None, None, None, None, None
+            gr.update(value=None, visible=True),
+            gr.update(value="### Error\n" + msg, visible=True),
+            gr.update(value=empty_positions_df(), visible=True),
+            gr.update(value=empty_suggestion_df(), visible=True),
+            gr.update(value=None, visible=False),
+            gr.update(value="", visible=True),
+            gr.update(value="", visible=True),
+            gr.update(value="", visible=True),
+            gr.update(visible=True),
+            gr.update(visible=True)
         )
 
     global UNIVERSE
@@ -485,23 +517,37 @@ def compute(
     amounts = {r["ticker"]: float(r["amount_usd"]) for _, r in df.iterrows()}
     rf_ann = RF_ANN
 
-    progress(0.18, desc="Downloading prices & computing moments...")
+    progress(0.35, desc="Downloading prices & estimating moments...")
     moms = estimate_all_moments_aligned(symbols, years_lookback, rf_ann)
     betas, covA, erp_ann, sigma_mkt = moms["betas"], moms["cov_ann"], moms["erp_ann"], moms["sigma_m_ann"]
 
     gross = sum(abs(v) for v in amounts.values())
     if gross <= 1e-12:
+        msg = "All amounts are zero."
         return (
-            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(value=None, visible=True),
+            gr.update(value="### Error\n" + msg, visible=True),
+            gr.update(value=empty_positions_df(), visible=True),
+            gr.update(value=empty_suggestion_df(), visible=True),
+            gr.update(value=None, visible=False),
+            gr.update(value="", visible=True),
+            gr.update(value="", visible=True),
+            gr.update(value="", visible=True),
+            gr.update(visible=True),
+            gr.update(visible=True)
         )
     weights = {k: v / gross for k, v in amounts.items()}
 
-    progress(0.35, desc="Computing portfolio CAPM stats...")
+    # Portfolio CAPM stats
+    progress(0.55, desc="Computing CAPM stats...")
     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.75, desc="Building synthetic dataset & suggestions...")
     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")
@@ -510,9 +556,6 @@ def compute(
     except Exception:
         csv_path = None
 
-    progress(0.75, desc="Deriving efficient mixes & suggestions...")
-    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)
     picks = suggest_one_per_band(synth, sigma_mkt, user_universe)
 
     def _fmt(row: pd.Series) -> str:
@@ -529,11 +572,11 @@ def compute(
     if chosen is None or chosen.empty:
         chosen_sigma = None
         chosen_mu = None
-        sugg_table = empty_suggestion_df()
+        sugg_table_df = empty_suggestion_df()
     else:
         chosen_sigma = float(chosen["sigma_hist"])
         chosen_mu = float(chosen["mu_capm"])
-        sugg_table = _holdings_table_from_row(chosen, budget=gross)
+        sugg_table_df = _holdings_table_from_row(chosen, budget=gross)
 
     pos_table = pd.DataFrame(
         [{
@@ -545,7 +588,6 @@ def compute(
         columns=["ticker", "amount_usd", "weight_exposure", "beta"]
     )
 
-    progress(0.9, desc="Rendering chart & summary...")
     img = plot_cml(
         rf_ann, erp_ann, sigma_mkt,
         sigma_hist, mu_capm,
@@ -553,6 +595,7 @@ def compute(
         sugg_sigma_hist=chosen_sigma, sugg_mu_capm=chosen_mu
     )
 
+    # Summary text (clean)
     info = "\n".join([
         "### Inputs",
         f"- Lookback years {years_lookback}",
@@ -574,141 +617,116 @@ def compute(
         "If leverage isn’t allowed, scale both weights proportionally toward 1.0 to fit your constraints.",
     ])
 
-    progress(1.0, desc="Done.")
+    progress(0.98, desc="Rendering...")
+    time.sleep(0.05)
 
     return (
-        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(value=img, visible=True),
+        gr.update(value=info, visible=True),
+        gr.update(value=pos_table, visible=True),
+        gr.update(value=sugg_table_df, visible=True),
+        gr.update(value=csv_path, visible=bool(csv_path)),
+        gr.update(value=txt_low, visible=True),
+        gr.update(value=txt_med, visible=True),
+        gr.update(value=txt_high, visible=True),
+        gr.update(visible=True),  # show outputs group
+        gr.update(visible=True)   # show suggestions group
     )
 
 # -------------- UI --------------
-with gr.Blocks(
-    title="Efficient Portfolio Advisor",
-) as demo:
+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."
+        "Search symbols, enter **dollar amounts**, set horizon. Returns use Yahoo Finance monthly data; risk-free from FRED. "
+        "Plot shows **your CAPM point on the CML** plus efficient market/bills points."
     )
 
-    with gr.Row():
-        with gr.Column(scale=5) as left_col:
-            # --- Vertical flow: Search -> Button -> Matches -> Add ---
-            q = gr.Textbox(label="Search symbol")
-            search_btn = gr.Button("Search")
-            search_note = gr.Markdown()
-            matches = gr.Dropdown(choices=[], label="Matches")
-            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")
+    # LEFT: controls (fill page initially)
+    with gr.Group(visible=True) as controls_group:
+        # Search flow: Search -> Button -> Matches -> Add
+        q = gr.Textbox(label="Search symbol")
+        search_btn = gr.Button("Search")
+        matches = gr.Dropdown(choices=[], label="Matches")
+        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")
+        )
 
-            # Loading banner (appears instantly on click, hidden after results show)
-            loading_md = gr.Markdown("⏳ Working... fetching data and computing suggestions...", visible=False)
+        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")
 
-            # Compute button directly under lookback slider
-            run_btn = gr.Button("Compute (build dataset & suggest)")
+        # Compute button directly under lookback slider
+        run_btn = gr.Button("Compute (build dataset & suggest)")
 
-            # Suggestions UI (hidden until Compute)
-            sugg_hdr = gr.Markdown("### Suggestions", visible=False)
+        # Suggestions container (hidden until compute)
+        with gr.Group(visible=False) as sugg_group:
+            gr.Markdown("### Suggestions")
             with gr.Row():
-                btn_low  = gr.Button("Show Low",    visible=False)
-                btn_med  = gr.Button("Show Medium", visible=False)
-                btn_high = gr.Button("Show High",   visible=False)
-            low_txt  = gr.Markdown(visible=False)
-            med_txt  = gr.Markdown(visible=False)
-            high_txt = gr.Markdown(visible=False)
-
-        with gr.Column(scale=7, visible=False) as right_col:
-            # Results (hidden until Compute)
-            plot = gr.Image(label="Capital Market Line (CAPM)", type="pil", visible=False)
-            summary = gr.Markdown(label="Inputs & Results", visible=False)
-            positions = gr.Dataframe(
-                label="Computed positions",
-                headers=["ticker", "amount_usd", "weight_exposure", "beta"],
-                datatype=["str", "number", "number", "number"],
-                col_count=(4, "fixed"),
-                value=empty_positions_df(),
-                interactive=False,
-                visible=False
-            )
-            sugg_table = gr.Dataframe(
-                label="Selected suggestion holdings (% / $)",
-                headers=["ticker", "weight_%", "amount_$"],
-                datatype=["str", "number", "number"],
-                col_count=(3, "fixed"),
-                value=empty_suggestion_df(),
-                interactive=False,
-                visible=False
-            )
-            dl = gr.File(label="Generated dataset CSV", value=None, visible=False)
-
-    # --- wiring ---
-    search_btn.click(fn=search_tickers_cb, inputs=q, outputs=[search_note, matches])
-    add_btn.click(fn=add_symbol, inputs=[matches, table], outputs=[table, search_note])
+                btn_low = gr.Button("Show Low")
+                btn_med = gr.Button("Show Medium")
+                btn_high = gr.Button("Show High")
+            low_txt = gr.Markdown()
+            med_txt = gr.Markdown()
+            high_txt = gr.Markdown()
+
+    # RIGHT: outputs (hidden until compute)
+    with gr.Group(visible=False) as out_group:
+        with gr.Row():
+            with gr.Column(scale=1):
+                plot = gr.Image(label="Capital Market Line (CAPM)", type="pil")
+                summary = gr.Markdown(label="Inputs & Results")
+            with gr.Column(scale=1):
+                positions = gr.Dataframe(
+                    label="Computed positions",
+                    headers=["ticker", "amount_usd", "weight_exposure", "beta"],
+                    datatype=["str", "number", "number", "number"],
+                    col_count=(4, "fixed"),
+                    value=empty_positions_df(),
+                    interactive=False
+                )
+                sugg_table = gr.Dataframe(
+                    label="Selected suggestion holdings (% / $)",
+                    headers=["ticker", "weight_%", "amount_$"],
+                    datatype=["str", "number", "number"],
+                    col_count=(3, "fixed"),
+                    value=empty_suggestion_df(),
+                    interactive=False
+                )
+                dl = gr.File(label="Generated dataset CSV", value=None, visible=True)
+
+    # wire search / add / locking
+    search_btn.click(fn=search_tickers_cb, inputs=q, outputs=matches)
+    add_btn.click(fn=add_symbol_table_only, inputs=[matches, table], outputs=table)
     table.change(fn=lock_ticker_column, inputs=table, outputs=table)
-    horizon.change(fn=set_horizon, inputs=horizon, outputs=[])
-
-    # Small helpers to toggle the loading banner
-    def _show_loading():
-        return gr.update(visible=True)
-    def _hide_loading():
-        return gr.update(visible=False)
 
-    # 1) Show loading immediately
-    # 2) Run compute (with full-page progress bar) 
-    # 3) Reveal results and suggestion controls
-    # 4) Hide loading banner
-    show_evt = run_btn.click(_show_loading, inputs=[], outputs=[loading_md])
+    # horizon updates globals silently (no UI output)
+    horizon.change(fn=set_horizon, inputs=horizon, outputs=[])
 
-    compute_evt = show_evt.then(
+    # compute + render (default to Medium band)
+    run_btn.click(
         fn=compute,
         inputs=[lookback, table, gr.State("Medium")],
         outputs=[
             plot, summary, positions, sugg_table, dl,
             low_txt, med_txt, high_txt,
-            gr.State(), gr.State(), gr.State(), gr.State(), gr.State(), gr.State(), gr.State(),
-            gr.State(), gr.State()
-        ],
-        show_progress="full",   # <-- full-page progress overlay
-    )
-
-    def _reveal():
-        up = gr.update(visible=True)
-        return (up, up, up, up, up, up, up, up, up, up, up, up, up)
-
-    after_compute = compute_evt.then(
-        _reveal,
-        inputs=[],
-        outputs=[
-            right_col,
-            plot, summary, positions, sugg_table, dl,
-            sugg_hdr, btn_low, btn_med, btn_high, low_txt, med_txt, high_txt
+            out_group, sugg_group
         ]
     )
 
-    after_compute.then(_hide_loading, inputs=[], outputs=[loading_md])
-
-    # Band buttons (after reveal). Also request full progress overlay.
+    # band buttons recompute picks quickly (keep groups visible)
     btn_low.click(
         fn=compute,
         inputs=[lookback, table, gr.State("Low")],
         outputs=[
             plot, summary, positions, sugg_table, dl,
             low_txt, med_txt, high_txt,
-            gr.State(), gr.State(), gr.State(), gr.State(), gr.State(), gr.State(), gr.State(),
-            gr.State(), gr.State()
-        ],
-        show_progress="full",
+            out_group, sugg_group
+        ]
     )
     btn_med.click(
         fn=compute,
@@ -716,10 +734,8 @@ with gr.Blocks(
         outputs=[
             plot, summary, positions, sugg_table, dl,
             low_txt, med_txt, high_txt,
-            gr.State(), gr.State(), gr.State(), gr.State(), gr.State(), gr.State(), gr.State(),
-            gr.State(), gr.State()
-        ],
-        show_progress="full",
+            out_group, sugg_group
+        ]
     )
     btn_high.click(
         fn=compute,
@@ -727,10 +743,8 @@ with gr.Blocks(
         outputs=[
             plot, summary, positions, sugg_table, dl,
             low_txt, med_txt, high_txt,
-            gr.State(), gr.State(), gr.State(), gr.State(), gr.State(), gr.State(), gr.State(),
-            gr.State(), gr.State()
-        ],
-        show_progress="full",
+            out_group, sugg_group
+        ]
     )
 
 # initialize risk-free at launch
@@ -738,6 +752,6 @@ RF_CODE = fred_series_for_horizon(HORIZON_YEARS)
 RF_ANN = fetch_fred_yield_annual(RF_CODE)
 
 if __name__ == "__main__":
-    # enable event queue so progress bar + async UI updates work properly
-    demo.queue()
-    demo.launch(server_name="0.0.0.0", server_port=7860, show_api=False)
+    # enable queue for visible progress bar
+    demo.queue().launch(server_name="0.0.0.0", server_port=7860, show_api=False)
+