Fetch the picked model up front, with Classify dead until it lands

Clicking Classify used to mean "download the model, then maybe run inference",
with nothing on screen saying which was happening -- and the ms reading next to
the prediction quietly included the download, so the first number of a session
was a network measurement dressed as a latency.

Both action buttons now start disabled and load() runs up front: on page load,
on picking a model, and on picking a commit. Classify reads "Downloading the
model..." and is greyed while it runs, so a click is only ever inference, and
the timer starts after load so the ms means what it says.

The wiring keeps it to one warm per pick. model.change updates the revision
menu and then warms, so it reads the revision the switch just chose rather than
the old repo's commit -- a sha from the previous repo would 404. The revision
menu warms on .input rather than .change, because .change also fires on the
programmatic update model.change just made, and on the 30s refresh, either of
which would re-warm and flicker the buttons.

A revision that fails to load hands the buttons back and reports why, so a bad
pick cannot leave a dead interface.

Shift+Enter still submits during a load: you can paste a transcript while the
model downloads, and an early keypress waits on the same cached load rather
than starting a second one.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

README.md

@@ -77,6 +77,24 @@ the SetFit path, otherwise the model is loaded as an
 The **Evaluation** tab replays the test split and shows the confusion matrix,
 then the cases one by one, errors first.
 
+## Clicking Classify never downloads
+
+Both action buttons start disabled, and the picked revision is fetched up front:
+on page load, on picking a model, and on picking a commit. While that runs,
+Classify reads *Downloading the model…* and is greyed out. So a click is only
+ever inference, and the `ms` reading next to the prediction is measured after the
+load — it is inference alone, not a download that happened to be first.
+
+Warming is wired so it runs once per pick. `model.change` updates the revision
+menu and *then* warms, so it reads the revision the switch just chose rather than
+the previous repo's commit; the revision menu warms on `.input`, which is
+user-only, so the programmatic update that `model.change` just made does not warm
+a second time. A revision that fails to load hands the buttons back and reports
+why, instead of leaving a dead interface.
+
+⇧ Enter still submits while a model is loading — you can paste a transcript
+during the download, and an early keypress simply waits on the same load.
+
 ## Nothing is ever stale
 
 `main` is resolved to a commit on every call, and the caches are keyed on the

app/handlers.py

@@ -9,7 +9,7 @@ from . import evaluation
 from .config import display
 from .hub import model_repos, newest, revisions
 from .predictors import load
-from .text import LOADING, NO_MODEL, SCORING, pushed_at
+from .text import CLASSIFY, EVALUATE, LOADING, NO_MODEL, SCORING, WARM_FAILED, WARMING, pushed_at
 from .turns import window
 
 EXAMPLES = json.loads((Path(__file__).parent / "examples.json").read_text(encoding="utf-8"))
@@ -21,14 +21,34 @@ def classify(repo: str, revision: str, transcript: str) -> tuple[dict[str, float
     if not repo or not text:
         return {}, "", ""
 
-    started = time.perf_counter()
     predictor, sha = load(repo, revision)
+    started = time.perf_counter()  # after load, so the reading is inference alone
     labels, probabilities = predictor([text])
-    scores = {display(name): float(p) for name, p in zip(labels, probabilities[0])}
     elapsed = (time.perf_counter() - started) * 1000
+    scores = {display(name): float(p) for name, p in zip(labels, probabilities[0])}
     return scores, text, f"`{sha[:7]}` · `{elapsed:.0f} ms`"
 
 
+def _actions(classify_label: str, ready: bool) -> tuple[gr.Button, gr.Button]:
+    return gr.Button(classify_label, interactive=ready), gr.Button(EVALUATE, interactive=ready)
+
+
+def warm(repo: str, revision: str):
+    """Fetch the picked revision up front, so Classify only ever runs inference."""
+    if not repo:
+        yield _actions(CLASSIFY, ready=False)
+        return
+
+    yield _actions(WARMING, ready=False)
+    try:
+        load(repo, revision)
+    except Exception as failure:
+        # a bad revision must hand the buttons back, not dead-end the interface
+        yield _actions(CLASSIFY, ready=True)
+        raise gr.Error(f"{WARM_FAILED}: {failure}") from failure
+    yield _actions(CLASSIFY, ready=True)
+
+
 def summary(report: evaluation.Report) -> str:
     return (
         f"### {report.hits}/{report.total} — accuracy {report.hits / report.total:.1%}\n"

app/text.py

@@ -26,6 +26,11 @@ NO_MODEL = "No model selected."
 LOADING = "Loading the model"
 SCORING = "Classifying the test split"
 
+CLASSIFY = "Classify"
+EVALUATE = "Evaluate on the test split"
+WARMING = "Downloading the model…"
+WARM_FAILED = "Could not load that revision"
+
 
 def pushed_at(when: datetime | None) -> str:
     """Line under the pickers: when the selected repo was last touched."""

app/ui.py

@@ -3,9 +3,9 @@ from pathlib import Path
 import gradio as gr
 
 from .config import REFRESH_SECONDS, display
-from .handlers import EXAMPLES, classify, evaluate, pick_revision, refresh
+from .handlers import EXAMPLES, classify, evaluate, pick_revision, refresh, warm
 from .hub import model_repos, newest, revisions
-from .text import HEADER, PLACEHOLDER, TRANSCRIPT_INFO, pushed_at
+from .text import CLASSIFY, EVALUATE, HEADER, PLACEHOLDER, TRANSCRIPT_INFO, pushed_at
 
 CMD_ENTER_JS = (Path(__file__).parent / "cmd_enter.js").read_text(encoding="utf-8")
 
@@ -36,7 +36,9 @@ def classify_tab() -> tuple[gr.Textbox, gr.Button, list]:
                 lines=7,
                 max_lines=14,
             )
-            run = gr.Button("Classify", variant="primary", elem_id="run-classify")
+            run = gr.Button(
+                CLASSIFY, variant="primary", elem_id="run-classify", interactive=False
+            )
             gr.Examples(
                 examples=[[row["text"]] for row in EXAMPLES],
                 example_labels=[f"{display(row['gold'])} — {row['id']}" for row in EXAMPLES],
@@ -58,7 +60,7 @@ def classify_tab() -> tuple[gr.Textbox, gr.Button, list]:
 
 
 def evaluation_tab() -> tuple[gr.Button, list, gr.Dataframe]:
-    run = gr.Button("Evaluate on the test split", variant="primary")
+    run = gr.Button(EVALUATE, variant="primary", interactive=False)
     score = gr.Markdown()
     matrix = gr.Dataframe(
         label="Confusion matrix",
@@ -88,10 +90,19 @@ def build() -> gr.Blocks:
         with gr.Tab("Evaluation"):
             evaluate_button, report, progress_target = evaluation_tab()
 
+        # Buttons start dead and the model is fetched up front, so a click is
+        # never a download. .input() is user-only, so the revision update that
+        # picking a model triggers does not warm a second time.
+        actions = [run, evaluate_button]
+        demo.load(warm, selection, actions, show_progress="hidden")
+        revision.input(warm, selection, actions, show_progress="hidden")
+
         timer = gr.Timer(REFRESH_SECONDS)
         timer.tick(refresh, selection, [*selection, pushed], show_progress="hidden")
         refresh_button.click(refresh, selection, [*selection, pushed])
-        model.change(pick_revision, model, [revision, pushed])
+        model.change(pick_revision, model, [revision, pushed]).then(
+            warm, selection, actions, show_progress="hidden"
+        )
         gr.on(
             [run.click, transcript.submit],
             classify,