Spaces:
Sleeping
Sleeping
| import threading | |
| import time | |
| # Import numpy here, on the main thread, before anything else can start one. | |
| # The reranker warms up on a background thread further down, and importing | |
| # torch pulls numpy in with it. On a slow cold start -- which is what a | |
| # Hugging Face Space is -- that import was still running when a rerun called | |
| # inject_global_css(), whose plotly template validation calls np.isscalar. | |
| # Python handed it a half-built module and the whole page died with | |
| # "partially initialized module 'numpy' ... most likely due to a circular | |
| # import". Loading numpy to completion first makes the background import a | |
| # cache hit and closes the race at its source. | |
| import numpy # noqa: F401 | |
| import streamlit as st | |
| from dotenv import load_dotenv | |
| load_dotenv() | |
| from langchain_core.messages import HumanMessage | |
| from agent.llm import RunConfig, classify_llm_error | |
| from dashboard import i18n | |
| from dashboard import model_picker | |
| from dashboard.i18n import t | |
| from dashboard.runtime_env import is_hosted_space | |
| from dashboard.theme import inject_global_css, LOGO_SVG | |
| from dashboard.nav import NAV_ITEMS, LEGACY_NAV, VALID_KEYS, render as render_nav | |
| from dashboard import reasoning as reasoning_panel | |
| import dashboard.agent_graph as agent_graph | |
| st.set_page_config(page_title="Readthrough", page_icon="📊", layout="wide", initial_sidebar_state="expanded") | |
| inject_global_css() | |
| # Warm the reranker on a background thread. This used to block the first render: | |
| # importing torch + sentence-transformers costs tens of seconds on a cold process, | |
| # and doing it here meant the visitor saw a blank page for all of it before any | |
| # chrome appeared. A search that arrives mid-load waits on the model's own lock. | |
| if not st.session_state.get("_reranker_warmed"): | |
| from storage.reranker import warmup_async as _warmup_reranker | |
| _warmup_reranker() | |
| st.session_state["_reranker_warmed"] = True | |
| # ── UI language — default to English (finance lingua franca) ─────────────────── | |
| st.session_state.setdefault("ui_lang", "en") | |
| # ── Navigation state — default to Company Overview (the onboarding view) ─────── | |
| st.session_state.setdefault("nav_key", "company") | |
| # Remap stale route keys from the pre-Decision-Stack navigation (open sessions). | |
| _nk = st.session_state["nav_key"] | |
| if _nk not in VALID_KEYS: | |
| st.session_state["nav_key"] = LEGACY_NAV.get(_nk, "company") | |
| # ── Generation state ──────────────────────────────────────────────────────────── | |
| st.session_state.setdefault("gen", { | |
| "running": False, | |
| "ticker": None, | |
| "trace": [], | |
| "brief": None, | |
| "error": None, | |
| "all_messages": [], | |
| "config": None, | |
| }) | |
| # ── Sidebar ───────────────────────────────────────────────────────────────────── | |
| with st.sidebar: | |
| st.markdown( | |
| f"""<div class="primer-logo-row"> | |
| {LOGO_SVG} | |
| <div> | |
| <div class="primer-logo-wordmark">Readthrough</div> | |
| <div class="primer-logo-tagline">AI equity research</div> | |
| </div> | |
| </div>""", | |
| unsafe_allow_html=True, | |
| ) | |
| # ── Language selector — top of sidebar so first-time visitors set it before ── | |
| # anything else. Endonym labels (English / Français / Español / Deutsch) are | |
| # self-identifying regardless of the current display language. | |
| _lang_labels = list(i18n.LANGUAGES.keys()) | |
| _current_lang_label = next( | |
| (lbl for lbl, code in i18n.LANGUAGES.items() | |
| if code == st.session_state.get("ui_lang", "en")), | |
| _lang_labels[0], | |
| ) | |
| _selected_lang_label = st.selectbox( | |
| t("language"), | |
| options=_lang_labels, | |
| index=_lang_labels.index(_current_lang_label), | |
| key="_lang_selectbox", | |
| label_visibility="collapsed", | |
| ) | |
| # Persist and rerun when the language changes so all t() calls refresh. | |
| _new_lang_code = i18n.LANGUAGES[_selected_lang_label] | |
| if _new_lang_code != st.session_state.get("ui_lang", "en"): | |
| st.session_state["ui_lang"] = _new_lang_code | |
| st.rerun() | |
| # ── Model / API key picker ───────────────────────────────────────────────── | |
| run_cfg, _key_source = model_picker.render() | |
| # ── Ticker input — single company at a time ─────────────────────────────── | |
| # Coverage clicks set a pending ticker; consume it BEFORE the widget | |
| # instantiates (writing a widget key after instantiation raises). | |
| _pending_ticker = st.session_state.pop("_pending_ticker", None) | |
| if _pending_ticker: | |
| st.session_state["ticker_input_box"] = _pending_ticker | |
| # Opening a saved company should land on the same screen a freshly | |
| # generated one does. Routing one to Company Overview and the other to | |
| # The Brief gave the app two different "first screens" for the same | |
| # state. Only redirect from the default landing route, so a deliberate | |
| # tab choice survives switching company. | |
| if st.session_state.get("nav_key") == "company": | |
| st.session_state["_nav_pending_key"] = "verdict" | |
| _raw_ticker = st.text_input( | |
| t("ticker_label"), placeholder=t("ticker_placeholder"), | |
| key="ticker_input_box", | |
| ).strip().upper() | |
| st.caption(t("ticker_caption")) | |
| # Graceful multi-ticker: if the user types "NVDA AAPL", take the first as the | |
| # active ticker and ignore the rest with a note. | |
| _ticker_tokens = [tok for tok in _raw_ticker.replace(",", " ").split() if tok] | |
| ticker_input = _ticker_tokens[0] if _ticker_tokens else "" | |
| if len(_ticker_tokens) > 1: | |
| st.info(t("ticker_multi_warning")) | |
| generate_clicked = st.button( | |
| t("generate_brief"), type="primary", use_container_width=True, | |
| disabled=not ticker_input or st.session_state["gen"]["running"] or run_cfg is None, | |
| ) | |
| if run_cfg is None: | |
| st.caption(t("model_blocked_caption")) | |
| st.divider() | |
| # Resolve any pending nav redirect (e.g. auto-navigate to Verdict after generation) | |
| if "_nav_pending_key" in st.session_state: | |
| st.session_state["nav_key"] = st.session_state.pop("_nav_pending_key") | |
| # ── Auto-load persisted brief from briefs.db — no regeneration needed ───── | |
| if ( | |
| ticker_input | |
| and not st.session_state["gen"]["running"] | |
| and st.session_state.get("brief_ticker") != ticker_input | |
| ): | |
| try: | |
| from storage import briefs_db | |
| _persisted = briefs_db.get_brief(ticker_input) | |
| if _persisted: | |
| st.session_state["brief"] = _persisted | |
| st.session_state["brief_ticker"] = ticker_input | |
| except Exception as _exc: | |
| # Surfaced, not swallowed — a silent failure here is exactly what | |
| # makes The Brief / What Changed wrongly ask to regenerate a | |
| # brief that was already produced and persisted. | |
| import sys | |
| print(f"[app] persisted brief reload failed for {ticker_input!r}: {_exc}", file=sys.stderr) | |
| # Inline brief lookup — _get_cached_brief() is defined after this block | |
| _sb = st.session_state.get("brief") | |
| _sidebar_brief = _sb if (_sb and ticker_input and st.session_state.get("brief_ticker") == ticker_input) else None | |
| render_nav(NAV_ITEMS, st.session_state["nav_key"], brief=_sidebar_brief) | |
| # ── Coverage — saved briefs, click to load without regenerating ─────────── | |
| try: | |
| from storage import briefs_db | |
| _coverage = briefs_db.list_briefs() | |
| except Exception: | |
| _coverage = [] | |
| if _coverage: | |
| st.divider() | |
| st.markdown( | |
| f'<div style="font-size:0.6rem;font-weight:700;text-transform:uppercase;' | |
| f'letter-spacing:0.1em;color:#8C968F;padding:0 2px 4px;">{t("coverage_title")}</div>', | |
| unsafe_allow_html=True, | |
| ) | |
| for _row in _coverage: | |
| _cov_label = ( | |
| f'{_row["ticker"]} · {_row["filing_date"]}' | |
| if _row["filing_date"] else _row["ticker"] | |
| ) | |
| if st.button(_cov_label, key=f'cov_{_row["ticker"]}', use_container_width=True): | |
| st.session_state["_pending_ticker"] = _row["ticker"] | |
| st.rerun() | |
| st.caption(t("coverage_caption")) | |
| # Cost footer | |
| cost_state = st.session_state.get("_last_cost") | |
| cost_ticker = st.session_state.get("_last_cost_ticker") | |
| if cost_state and cost_ticker == ticker_input: | |
| c = cost_state | |
| st.divider() | |
| st.caption( | |
| f"Tokens: {c['input_tokens']:,} in / {c['output_tokens']:,} out\n" | |
| f"Est. cost: ${c['cost_usd']:.4f} USD" | |
| ) | |
| # ── Helpers ───────────────────────────────────────────────────────────────────── | |
| def _get_cached_brief() -> dict | None: | |
| cached = st.session_state.get("brief") | |
| if cached and st.session_state.get("brief_ticker") == ticker_input: | |
| return cached | |
| # Defense-in-depth: the sidebar auto-load already tries this once per | |
| # rerun, but session_state can lose "brief" between reruns (WebSocket | |
| # reconnect, concurrent-session DB lock, etc.) without ticker_input | |
| # changing. Retry here so a tab switch never asks to regenerate a brief | |
| # that was already produced and persisted for this ticker. | |
| if ticker_input and not st.session_state["gen"]["running"]: | |
| try: | |
| from storage import briefs_db | |
| persisted = briefs_db.get_brief(ticker_input) | |
| except Exception as exc: | |
| import sys | |
| print(f"[app] _get_cached_brief reload failed for {ticker_input!r}: {exc}", file=sys.stderr) | |
| persisted = None | |
| if persisted: | |
| st.session_state["brief"] = persisted | |
| st.session_state["brief_ticker"] = ticker_input | |
| return persisted | |
| return None | |
| def _brief_placeholder(tab_name: str) -> None: | |
| st.info(f"{t('section_placeholder')} {tab_name}.") | |
| def _absorb_translation_cost(ticker: str, usage: dict | None, model: str) -> None: | |
| """Merge translation token usage into the session cost footer.""" | |
| if not usage: | |
| return | |
| try: | |
| from agent.cost_log import log_usage | |
| log_usage(ticker, model, usage["input_tokens"], usage["output_tokens"]) | |
| existing = st.session_state.get("_last_cost") | |
| if existing and st.session_state.get("_last_cost_ticker") == ticker: | |
| st.session_state["_last_cost"] = { | |
| "input_tokens": existing["input_tokens"] + usage["input_tokens"], | |
| "output_tokens": existing["output_tokens"] + usage["output_tokens"], | |
| "cost_usd": round(existing["cost_usd"] + usage["cost_usd"], 6), | |
| } | |
| else: | |
| st.session_state["_last_cost"] = usage | |
| st.session_state["_last_cost_ticker"] = ticker | |
| except Exception: | |
| pass | |
| def _get_display_brief(brief: dict | None, ticker: str, config: RunConfig | None) -> dict | None: | |
| """Return a brief translated to the current UI language if needed. | |
| Never raises. Falls back to original brief on any error. | |
| Uses session cache + DB cache to avoid re-translating on every rerun. | |
| """ | |
| if not brief: | |
| return brief | |
| target = i18n.report_language() | |
| if (brief.get("language") or "English") == target: | |
| return brief | |
| # No key available (yet) — skip translation silently rather than erroring; | |
| # the brief still renders in its original (English) language. | |
| if config is None: | |
| return brief | |
| # Session cache key: (ticker, target_lang, filing_date) | |
| cache = st.session_state.setdefault("_display_brief_cache", {}) | |
| failed = st.session_state.setdefault("_translate_failed", set()) | |
| cache_key = (ticker, target, brief.get("filing_date") or "") | |
| if cache_key in cache: | |
| return cache[cache_key] | |
| if cache_key in failed: | |
| st.caption(t("translation_failed")) | |
| return brief | |
| # Check persistent DB cache first | |
| try: | |
| from storage import briefs_db | |
| persisted = briefs_db.get_translation(ticker, target) | |
| except Exception: | |
| persisted = None | |
| if persisted: | |
| cache[cache_key] = persisted | |
| return persisted | |
| # Call the translator | |
| from agent.translate import translate_brief | |
| with st.spinner(t("translating_brief")): | |
| translated, usage = translate_brief(brief, target, config=config) | |
| if (translated.get("language") or "English") != target: | |
| failed.add(cache_key) | |
| st.caption(t("translation_failed")) | |
| return brief | |
| try: | |
| from storage import briefs_db | |
| briefs_db.save_translation(ticker, translated.get("language", target), translated) | |
| except Exception: | |
| pass | |
| cache[cache_key] = translated | |
| _absorb_translation_cost(ticker, usage, config.model) | |
| return translated | |
| def _reliability_counts(brief: dict) -> dict[str, int]: | |
| """Aggregate HIGH/MED/LOW counts across all SourcedFact fields in the brief.""" | |
| counts: dict[str, int] = {"HIGH": 0, "MEDIUM": 0, "LOW": 0} | |
| def _tally(obj: object) -> None: | |
| if isinstance(obj, dict): | |
| rel = obj.get("reliability") | |
| if rel in counts: | |
| counts[rel] += 1 | |
| for v in obj.values(): | |
| _tally(v) | |
| elif isinstance(obj, list): | |
| for item in obj: | |
| _tally(item) | |
| _tally(brief) | |
| return counts | |
| def _reliability_bar_html(brief: dict) -> str: | |
| """A compact stacked bar (HIGH/MEDIUM/LOW) with the breakdown as a hover | |
| tooltip — replaces a wall of "HIGH 73% · MEDIUM 25% · LOW 2%" text.""" | |
| from dashboard.theme import GREEN, AMBER, TEXT_FAINT | |
| counts = _reliability_counts(brief) | |
| total = sum(counts.values()) | |
| if total == 0: | |
| return "" | |
| pct = {k: round(v * 100 / total) for k, v in counts.items()} | |
| colors = {"HIGH": GREEN, "MEDIUM": AMBER, "LOW": "#8C968F"} | |
| segments = "".join( | |
| f'<span style="display:inline-block;height:100%;width:{pct[k]}%;background:{colors[k]};"></span>' | |
| for k in ("HIGH", "MEDIUM", "LOW") if pct[k] > 0 | |
| ) | |
| title = " · ".join(f"{k} {pct[k]}%" for k in ("HIGH", "MEDIUM", "LOW") if pct[k] > 0) | |
| return ( | |
| f'<span title="{t("sources_prefix")} {title}" style="display:inline-flex;align-items:center;gap:5px;">' | |
| f'<span style="font-size:0.68rem;color:{TEXT_FAINT};">{t("sources_prefix")}</span>' | |
| f'<span style="display:inline-block;width:60px;height:7px;border-radius:4px;overflow:hidden;' | |
| f'background:#D5DAD4;">{segments}</span>' | |
| f'</span>' | |
| ) | |
| def _display_policy_allows(brief: dict, capability: str) -> bool: | |
| """Return True only when a display capability is explicitly validated. | |
| Persisted briefs predate ``display_policy`` and therefore fail closed. A | |
| truthy string or an LLM-invented value is deliberately insufficient: the | |
| producer must set the exact boolean ``True`` after the relevant alignment | |
| or calibration check has passed. | |
| """ | |
| policy = brief.get("display_policy") or {} | |
| return isinstance(policy, dict) and policy.get(capability) is True | |
| def _render_ticker_bar(ticker: str, brief: dict) -> None: | |
| """Render the sticky context bar above the main content area. | |
| Ticker, company and filing date are always safe to show. Event returns and | |
| aggregate reliability are hidden unless upstream validation explicitly | |
| enables them via alignment flags or ``display_policy``, respectively. | |
| """ | |
| from dashboard.theme import GREEN, RED, TEXT_MUTED | |
| company = brief.get("company_name", ticker) | |
| filing_date = brief.get("filing_date", "") | |
| me = brief.get("market_expectations") or {} | |
| event_returns_aligned = ( | |
| isinstance(me, dict) | |
| and _display_policy_allows(brief, "event_returns_aligned") | |
| and me.get("event_aligned") is True | |
| and me.get("event_comparison_allowed") is True | |
| ) | |
| d1 = ( | |
| me.get("d1_price_reaction_pct") | |
| if event_returns_aligned | |
| else None | |
| ) | |
| # D1 reaction | |
| d1_html = "" | |
| if d1 is not None: | |
| color = GREEN if d1 >= 0 else RED | |
| prefix = "+" if d1 >= 0 else "" | |
| d1_html = ( | |
| f'<span style="background:{"#DCEBE3" if d1 >= 0 else "#F3DDD8"};' | |
| f'color:{color};border:1px solid {color}33;' | |
| f'border-radius:4px;padding:2px 8px;font-size:0.75rem;font-weight:600;">' | |
| f'D1 {prefix}{d1:.1f}%</span>' | |
| ) | |
| # Filing date and generation date — kept visually distinct so "as of" never | |
| # gets misread as "when this brief was produced" (the two can differ by | |
| # weeks if a persisted brief is reloaded, or the filing itself is old). | |
| date_html = "" | |
| if filing_date: | |
| date_html = ( | |
| f'<span style="font-size:0.75rem;color:{TEXT_MUTED};">{t("as_of")} {filing_date}</span>' | |
| ) | |
| generated_at = str(brief.get("generated_at") or "")[:10] | |
| generated_html = "" | |
| if generated_at and generated_at != filing_date: | |
| generated_html = ( | |
| f'<span style="font-size:0.75rem;color:{TEXT_MUTED};">{t("generated_prefix")} {generated_at}</span>' | |
| ) | |
| # Reliability breakdown — mini stacked bar (hover for the exact split) | |
| rel_html = ( | |
| _reliability_bar_html(brief) | |
| if _display_policy_allows(brief, "aggregate_reliability_meaningful") | |
| else "" | |
| ) | |
| # Dot separator helper | |
| sep = f'<span style="color:#8C968F;font-size:0.7rem;">·</span>' | |
| inner_parts = [ | |
| f'<span style="font-weight:700;font-size:0.9rem;color:#15201B;">{ticker}</span>', | |
| f'<span style="font-size:0.82rem;color:#3E4A44;">{company}</span>', | |
| ] | |
| if date_html: | |
| inner_parts.append(date_html) | |
| if generated_html: | |
| inner_parts.append(generated_html) | |
| if d1_html: | |
| inner_parts.append(d1_html) | |
| if rel_html: | |
| inner_parts.append(rel_html) | |
| inner = f" {sep} ".join(inner_parts) | |
| st.markdown( | |
| f'<div class="primer-sticky-bar">' | |
| f'<div style="display:flex;align-items:center;gap:10px;flex-wrap:wrap;">' | |
| f'{inner}' | |
| f'</div>' | |
| f'</div>', | |
| unsafe_allow_html=True, | |
| ) | |
| # ── Background generation thread ───────────────────────────────────────────────── | |
| def _run_brief_thread(ticker: str, gen: dict, language: str, config: RunConfig) -> None: | |
| """Run brief generation in a background thread. | |
| `config` is a frozen snapshot taken in the main thread at click time — | |
| this function never reads st.session_state, so a mid-run change to the | |
| sidebar picker cannot affect an in-flight run. | |
| """ | |
| initial = { | |
| "ticker": ticker, | |
| "messages": [HumanMessage(content=f"Generate a research brief for {ticker}.")], | |
| "tool_round_count": 0, | |
| "nudge_fired": False, | |
| "profile_payloads": None, | |
| "language": language, | |
| "brief": None, | |
| "brief_markdown": None, | |
| "synthesis_error": None, | |
| } | |
| try: | |
| from agent.graph import create_graph | |
| graph = create_graph(config) | |
| for event in graph.stream(initial, stream_mode="updates"): | |
| for node_name, output in event.items(): | |
| if output is None: | |
| continue | |
| msgs = output.get("messages") or [] | |
| if node_name == "agent": | |
| reasoning_panel.absorb_agent_messages(gen["trace"], msgs) | |
| gen["all_messages"].extend(msgs) | |
| # If the agent stopped emitting tool_calls, synthesis is next | |
| last = msgs[-1] if msgs else None | |
| if last and not getattr(last, "tool_calls", None): | |
| reasoning_panel.mark_synthesis(gen["trace"], "in_progress") | |
| elif node_name == "tools": | |
| reasoning_panel.absorb_tool_messages(gen["trace"], msgs) | |
| gen["all_messages"].extend(msgs) | |
| elif node_name == "nudge": | |
| for msg in msgs: | |
| text = getattr(msg, "content", "") | |
| if text: | |
| gen["trace"].append({"kind": "assistant_text", "text": f"⚠ Coverage nudge: {text}"}) | |
| elif node_name == "synthesis": | |
| gen["brief"] = output.get("brief") | |
| gen["error"] = output.get("synthesis_error") | |
| reasoning_panel.mark_synthesis(gen["trace"], "done", error=gen["error"]) | |
| except Exception as exc: | |
| import sys | |
| print(f"[gen thread error] {exc}", file=sys.stderr) | |
| gen["error"] = classify_llm_error(exc, config.provider) or str(exc) | |
| finally: | |
| gen["running"] = False | |
| if generate_clicked and ticker_input and not st.session_state["gen"]["running"] and run_cfg is not None: | |
| gen = st.session_state["gen"] | |
| gen.update( | |
| running=True, ticker=ticker_input, trace=[], | |
| brief=None, error=None, all_messages=[], config=run_cfg, | |
| ) | |
| _chosen_language = i18n.report_language() | |
| # NB: never name this `t` — it would shadow the i18n t() helper. | |
| _thread_args = (ticker_input, gen, _chosen_language, run_cfg) | |
| try: | |
| from streamlit.runtime.scriptrunner import add_script_run_ctx | |
| _gen_thread = threading.Thread(target=_run_brief_thread, args=_thread_args, daemon=True) | |
| add_script_run_ctx(_gen_thread) | |
| _gen_thread.start() | |
| except Exception: | |
| # Fallback: run synchronously if thread context attachment fails | |
| _gen_thread = threading.Thread(target=_run_brief_thread, args=_thread_args, daemon=True) | |
| _gen_thread.start() | |
| # ── Live trace poller (polls every 400ms while generation runs) ────────────────── | |
| def _live_trace_fragment() -> None: | |
| gen = st.session_state.get("gen", {}) | |
| if not gen.get("running") and not gen.get("trace"): | |
| return | |
| trace = gen["trace"] | |
| progress_val, progress_label = reasoning_panel.estimate_progress(trace) | |
| pct = int(progress_val * 100) | |
| ticker_label = gen.get("ticker", "") | |
| st.markdown( | |
| f'<div style="background:#F5F6F3;border:1px solid #D5DAD4;border-radius:12px;' | |
| f'padding:16px 20px;margin-bottom:16px;">' | |
| f'<div style="display:flex;justify-content:space-between;align-items:baseline;margin-bottom:4px;">' | |
| f'<div style="font-size:0.88rem;font-weight:600;color:#15201B;">' | |
| f'{t("generating_brief")} — <code style="background:#ECEEE9;padding:1px 7px;border-radius:5px;font-size:0.82rem;">{ticker_label}</code>' | |
| f'</div>' | |
| f'<div style="font-size:1rem;font-weight:700;color:#1E6B55;">{pct}%</div>' | |
| f'</div>' | |
| f'<div style="font-size:0.75rem;color:#3E4A44;margin-bottom:10px;">{progress_label}</div>' | |
| f'<div style="background:#D5DAD4;border-radius:999px;height:7px;overflow:hidden;">' | |
| f'<div style="background:linear-gradient(90deg,#1E6B55,#134A3B);height:100%;' | |
| f'width:{pct}%;border-radius:999px;transition:width 0.4s ease;"></div>' | |
| f'</div>' | |
| f'</div>', | |
| unsafe_allow_html=True, | |
| ) | |
| agent_graph.render(trace) | |
| with st.expander(t("detailed_reasoning"), expanded=False): | |
| reasoning_panel.render_trace_body(trace) | |
| if gen.get("error") and not gen.get("brief"): | |
| st.error(f"{t('gen_error_prefix')} {gen['error']}") | |
| if gen.get("running"): | |
| # Still generating — poll again in 400 ms (server-side timer avoids HF Spaces proxy race) | |
| time.sleep(0.4) | |
| st.rerun() | |
| else: | |
| # Thread has finished — persist results and navigate | |
| if gen.get("brief"): | |
| try: | |
| from agent.cost_log import compute_run_cost, log_usage | |
| from agent.llm import ANTHROPIC_DEFAULT_MODEL | |
| # Bill the model that actually ran this generation — the frozen | |
| # snapshot taken at click time, not whatever the sidebar picker | |
| # shows now (the visitor may have switched provider mid-run). | |
| _cfg = gen.get("config") | |
| run_model = _cfg.model if _cfg else ANTHROPIC_DEFAULT_MODEL | |
| cost = compute_run_cost(gen["all_messages"], run_model) | |
| # The narrative is composed in a call outside the graph's | |
| # message list, so its tokens reach the log only from here. | |
| extra = (gen["brief"] or {}).get("narrative_usage") or {} | |
| for key in ("input_tokens", "output_tokens", "cost_usd"): | |
| cost[key] = round(cost.get(key, 0) + extra.get(key, 0), 6) | |
| log_usage(gen["ticker"], run_model, cost["input_tokens"], cost["output_tokens"]) | |
| st.session_state["_last_cost"] = cost | |
| st.session_state["_last_cost_ticker"] = gen["ticker"] | |
| except Exception: | |
| pass | |
| st.session_state["brief"] = gen["brief"] | |
| st.session_state["brief_ticker"] = gen["ticker"] | |
| # Invalidate translation cache for the fresh brief | |
| st.session_state.pop("_display_brief_cache", None) | |
| st.session_state.pop("_translate_failed", None) | |
| # Persist brief for the Coverage list + reload across sessions | |
| # (non-critical — never blocks UI) | |
| try: | |
| from storage import briefs_db | |
| briefs_db.save_brief(gen["ticker"], gen["brief"]) | |
| except Exception: | |
| pass | |
| st.session_state.setdefault("reasoning_trace", {})[gen["ticker"]] = list(gen["trace"]) | |
| st.session_state["_nav_pending_key"] = "verdict" | |
| gen.update(running=False, trace=[], brief=None, error=None, all_messages=[]) | |
| st.rerun() | |
| else: | |
| # Failure: store error message, clean up, return to normal UI | |
| err_msg = gen.get("error") or t("no_brief_error").format(ticker=gen.get("ticker", "")) | |
| st.session_state["_gen_error"] = (gen.get("ticker", ""), err_msg) | |
| gen.update(running=False, trace=[], brief=None, error=None, all_messages=[]) | |
| st.rerun() | |
| # ── Main content routing ────────────────────────────────────────────────────────── | |
| def _display_company_profile(profile: dict, config: RunConfig | None) -> dict: | |
| target_language = i18n.report_language() | |
| if target_language == "English": | |
| return profile | |
| profile_id = profile.get("_profile_id") | |
| if not profile_id: | |
| return profile | |
| try: | |
| from storage import company_profiles | |
| cached = company_profiles.get_translation(profile_id, target_language) | |
| if cached: | |
| return cached | |
| if config is None: | |
| return profile | |
| from agent.company_profile import translate_company_profile | |
| with st.spinner(t("translating_brief")): | |
| translated, usage = translate_company_profile(profile, target_language, config) | |
| if translated is not profile and translated.get("language") == target_language: | |
| company_profiles.save_translation(profile_id, target_language, translated) | |
| _absorb_translation_cost(str(profile.get("ticker") or ""), usage, config.model) | |
| return translated | |
| except Exception: | |
| pass | |
| st.caption(t("translation_failed")) | |
| return profile | |
| def _render_company_route(ticker: str, config: RunConfig | None) -> None: | |
| from agent.company_profile import profile_source_coverage, source_fingerprint | |
| from storage import company_profiles | |
| fingerprint = source_fingerprint(ticker) | |
| profile = company_profiles.get_latest_profile( | |
| ticker, | |
| source_fingerprint=fingerprint, | |
| language="English", | |
| ) | |
| stale = False | |
| if profile is None: | |
| profile = company_profiles.get_latest_profile(ticker, language="English") | |
| stale = profile is not None | |
| if profile is None: | |
| st.markdown( | |
| f""" | |
| <div style="text-align:center;padding:48px 0;color:#3E4A44;"> | |
| <div style="width:32px;height:32px;margin:0 auto 12px;border-radius:8px; | |
| background:#DCEBE3;border:1px solid #1E6B55;"></div> | |
| <div style="font-size:1.1rem;font-weight:600;margin-bottom:6px;color:#15201B;">{t("overview_empty_title")}</div> | |
| <div style="font-size:0.9rem;">{t("overview_empty_body")}</div> | |
| </div> | |
| """, | |
| unsafe_allow_html=True, | |
| ) | |
| return | |
| if stale: | |
| st.caption(t("overview_stale")) | |
| coverage = profile_source_coverage(ticker) | |
| if ( | |
| coverage.get("business_sections_attempted", 0) < 1 | |
| or coverage.get("segments_geography_sections_attempted", 0) < 1 | |
| ): | |
| warning_key = ( | |
| "primer_backfill_warning_hosted" | |
| if is_hosted_space() | |
| else "primer_backfill_warning" | |
| ) | |
| st.warning(t(warning_key).format(ticker=ticker)) | |
| display_profile = _display_company_profile(profile, config) | |
| company_name = str(display_profile.get("company_name") or ticker) | |
| from analytics.company_news import fetch_company_news | |
| from analytics.company_market import fetch_company_market | |
| with st.spinner(t("primer_loading_market")): | |
| news_items, news_error = fetch_company_news(ticker, company_name) | |
| market, market_error = fetch_company_market(ticker, company_name) | |
| import copy | |
| from analysis.company_attention import attach_attention_stats | |
| display_profile = attach_attention_stats(copy.deepcopy(display_profile), ticker, news_items) | |
| from dashboard.company_primer import render as render_company_primer | |
| render_company_primer( | |
| display_profile, | |
| ticker, | |
| market=market, | |
| news_items=news_items, | |
| news_error=news_error, | |
| ) | |
| if market_error: | |
| st.caption(market_error) | |
| def _render_landing(coverage: list[dict]) -> None: | |
| """First screen for a visitor with no ticker selected. | |
| The previous version was a single sentence over an empty green square: it | |
| never said what a brief actually contains, and the only thing a newcomer | |
| could click — the saved-brief list — sat below the fold in the sidebar. | |
| This states the promise, names the five sections, and puts the saved briefs | |
| front and centre so the app can be seen working without waiting for a run. | |
| """ | |
| from dashboard.theme import ( | |
| BG, BORDER, TEXT, TEXT_MUTED, TEXT_FAINT, BRAND_GREEN, AI_COLOR, | |
| ) | |
| st.markdown( | |
| f""" | |
| <div style="max-width:720px;margin:36px 0 28px;"> | |
| <div style="font-size:1.75rem;font-weight:700;color:{TEXT}; | |
| letter-spacing:-0.02em;line-height:1.25;margin-bottom:12px;"> | |
| {t("landing_title")} | |
| </div> | |
| <div style="font-size:0.95rem;color:{TEXT_MUTED};line-height:1.65;"> | |
| {t("landing_body")} | |
| </div> | |
| </div> | |
| """, | |
| unsafe_allow_html=True, | |
| ) | |
| # ── What you get — one card per destination, in nav order ──────────────── | |
| st.markdown( | |
| f'<div style="font-size:0.6rem;font-weight:700;text-transform:uppercase;' | |
| f'letter-spacing:0.1em;color:{TEXT_FAINT};margin:8px 0 10px;">' | |
| f'{t("landing_sections_title")}</div>', | |
| unsafe_allow_html=True, | |
| ) | |
| cards = [ | |
| ("nav_company", "landing_card_company", BRAND_GREEN), | |
| ("nav_verdict", "landing_card_verdict", BRAND_GREEN), | |
| ("nav_signals", "landing_card_signals", BRAND_GREEN), | |
| ("nav_financials", "landing_card_financials", BRAND_GREEN), | |
| ("nav_chat", "landing_card_chat", AI_COLOR), | |
| ] | |
| cols = st.columns(len(cards), gap="small") | |
| for col, (label_key, body_key, accent) in zip(cols, cards): | |
| with col: | |
| st.markdown( | |
| f'<div style="background:{BG};border:1px solid {BORDER};' | |
| f'border-left:3px solid {accent};border-radius:10px;' | |
| f'padding:14px 16px;height:100%;min-height:150px;">' | |
| f'<div style="font-size:0.85rem;font-weight:600;color:{TEXT};' | |
| f'margin-bottom:7px;">{t(label_key)}</div>' | |
| f'<div style="font-size:0.78rem;color:{TEXT_MUTED};line-height:1.55;">' | |
| f'{t(body_key)}</div>' | |
| f'</div>', | |
| unsafe_allow_html=True, | |
| ) | |
| # ── Saved briefs — the fastest path to seeing real output ──────────────── | |
| st.markdown( | |
| f'<div style="font-size:0.6rem;font-weight:700;text-transform:uppercase;' | |
| f'letter-spacing:0.1em;color:{TEXT_FAINT};margin:30px 0 6px;">' | |
| f'{t("landing_start_title")}</div>', | |
| unsafe_allow_html=True, | |
| ) | |
| if not coverage: | |
| st.caption(t("landing_start_empty")) | |
| return | |
| st.markdown( | |
| f'<div style="font-size:0.82rem;color:{TEXT_MUTED};margin-bottom:12px;">' | |
| f'{t("landing_start_body")}</div>', | |
| unsafe_allow_html=True, | |
| ) | |
| # Cap the row so a long coverage list cannot stretch the buttons to slivers. | |
| row = coverage[:6] | |
| for col, entry in zip(st.columns(max(len(row), 3), gap="small"), row): | |
| with col: | |
| label = ( | |
| f'{entry["ticker"]} · {entry["filing_date"]}' | |
| if entry.get("filing_date") else entry["ticker"] | |
| ) | |
| if st.button(label, key=f'landing_cov_{entry["ticker"]}', | |
| use_container_width=True): | |
| st.session_state["_pending_ticker"] = entry["ticker"] | |
| st.rerun() | |
| gen_error = st.session_state.pop("_gen_error", None) | |
| if gen_error: | |
| err_ticker, err_msg = gen_error | |
| st.error(f"{t('brief_error_prefix')} **{err_ticker}**: {err_msg}") | |
| gen = st.session_state["gen"] | |
| active_key = st.session_state.get("nav_key", "company") | |
| if gen["running"] or gen.get("trace"): | |
| _live_trace_fragment() | |
| elif not ticker_input: | |
| _render_landing(_coverage) | |
| else: | |
| # Active ticker, not generating — show context bar then route to section | |
| brief = _get_display_brief(_get_cached_brief(), ticker_input, run_cfg) | |
| # The Brief carries its own masthead — ticker, company, period, filing date | |
| # and the whole data rail. Stacking the app's context bar on top of it would | |
| # print the same facts twice and push the note's own head below the fold. | |
| if brief and active_key != "verdict": | |
| _render_ticker_bar(ticker_input, brief) | |
| if active_key == "company": | |
| _render_company_route(ticker_input, run_cfg) | |
| elif active_key == "verdict": | |
| if brief: | |
| # The Brief is the research note: masthead, ten sections, sticky | |
| # contents and data rail, sourced footer. dashboard/note.py. | |
| from dashboard.note import render as render_note | |
| render_note(brief) | |
| else: | |
| st.markdown( | |
| f""" | |
| <div style="text-align:center;padding:48px 0;color:#3E4A44;"> | |
| <div style="width:32px;height:32px;margin:0 auto 12px;border-radius:8px; | |
| background:#DCEBE3;border:1px solid #1E6B55;"></div> | |
| <div style="font-size:1.1rem;font-weight:600;margin-bottom:6px;color:#15201B;">{t("snapshot_empty_title")}</div> | |
| <div style="font-size:0.9rem;">{t("snapshot_empty_body")}</div> | |
| </div> | |
| """, | |
| unsafe_allow_html=True, | |
| ) | |
| elif active_key == "signals": | |
| if brief: | |
| from dashboard.signals_view import render as render_signals | |
| render_signals(brief, ticker_input) | |
| else: | |
| _brief_placeholder(t("nav_signals")) | |
| elif active_key == "financials": | |
| from dashboard.financials import render as render_financials | |
| render_financials(ticker_input, brief) | |
| elif active_key == "chat": | |
| from dashboard.chat import render as render_chat | |
| render_chat(ticker_input, brief=brief, config=run_cfg) | |
| # ── Global data disclaimer ───────────────────────────────────────────────────── | |
| if ( | |
| ticker_input | |
| and not gen.get("running") | |
| and not gen.get("trace") | |
| # The note closes with this same text under its own "Avertissement" | |
| # heading, so the page-level copy would be the second one. | |
| and active_key != "verdict" | |
| ): | |
| st.markdown( | |
| f'<div style="margin-top:40px;border-top:1px solid #D5DAD4;padding-top:12px;' | |
| f'font-size:0.72rem;color:#8C968F;line-height:1.5;">' | |
| f'{t("disclaimer")}' | |
| f'</div>', | |
| unsafe_allow_html=True, | |
| ) | |