Spaces:
Sleeping
Sleeping
| """Upwork Proposal Strategist — Streamlit entry point. | |
| End users never run this directly — they double-click the launcher (see | |
| README), which opens the app in their web browser. Developers launch it via | |
| ``python desktop_app.py`` (same thing — starts the server and opens the browser) | |
| or, after ``pip install -e .``, ``python -m streamlit run app/main.py`` — no | |
| PYTHONPATH needed in either case, because the project is an installable package | |
| and the launcher puts the project root on ``sys.path``. See DEVELOPER.md. | |
| """ | |
| from __future__ import annotations | |
| import copy | |
| import traceback | |
| from datetime import datetime, timezone | |
| import streamlit as st | |
| from app.config import ( | |
| APP_TITLE, APP_TAGLINE, | |
| get_settings, reload_settings, | |
| get_saved_dossier_path, save_dossier_path, | |
| apply_session_overrides, REMEMBERED_CONFIG_KEYS, | |
| ) | |
| from app.services import browser_tag, diagnostics, key_store | |
| from app.services.api_gate import ApiGateError, run_capability_test | |
| from app.services.folder_validator import score_evidence, validate | |
| from app.services.dossier_reader import read_dossier | |
| from app.services.evidence_index import build_evidence_index | |
| from app.ui import ( | |
| setup_screen, | |
| dossier_screen, | |
| interview_screen, | |
| screenshot_screen, | |
| confirmation_screen, | |
| analysis_screen, | |
| proposal_screen, | |
| ) | |
| from app.ui import api_usage_panel, diagnostics_panel, motion_runtime, theme | |
| from app.utils.logging_utils import get_logger | |
| _logger = get_logger("upwork_strategist.main") | |
| # (step key, sidebar label) in flow order. | |
| STEPS: list[tuple[str, str]] = [ | |
| ("setup", "Setup"), | |
| ("dossier", "Dossier"), | |
| ("screenshot", "Job Screenshot"), | |
| ("confirmation", "Confirm Details"), | |
| ("analysis", "Analysis"), | |
| ("proposal", "Proposal"), | |
| ] | |
| # "Confirm Details" is a developer/admin-only screen. Normal users get a | |
| # clean Setup → Dossier → Job Screenshot → Analysis → Proposal flow; the | |
| # extracted job fields are confirmed automatically in the backend right | |
| # after extraction, so these steps are hidden unless SHOW_DEBUG_PANEL=true. | |
| DEBUG_ONLY_STEPS: frozenset[str] = frozenset({"confirmation"}) | |
| # Screens that are a second route through a step rather than a step of their | |
| # own. They are reachable and renderable, but they are NOT in STEPS: they | |
| # borrow their parent's rail row, breadcrumb, step number and accent, so the | |
| # workflow stays the same length however the user builds their profile. | |
| # | |
| # The interview is one of these. It is an alternative to reading a dossier | |
| # folder — same step, same outcome (an evidence index), different input — so | |
| # giving it its own rail row would tell the user the flow grew a step when it | |
| # did not, and would leave "Step N of M" counting differently depending on | |
| # which route they took. | |
| STEP_PARENT: dict[str, str] = {"interview": "dossier"} | |
| def _parent_step(step_key: str) -> str: | |
| """The step a sub-screen reports as, for the rail and the top bar.""" | |
| return STEP_PARENT.get(step_key, step_key) | |
| def _visible_steps(show_debug: bool) -> list[tuple[str, str]]: | |
| """Return the steps shown in the sidebar for the current mode.""" | |
| if show_debug: | |
| return list(STEPS) | |
| return [(key, label) for key, label in STEPS if key not in DEBUG_ONLY_STEPS] | |
| RENDERERS = { | |
| "setup": setup_screen.render, | |
| "dossier": dossier_screen.render, | |
| "interview": interview_screen.render, | |
| "screenshot": screenshot_screen.render, | |
| "confirmation": confirmation_screen.render, | |
| "analysis": analysis_screen.render, | |
| "proposal": proposal_screen.render, | |
| } | |
| SESSION_DEFAULTS: dict[str, object] = { | |
| # Setup gate | |
| "api_status": None, | |
| "api_ok": False, | |
| # Theme (light default) | |
| "theme_dark": True, | |
| # Navigation | |
| "current_step": "setup", | |
| # Dossier flow | |
| "dossier_folder_path": "", | |
| "dossier_validation": None, | |
| "dossier_chunks": None, | |
| "dossier_read": False, | |
| "dossier_read_error": False, | |
| "evidence_index": None, | |
| "canonical_profile": None, | |
| "evidence_index_meta": None, | |
| # Interview (the second route through Dossier) | |
| "profile_source": "dossier", | |
| "interview_state": None, | |
| "interview_started": False, | |
| "interview_last_turn": None, | |
| "interview_turn_seq": 0, | |
| # Published by the interview when it builds a profile; None until then. | |
| # Declared here rather than left to spring into existence on the first | |
| # build, so every reader (Analysis scores with it, Dossier decides | |
| # whether to still offer a gap-fill interview with it) sees the same key | |
| # from the first rerun and a reset can return it to a value that exists. | |
| "interview_strength": None, | |
| # Screenshots | |
| "screenshots_uploaded": False, | |
| "uploaded_screenshots": [], | |
| "pasted_screenshots": [], | |
| "screenshot_upload_sig": (), | |
| "extracted_job_fields": None, | |
| # Confirmation | |
| "confirmed_job_fields": None, | |
| "fields_confirmed": False, | |
| "current_job_fingerprint": None, | |
| # Analysis output | |
| "scoring_result": None, | |
| "recommendation_result": None, | |
| "match_data": None, | |
| "generated_proposal": None, | |
| "verified_proposal": None, | |
| "proposal_context": None, | |
| "selected_evidence_for_proposal": None, | |
| # API usage tracking | |
| "api_usage_log": [], | |
| } | |
| def _init_session_state() -> None: | |
| for key, value in SESSION_DEFAULTS.items(): | |
| if key not in st.session_state: | |
| # A copy per session: this process serves every visitor, and the | |
| # defaults themselves would hand them all one shared list (the | |
| # usage log is appended to in place, so one visitor's calls and | |
| # failures would show up in everyone's panels and reports). | |
| st.session_state[key] = copy.deepcopy(value) | |
| def _is_unlocked(step_key: str) -> bool: | |
| if step_key == "setup": | |
| return True | |
| if step_key == "dossier": | |
| return bool(st.session_state.get("api_ok")) | |
| if step_key == "interview": | |
| # Same gate as its parent step: the interview needs a working API key | |
| # and nothing else. Without this branch the sweep below would bounce | |
| # the user straight back to Setup the moment they opened it. | |
| return bool(st.session_state.get("api_ok")) | |
| if step_key == "screenshot": | |
| return bool(st.session_state.get("evidence_index")) | |
| if step_key == "confirmation": | |
| return bool(st.session_state.get("extracted_job_fields")) | |
| if step_key == "analysis": | |
| return bool(st.session_state.get("fields_confirmed")) | |
| if step_key == "proposal": | |
| # Also locked while the analysis is being worked out again: a draft | |
| # started now would build on the verdict that is about to change. | |
| return bool( | |
| st.session_state.get("fields_confirmed") | |
| and st.session_state.get("recommendation_result") | |
| and not st.session_state.get("analysis_running") | |
| ) | |
| return False | |
| def _proposal_state() -> str | None: | |
| """Where the stored proposal stands, in the Proposal screen's own terms. | |
| ``"ready"``: a draft the screen offers to send (fact-checked, or marked | |
| as not fact-checked when the check could not run). ``"review"``: the | |
| fact-check ran and flagged claims, so the screen asks for a closer look | |
| first. ``"retry"``: nothing to send — the check left no text, or the AI | |
| did not write it and only the fixed outline is there. ``None`` before any | |
| result. The rail tick and the header pill both read this, so neither | |
| calls a proposal ready while the screen is saying it is not. | |
| """ | |
| vp = st.session_state.get("verified_proposal") | |
| if not isinstance(vp, dict) or not vp: | |
| return None | |
| written_by_ai = bool((vp.get("__meta__") or {}).get("used_api")) | |
| if not written_by_ai or not str(vp.get("proposal") or "").strip(): | |
| return "retry" | |
| if vp.get("verification_status") == "failed": | |
| return "review" | |
| return "ready" | |
| def _is_completed(step_key: str) -> bool: | |
| if step_key == "setup": | |
| return bool(st.session_state.get("api_ok")) | |
| if step_key == "dossier": | |
| return bool(st.session_state.get("evidence_index")) | |
| if step_key == "interview": | |
| return bool( | |
| st.session_state.get("evidence_index") | |
| and st.session_state.get("profile_source") == "interview" | |
| ) | |
| if step_key == "screenshot": | |
| return bool(st.session_state.get("extracted_job_fields")) | |
| if step_key == "confirmation": | |
| return bool(st.session_state.get("fields_confirmed")) | |
| if step_key == "analysis": | |
| return bool(st.session_state.get("recommendation_result")) | |
| if step_key == "proposal": | |
| return _proposal_state() == "ready" | |
| return False | |
| def _lock_reason(step_key: str, show_debug: bool = False) -> str: | |
| if step_key in ("dossier", "interview"): | |
| return "Locked — run the API check first." | |
| if step_key == "screenshot": | |
| return "Locked — read your dossier and build proof points first." | |
| if step_key == "confirmation": | |
| return "Locked — extract job details from a screenshot first." | |
| if step_key == "analysis": | |
| if show_debug: | |
| return "Locked — confirm the job details first." | |
| # Confirm Details is hidden outside debug mode: the details are | |
| # confirmed when the user presses Analyze Opportunity. | |
| return "Locked — add a job screenshot and press Analyze Opportunity first." | |
| if step_key == "proposal": | |
| if st.session_state.get("analysis_running"): | |
| return "Locked — wait for the analysis to finish." | |
| return "Locked — run the analysis first." | |
| return "Locked." | |
| def _step_status(step_key: str, current: str) -> str: | |
| if step_key == current: | |
| return "current" | |
| if not _is_unlocked(step_key): | |
| return "locked" | |
| if _is_completed(step_key): | |
| return "completed" | |
| return "available" | |
| # Quiet glyphs that read as a clean status, not technical noise. | |
| _STATUS_GLYPH = { | |
| "completed": "✓", | |
| "current": "●", | |
| "available": "○", | |
| "locked": "◦", | |
| } | |
| # Session status pill -> the design canvas's pill tones. | |
| _CHIP_TONE = {"ready": "ok", "info": "violet", "attention": "warn", "missing": "stop"} | |
| # The pill for a stored proposal, by _proposal_state(). | |
| _PROPOSAL_CHIP = { | |
| "ready": ("Proposal Ready", "ready"), | |
| "review": ("Proposal Needs Review", "attention"), | |
| "retry": ("Proposal Needs a Retry", "attention"), | |
| } | |
| def _header_chip() -> tuple[str, str]: | |
| proposal = _proposal_state() | |
| if proposal: | |
| return _PROPOSAL_CHIP[proposal] | |
| if st.session_state.get("recommendation_result"): | |
| return "Analysis Ready", "info" | |
| if st.session_state.get("api_ok"): | |
| return "API Ready", "ready" | |
| return "API Missing", "missing" | |
| def _render_sidebar(show_debug: bool) -> None: | |
| # The rail from the design canvas: brand lockup, a caption, one row per | |
| # step, and the engine card pinned to the foot. The rows are still real | |
| # st.button controls — the widget layer gives each one its step icon and | |
| # its on / done / locked state. | |
| theme.sidebar_brand(APP_TITLE, APP_TAGLINE) | |
| theme.rail_cap("Workflow") | |
| current = st.session_state.current_step | |
| # A sub-screen lights its parent's row, so the rail always shows where the | |
| # user is in the workflow — but the row still navigates, because from the | |
| # interview "Dossier" means "take me back to the folder route". | |
| rail_current = _parent_step(current) | |
| for key, label in _visible_steps(show_debug): | |
| status = _step_status(key, rail_current) | |
| unlocked = status != "locked" | |
| glyph = _STATUS_GLYPH.get(status, "○") | |
| # The ordinal moved to the top bar, which now shows the live segmented | |
| # rail and "Step N of M". The glyph stays: it is the only per-row state | |
| # signal Streamlit does not already express through type= / disabled. | |
| btn_label = f"{glyph} {label}" | |
| clicked = st.button( | |
| btn_label, | |
| key=f"nav_btn_{key}", | |
| type="primary" if status == "current" else "secondary", | |
| disabled=not unlocked, | |
| use_container_width=True, | |
| help=None if unlocked else _lock_reason(key, show_debug), | |
| ) | |
| if clicked and unlocked and key != current: | |
| st.session_state.current_step = key | |
| st.rerun() | |
| # API status warning — shown any time the key is no longer working so the | |
| # user knows why things are failing without hunting through the screens. | |
| if st.session_state.get("api_ok") is False and st.session_state.get("api_status") not in (None,): | |
| st.warning("AI service issue — go to Setup to fix it.") | |
| # ── Always-visible settings link ─────────────────────────────────── | |
| # The Setup screen is auto-skipped once an API key is saved, so users | |
| # need an explicit way back to change it. | |
| st.divider() | |
| if st.button( | |
| "Change API Settings", | |
| key="goto_setup_btn", | |
| use_container_width=True, | |
| type="secondary", | |
| help="Go back to Setup to change your API key or AI provider.", | |
| ): | |
| st.session_state.current_step = "setup" | |
| st.rerun() | |
| # Dark / light theme toggle. | |
| dark_on = st.toggle( | |
| "Dark mode", | |
| value=bool(st.session_state.get("theme_dark", True)), | |
| key="theme_toggle", | |
| ) | |
| if dark_on != st.session_state.get("theme_dark"): | |
| st.session_state.theme_dark = dark_on | |
| st.rerun() | |
| # Problem/diagnostics panel. NOT debug-gated: a user who hits an error is | |
| # precisely the user who cannot flip SHOW_DEBUG_PANEL, so the explanation | |
| # and the share button have to be reachable by default. Renders nothing | |
| # when there are no failures, leaving a healthy run visually unchanged. | |
| diagnostics_panel.render(key_suffix="sidebar") | |
| # Developer-only API usage panel. Hidden unless SHOW_DEBUG_PANEL=true. | |
| api_usage_panel.render(key_suffix="sidebar") | |
| # The engine card closes the rail, as on the design canvas. The provider | |
| # and model names are debug-gated exactly as everywhere else in this app | |
| # (Settings.show_debug_panel), so a normal user sees the state of their AI | |
| # service and nothing about which one it is. | |
| _render_engine_card(show_debug) | |
| def _render_engine_card(show_debug: bool) -> None: | |
| settings = get_settings() | |
| ok = bool(st.session_state.get("api_ok")) | |
| if show_debug: | |
| theme.engine_card( | |
| "Engine", | |
| settings.active_model or "Not configured", | |
| f"{settings.active_provider or 'no provider'} · " | |
| + ("connected" if ok else "not connected"), | |
| "ok" if ok else "stop", | |
| ) | |
| return | |
| theme.engine_card( | |
| "AI service", | |
| "Connected" if ok else "Not connected", | |
| "Ready for analysis" if ok else "Set your key on Setup", | |
| "ok" if ok else "warn", | |
| ) | |
| def _try_restore_saved_config() -> None: | |
| """Load this browser's saved (encrypted) Setup config from Supabase. | |
| Runs once per session. Only acts when key storage is configured and the | |
| session has no API key yet. On success it applies the saved provider / | |
| model / key / vision settings into the session so the rest of the app — | |
| including smart-landing's API check — proceeds as if the user just set up. | |
| Entirely fail-safe (see :mod:`app.services.key_store`): any failure leaves | |
| the session untouched and the user simply lands on Setup as before. | |
| """ | |
| ss = st.session_state | |
| if ss.get("_restore_done"): | |
| return | |
| if not key_store.is_configured(): | |
| ss["_restore_done"] = True | |
| return | |
| if get_settings().has_api_key: | |
| ss["_restore_done"] = True | |
| return | |
| tag = browser_tag.get_or_create_tag() | |
| if not tag: | |
| return # tag not available yet; try again on the next render | |
| # A Clear Credentials whose delete failed is finished first: the user | |
| # asked for this browser's saved key to be forgotten, so nothing is | |
| # restored while that delete is still pending. | |
| if setup_screen.finish_pending_forget(tag): | |
| ss["_restore_done"] = True | |
| return | |
| stored = key_store.load_config(tag) | |
| ss["_restore_done"] = True | |
| # Provider, model and key choices only. A config saved by an older version | |
| # also holds operator-only settings such as SHOW_DEBUG_PANEL, which must | |
| # keep following the server rather than what it was at save time. | |
| stored = { | |
| k: v for k, v in (stored or {}).items() if k in REMEMBERED_CONFIG_KEYS | |
| } | |
| if stored: | |
| apply_session_overrides(stored) | |
| ss["_config_restored"] = True | |
| def _try_smart_landing(settings) -> None: | |
| """On a fresh session, silently restore Setup + Dossier if already done. | |
| Setup: re-run the API check. If it passes, mark api_ok = True. | |
| Dossier: if a folder path was previously entered AND is still valid, | |
| silently re-load the evidence index. If the path is gone/broken, show | |
| a sidebar warning instead of forcing the user back to the Dossier screen. | |
| On success both steps are skipped and the user lands on Job Screenshot. | |
| On any failure the user lands on the broken step as normal. | |
| """ | |
| ss = st.session_state | |
| # --- Step 1: API check ------------------------------------------- | |
| # Only attempt if a key is already saved; don't block if it's missing. | |
| if not ss.get("api_ok") and settings.has_api_key: | |
| try: | |
| result = run_capability_test(settings=settings, live=True) | |
| if result.ok: | |
| ss["api_ok"] = True | |
| ss["api_status"] = ApiGateError.API_OK | |
| else: | |
| ss["api_ok"] = False | |
| ss["api_status"] = result.status | |
| # Can't go further without a working API key. | |
| ss["current_step"] = "setup" | |
| return | |
| except Exception: | |
| ss["api_ok"] = False | |
| ss["current_step"] = "setup" | |
| return | |
| if not ss.get("api_ok"): | |
| # No key saved at all → stay on Setup. | |
| ss["current_step"] = "setup" | |
| return | |
| # --- Step 2: Dossier auto-load ----------------------------------- | |
| if ss.get("evidence_index"): | |
| # Evidence index already loaded in this session → skip to screenshot. | |
| ss["current_step"] = "screenshot" | |
| return | |
| # Prefer the session-state path; fall back to the persisted .env path. | |
| path = (ss.get("dossier_folder_path") or "").strip() | |
| if not path: | |
| path = get_saved_dossier_path() | |
| if not path: | |
| # No path saved anywhere → go to Dossier so user can enter one. | |
| ss["current_step"] = "dossier" | |
| return | |
| # Always keep session_state in sync so the dossier screen shows it. | |
| ss["dossier_folder_path"] = path | |
| try: | |
| result = validate(path) | |
| if not result.can_continue: | |
| # Path exists but unusable → land on Dossier with a clear error. | |
| ss["dossier_validation"] = result | |
| ss["current_step"] = "dossier" | |
| return | |
| chunks = read_dossier(path) | |
| if not chunks: | |
| ss["current_step"] = "dossier" | |
| return | |
| proofs, profile, meta = build_evidence_index(chunks) | |
| ss["dossier_chunks"] = chunks | |
| ss["dossier_read"] = True | |
| ss["dossier_read_error"] = False | |
| # Re-scored from what the files hold, as the Dossier screen does: | |
| # validate() sees file names only, so a full dossier PDF scored thin. | |
| ss["dossier_validation"] = score_evidence(result, proofs) if proofs else result | |
| ss["evidence_index"] = proofs | |
| ss["canonical_profile"] = profile | |
| ss["evidence_index_meta"] = meta | |
| ss["current_step"] = "screenshot" | |
| except Exception: | |
| # Folder moved or deleted → land on Dossier, warn there. | |
| ss["dossier_read_error"] = True | |
| ss["current_step"] = "dossier" | |
| # Shown in place of a screen that raised. The details go to the server log. | |
| _SCREEN_ERROR_MESSAGE = ( | |
| "Something went wrong in the app on this step. Your work so far is kept: " | |
| "try again, or go back a step in the sidebar." | |
| ) | |
| def _report_screen_crash(step: str, exc: Exception) -> None: | |
| """Log a screen's uncaught exception and record it for diagnostics. | |
| Call it in the ``except``. The traceback goes to the server log, inside | |
| the message so the log's redaction filter scrubs it like any other line. | |
| The diagnostics event names the exception's class only — never its | |
| message, which can quote dossier or job text. | |
| """ | |
| error_type = type(exc).__name__ | |
| _logger.error( | |
| "screen=%s status=app_error error_type=%s\n%s", | |
| step, | |
| error_type, | |
| traceback.format_exc(), | |
| ) | |
| # Same record shape as llm_client's, so a report renders one table. | |
| diagnostics.record_event( | |
| { | |
| "timestamp": datetime.now(timezone.utc).isoformat(timespec="seconds"), | |
| "task_name": f"{step}_screen", | |
| "provider": None, | |
| "model": None, | |
| "used_api": False, | |
| "status": "app_error", | |
| "error_message": None, | |
| "duration_seconds": None, | |
| "estimated_input_tokens": None, | |
| "estimated_output_tokens": None, | |
| "request_id": None, | |
| "http_status": None, | |
| "error_type": error_type, | |
| } | |
| ) | |
| def main() -> None: | |
| st.set_page_config( | |
| page_title=APP_TITLE, | |
| page_icon="🧭", | |
| layout="wide", | |
| initial_sidebar_state="expanded", | |
| ) | |
| theme.inject_css() | |
| _init_session_state() | |
| settings = get_settings() | |
| show_debug = bool(getattr(settings, "show_debug_panel", False)) | |
| # Confirm Details is debug-only — keep normal users out of it even if a | |
| # stale navigation target points there. | |
| if not show_debug and st.session_state.current_step == "confirmation": | |
| st.session_state.current_step = ( | |
| "analysis" if st.session_state.get("fields_confirmed") else "screenshot" | |
| ) | |
| # ---- Smart landing: skip screens the user has already completed -------- | |
| # On a fresh Streamlit session (first page load or page refresh) we check | |
| # whether Setup and Dossier are already done and land the user directly on | |
| # Job Screenshot so they never have to re-enter their key or folder path. | |
| # We only do this once per session (guarded by the _smart_land_done flag), | |
| # and only when the session default "setup" is still the current step. | |
| # Restore a previously saved (encrypted) config for this browser BEFORE | |
| # smart-landing, so a returning visitor's key is in place and they get | |
| # auto-advanced past Setup without re-entering anything. | |
| _try_restore_saved_config() | |
| settings = get_settings() | |
| if not st.session_state.get("_smart_land_done"): | |
| st.session_state["_smart_land_done"] = True | |
| _try_smart_landing(settings) | |
| if not _is_unlocked(st.session_state.current_step): | |
| st.session_state.current_step = "setup" | |
| # Re-tint the whole screen to the current step's signature color. A | |
| # sub-screen borrows its parent's accent, breadcrumb and step number. | |
| dark = bool(st.session_state.get("theme_dark", True)) | |
| current_step = st.session_state.current_step | |
| crumb_step = _parent_step(current_step) | |
| theme.apply_step_accent(crumb_step, dark=dark) | |
| # The top bar from the design canvas: breadcrumb, a segmented rail that | |
| # lights the step you are on, "Step N of M", and the session status pill. | |
| visible = _visible_steps(show_debug) | |
| step_index = None | |
| for idx, (key, _label) in enumerate(visible, start=1): | |
| if key == crumb_step: | |
| step_index = idx | |
| break | |
| chip_label, chip_kind = _header_chip() | |
| theme.top_bar( | |
| crumb_a=APP_TITLE, | |
| crumb_b=dict(STEPS).get(crumb_step, crumb_step), | |
| step_index=step_index, | |
| step_total=len(visible), | |
| right_html=theme.tag(chip_label, _CHIP_TONE.get(chip_kind, "")), | |
| ) | |
| with st.sidebar: | |
| _render_sidebar(show_debug) | |
| # Dispatched through .get: an unknown step key (stale session state, or a | |
| # screen that navigated somewhere that no longer exists) would otherwise | |
| # raise a KeyError and blank the whole app. | |
| renderer = RENDERERS.get(st.session_state.current_step) | |
| if renderer is None: | |
| st.session_state.current_step = "setup" | |
| renderer = RENDERERS["setup"] | |
| # A screen that raises gets a plain message in its place instead of | |
| # Streamlit's traceback, which shows server paths and source lines to the | |
| # visitor. The rail and the session are untouched, so they can try again. | |
| # Exception only: st.rerun() and st.stop() raise BaseException subclasses, | |
| # which must keep passing through. | |
| step = st.session_state.current_step | |
| try: | |
| renderer() | |
| except Exception as exc: # noqa: BLE001 - last guard around a whole screen | |
| _report_screen_crash(step, exc) | |
| st.error(_SCREEN_ERROR_MESSAGE) | |
| # Motion drives the animation the CSS layer cannot express: panels that | |
| # arrive as they scroll into view, springs on hover and press, the fit ring | |
| # drawing to its score, and numbers counting up to the value just computed. | |
| # Started last so its first pass sees a fully rendered page; after that a | |
| # MutationObserver keeps up with Streamlit's reruns on its own. | |
| motion_runtime.inject() | |
| if __name__ == "__main__": | |
| main() | |