feat: add Gradio smoke-test dashboard

- replace the default template with a Gradio Blocks app
- show live HF_TOKEN status (unset, invalid, or authenticated account and plan)
- add a model-count slider (default 30) and a primary Run button
- stream per-model progress while the runner works
- render a summary with passed count, failures, fallback recoveries, and duration
- render a results table with literal True/False per model, attempt used, latency, and error
- load previous runs from /data/hf-inference-smoke via a history dropdown
- offer the current run JSON as a download
- populate the latest run and token banner on page load
- move the theme into launch() for Gradio 6 compatibility
- document discovery, routing, pass criteria, budget, and storage in-app

app.py

@@ -1,7 +1,255 @@
+"""StockAnalysis - HF Inference Providers smoke-test dashboard.
+
+The app resolves the most-trending conversational models on the Hub that have
+at least one live inference provider, sends one tiny chat completion to each
+via the HF router (cheapest routing, one fastest fallback), and reports a
+literal True/False per model.
+
+Run artifacts are written to /data/hf-inference-smoke so they survive restarts.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
 import gradio as gr
 
-def greet(name):
-    return "Hello " + name + "!!"
+import smoke
+
+TABLE_HEADERS = ["Rank", "Model", "Passed", "Attempt", "Latency (ms)", "Error"]
+TABLE_TYPES = ["number", "str", "bool", "str", "number", "str"]
+
+HOW_IT_WORKS = """
+### How this works
+
+1. **Discovery** - queries the Hub for `conversational` models sorted by
+   `trendingScore`, scanning past the requested count so models without a live
+   inference provider are skipped.
+2. **Routing** - each model is called through the HF router with `:cheapest`.
+   If that attempt fails, it is retried once with `:fastest`.
+3. **Pass criteria** - a model is `True` only when the router returns HTTP 200
+   with a non-empty `choices` array.
+4. **Budget** - each attempt asks for at most 8 output tokens, so a 30-model run
+   costs well under a cent.
+5. **Storage** - every run is saved to `/data/hf-inference-smoke/runs/` and
+   mirrored to `latest.json`.
+
+Results are written to persistent storage, never to the Space repository.
+"""
+
+
+def _token_banner() -> str:
+    """Return a short markdown banner describing the HF token state."""
+    token = os.getenv("HF_TOKEN")
+    if not token:
+        return (
+            "**Token status:** `HF_TOKEN` is **not set**. "
+            "Add it as a Space secret or environment variable to run tests."
+        )
+
+    status = smoke.get_token_status(token)
+    if not status["ok"]:
+        return f"**Token status:** invalid - {status['error']}"
+
+    plan = status["plan"] or "unknown"
+    return f"**Token status:** authenticated as **{status['name']}** (plan: `{plan}`)"
+
+
+def _summary(run: dict[str, Any] | None) -> str:
+    if not run:
+        return "No runs yet. Press **Run smoke test** to create one."
+
+    total = run.get("model_limit") or len(run.get("results", []))
+    passed = run.get("passed", 0)
+    failed = run.get("failed", 0)
+    fallbacks = run.get("fallbacks", 0)
+    duration = run.get("duration_seconds", 0)
+    return (
+        f"### Run `{run.get('run_id')}`\n\n"
+        f"| Metric | Value |\n"
+        f"|---|---|\n"
+        f"| **Passed** | **{passed} / {total}** |\n"
+        f"| Failed | {failed} |\n"
+        f"| Recovered on `:fastest` | {fallbacks} |\n"
+        f"| Duration | {duration}s |\n"
+        f"| Started | {run.get('started_at')} |\n"
+        f"| Finished | {run.get('finished_at')} |\n"
+    )
+
+
+def _rows(run: dict[str, Any] | None) -> list[list[Any]]:
+    if not run:
+        return []
+    return [
+        [
+            item.get("rank"),
+            item.get("model"),
+            bool(item.get("ok")),
+            item.get("attempt"),
+            item.get("latency_ms"),
+            item.get("error") or "",
+        ]
+        for item in run.get("results", [])
+    ]
+
+
+def _run_options() -> list[tuple[str, str]]:
+    options: list[tuple[str, str]] = []
+    for meta in smoke.list_runs():
+        label = (
+            f"{meta.get('run_id')} - {meta.get('passed')}/"
+            f"{meta.get('model_limit')} passed"
+        )
+        options.append((label, meta.get("run_id")))
+    return options
+
+
+def _download_path(run: dict[str, Any] | None) -> str | None:
+    if not run:
+        return None
+    run_id = run.get("run_id")
+    if not run_id:
+        return None
+    path = smoke.RUNS_DIR / f"{run_id}.json"
+    return str(path) if path.exists() else None
+
+
+def _view(
+    run: dict[str, Any] | None,
+) -> tuple[str, list[list[Any]], str | None]:
+    return _summary(run), _rows(run), _download_path(run)
+
+
+def initial_view() -> tuple[str, list[list[Any]], str | None, Any, str]:
+    run = smoke.load_latest_run()
+    summary, rows, download = _view(run)
+    choices = _run_options()
+    selected = run.get("run_id") if run else None
+    return summary, rows, download, gr.update(choices=choices, value=selected), _token_banner()
+
+
+def run_smoke_test(
+    model_limit: int,
+    progress: gr.Progress = gr.Progress(),
+) -> tuple[str, list[list[Any]], str | None, Any, str]:
+    token = os.getenv("HF_TOKEN")
+    if not token:
+        raise gr.Error(
+            "HF_TOKEN is not set. Add it as a Space secret or environment variable, "
+            "then restart the Space."
+        )
+
+    status = smoke.get_token_status(token)
+    if not status["ok"]:
+        raise gr.Error(f"HF_TOKEN was rejected: {status['error']}")
+
+    progress(0.0, desc="Fetching trending models...")
+    try:
+        snapshot = smoke.fetch_trending_models(limit=int(model_limit))
+    except Exception as exc:  # noqa: BLE001 - surface discovery failures in the UI
+        raise gr.Error(f"Model discovery failed: {exc}") from exc
+
+    models = snapshot["models"]
+    total = len(models)
+
+    def on_result(done: int, count: int, result: dict[str, Any]) -> None:
+        state = "PASS" if result["ok"] else "FAIL"
+        progress(
+            done / count,
+            desc=f"{done}/{count} - {state} {result['model']} ({result['attempt']})",
+        )
+
+    progress(0.0, desc=f"Testing {total} models...")
+    try:
+        run = smoke.run_smoke(models, token=token, progress=on_result)
+    except Exception as exc:  # noqa: BLE001 - surface runner failures in the UI
+        raise gr.Error(f"Smoke test failed: {exc}") from exc
+
+    summary, rows, download = _view(run)
+    choices = _run_options()
+    banner = _token_banner()
+    return summary, rows, download, gr.update(choices=choices, value=run["run_id"]), banner
+
+
+def load_history(
+    run_id: str | None,
+    progress: gr.Progress = gr.Progress(),
+) -> tuple[str, list[list[Any]], str | None]:
+    if not run_id:
+        run = smoke.load_latest_run()
+    else:
+        try:
+            run = smoke.load_run(run_id)
+        except ValueError as exc:
+            raise gr.Error(str(exc)) from exc
+    if run is None:
+        raise gr.Error("That run could not be found in storage.")
+    return _view(run)
+
+
+with gr.Blocks(title="StockAnalysis - HF Inference Smoke Test") as demo:
+    gr.Markdown(
+        "# HF Inference Smoke Test\n"
+        "Smoke-tests the **30 most trending** chat models on Hugging Face through "
+        "Inference Providers. Each model returns a literal **True** or **False**."
+    )
+
+    token_banner = gr.Markdown(_token_banner())
+
+    with gr.Row():
+        model_limit = gr.Slider(
+            minimum=1,
+            maximum=50,
+            value=smoke.DEFAULT_MODEL_LIMIT,
+            step=1,
+            label="Models to test",
+            info="Trending order, keeping only models with a live provider.",
+        )
+        run_button = gr.Button("Run smoke test", variant="primary", scale=1)
+
+    progress_note = gr.Markdown("*Idle.*")
+    summary = gr.Markdown(_summary(None))
+    table = gr.Dataframe(
+        headers=TABLE_HEADERS,
+        datatype=TABLE_TYPES,
+        value=[],
+        interactive=False,
+        wrap=True,
+        label="Results (True = valid chat completion)",
+    )
+
+    with gr.Row():
+        history = gr.Dropdown(
+            choices=[],
+            value=None,
+            label="Run history",
+            info="Load a previous run from /data/hf-inference-smoke/runs.",
+            scale=4,
+        )
+        download = gr.File(label="Download run JSON", interactive=False, scale=1)
+
+    with gr.Accordion("How it works", open=False):
+        gr.Markdown(HOW_IT_WORKS)
+
+    run_button.click(
+        fn=run_smoke_test,
+        inputs=[model_limit],
+        outputs=[summary, table, download, history, token_banner],
+    ).then(lambda: "*Run finished.*", outputs=progress_note)
+
+    history.change(
+        fn=load_history,
+        inputs=[history],
+        outputs=[summary, table, download],
+    )
+
+    demo.load(
+        fn=initial_view,
+        outputs=[summary, table, download, history, token_banner],
+    )
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+if __name__ == "__main__":
+    demo.launch(theme=gr.themes.Soft())