eval script in about, fix for qwen,

app.py

@@ -1069,10 +1069,15 @@ with gr.Blocks(title=APP_TITLE, theme=_theme, css=LEADERBOARD_CSS) as demo:
                             if job["req_count"]
                             else "no extra reqs"
                         )
+                        email_bit = (
+                            f" · 📧 `{job['contact_email']}`"
+                            if job.get("contact_email")
+                            else " · 📧 *(none)*"
+                        )
                         with gr.Row(elem_classes=row_cls):
                             gr.Markdown(
                                 f"**`{jid}`** · `{job['model_id']}` · "
-                                f"`{job['family_id']}`{gated}{script_bit} · {extras} · "
+                                f"`{job['family_id']}`{gated}{script_bit} · {extras}{email_bit} · "
                                 f"{job['notes_preview'] or '—'} · {job['created_at']}",
                                 elem_classes="ffasr-job-info",
                             )

constants.py

@@ -181,6 +181,9 @@ quantify latency. The balance between performance and latency is of practical im
 may run as part of a real‑time interaction with users. A Pareto plot helps visualize this tradeoff (a single metric
 balancing Avg WER and RTFx, e.g. area under the curve, could also be considered).
 
+Scoring is performed by [`benchmark/dataset.py`](https://huggingface.co/spaces/treble-technologies/ffasr/blob/main/benchmark/dataset.py),
+which calls `evaluate_condition_wer_timed` for each inference to compute the per‑condition WER and timing used for RTFx.
+
 ### Word Error Rate (WER)
 
 WER is the fraction of reference words that are substituted, inserted, or deleted:

job_queue.py

@@ -1871,6 +1871,7 @@ def pending_jobs_for_render(limit: int = 60) -> list[dict[str, Any]]:
                 "model_id": j.model_id,
                 "family_id": j.family_id,
                 "created_at": (j.created_at or "")[:19],
+                "contact_email": (j.contact_email or "").strip(),
                 "is_gated": j.is_gated,
                 "req_count": len(parse_requirements_lines(j.extra_requirements or "")),
                 "notes_preview": (

storage.py

@@ -23,6 +23,8 @@ runtime default token).
 
 import io
 import os
+import shutil
+import subprocess
 import tempfile
 from contextlib import nullcontext
 from pathlib import Path
@@ -127,7 +129,14 @@ def upload_to_bucket(
     Upload/copy/delete bucket files with progress bars disabled and Xet reporter compatibility.
     """
     if batch_bucket_files is None:
-        raise RuntimeError("huggingface_hub bucket support is not available")
+        # In-process hub lacks the bucket API (e.g. qwen-asr stack pins hub<1.0).
+        # Fall back to an isolated uv env that has it.
+        if not _bucket_uv_available():
+            raise RuntimeError("huggingface_hub bucket support is not available")
+        _upload_to_bucket_via_uv(
+            bucket_id, add=add, copy=copy, delete=delete, token=token
+        )
+        return
     _ensure_xet_progress_reporter_compatible()
     try:
         from huggingface_hub.utils import disable_progress_bars
@@ -145,13 +154,176 @@ def upload_to_bucket(
         )
 
 
+# huggingface_hub version that ships the bucket API, used by the isolated-subprocess
+# fallback when the in-process hub is pinned <1.0 (e.g. the qwen-asr stack, whose
+# transformers==4.57.x pin forces huggingface-hub<1.0 and so lacks bucket support).
+_BUCKET_FALLBACK_HUB_SPEC = os.environ.get(
+    "FFASR_BUCKET_FALLBACK_HUB_SPEC", "huggingface-hub>=1.14.0"
+)
+
+_BUCKET_DOWNLOAD_SNIPPET = """\
+import os, sys
+from huggingface_hub import download_bucket_files
+
+bucket_id, remote_path, local_path = sys.argv[1], sys.argv[2], sys.argv[3]
+download_bucket_files(
+    bucket_id,
+    files=[(remote_path, local_path)],
+    token=os.environ.get("FFASR_BUCKET_DL_TOKEN") or None,
+)
+"""
+
+_BUCKET_UPLOAD_SNIPPET = """\
+import json, os, sys
+from huggingface_hub import batch_bucket_files
+
+try:
+    from huggingface_hub.utils import disable_progress_bars
+    disable_progress_bars()
+except Exception:
+    pass
+
+manifest_path, bucket_id = sys.argv[1], sys.argv[2]
+with open(manifest_path, encoding="utf-8") as f:
+    manifest = json.load(f)
+add = [(src, dst) for src, dst in manifest.get("add", [])] or None
+copy = [tuple(c) for c in manifest.get("copy", [])] or None
+delete = list(manifest.get("delete", [])) or None
+batch_bucket_files(
+    bucket_id,
+    add=add,
+    copy=copy,
+    delete=delete,
+    token=os.environ.get("FFASR_BUCKET_DL_TOKEN") or None,
+)
+"""
+
+
+def _bucket_uv_available() -> bool:
+    return shutil.which("uv") is not None
+
+
+def _run_bucket_uv_snippet(
+    snippet: str, args: list[str], *, token: str | None = None
+) -> subprocess.CompletedProcess:
+    """Run ``snippet`` in an isolated ``uv`` env that has the hub bucket API.
+
+    Used when this process' ``huggingface_hub`` is pinned <1.0 (no bucket support).
+    ``uv`` resolves an ephemeral, cached environment with a recent ``huggingface_hub``
+    (plus ``hf_xet`` for Xet-backed buckets), independent of the job's pinned stack.
+    The Hub token is passed via ``FFASR_BUCKET_DL_TOKEN`` (never on argv).
+    """
+    uv = shutil.which("uv") or "uv"
+    cmd = [
+        uv,
+        "run",
+        "--no-project",
+        "--python",
+        "3.12",
+        "--with",
+        _BUCKET_FALLBACK_HUB_SPEC,
+        "--with",
+        "hf_xet",
+        "python",
+        "-c",
+        snippet,
+        *args,
+    ]
+    env = dict(os.environ)
+    tok = token or HF_TOKEN
+    if tok:
+        env["FFASR_BUCKET_DL_TOKEN"] = tok
+    env.setdefault("HF_HUB_DISABLE_PROGRESS_BARS", "1")
+    try:
+        return subprocess.run(
+            cmd,
+            env=env,
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+    except FileNotFoundError as exc:
+        raise RuntimeError(
+            "huggingface_hub bucket support is not available in this environment and the "
+            "`uv` fallback could not be launched (uv not found on PATH)."
+        ) from exc
+
+
+def _download_bucket_file_via_uv(path: str, local_path: str) -> None:
+    proc = _run_bucket_uv_snippet(
+        _BUCKET_DOWNLOAD_SNIPPET, [HF_BUCKET_ID, path, local_path]
+    )
+    if proc.returncode != 0 or not os.path.exists(local_path):
+        tail = (proc.stderr or proc.stdout or "").strip()[-2000:]
+        raise RuntimeError(
+            "Bucket download via isolated uv environment failed "
+            f"(exit {proc.returncode}) for '{path}'.\n{tail}"
+        )
+
+
+def _upload_to_bucket_via_uv(
+    bucket_id: str,
+    *,
+    add: list[tuple[str | Path | bytes, str]] | None,
+    copy: list[tuple[str, str, str, str]] | None,
+    delete: list[str] | None,
+    token: str | bool | None = None,
+) -> None:
+    """Upload/copy/delete bucket files via the isolated ``uv`` env (hub <1.0 fallback).
+
+    ``bytes`` sources in ``add`` are materialized to temp files so the subprocess can
+    pass plain file paths to ``batch_bucket_files``.
+    """
+    tmpdir = tempfile.mkdtemp(prefix="ffasr_bucket_up_")
+    try:
+        add_items: list[tuple[str, str]] = []
+        for i, (src, dst) in enumerate(add or []):
+            if isinstance(src, (bytes, bytearray)):
+                src_path = os.path.join(tmpdir, f"add_{i}_{os.path.basename(dst) or 'blob'}")
+                with open(src_path, "wb") as fh:
+                    fh.write(src)
+            else:
+                src_path = os.fspath(src)
+            add_items.append((src_path, dst))
+        manifest = {
+            "add": add_items,
+            "copy": [list(c) for c in (copy or [])],
+            "delete": list(delete or []),
+        }
+        import json as _json
+
+        manifest_path = os.path.join(tmpdir, "manifest.json")
+        with open(manifest_path, "w", encoding="utf-8") as fh:
+            _json.dump(manifest, fh)
+        snippet_token = token if isinstance(token, str) else None
+        proc = _run_bucket_uv_snippet(
+            _BUCKET_UPLOAD_SNIPPET, [manifest_path, bucket_id], token=snippet_token
+        )
+        if proc.returncode != 0:
+            tail = (proc.stderr or proc.stdout or "").strip()[-2000:]
+            raise RuntimeError(
+                "Bucket upload via isolated uv environment failed "
+                f"(exit {proc.returncode}).\n{tail}"
+            )
+    finally:
+        shutil.rmtree(tmpdir, ignore_errors=True)
+
+
 def download_bucket_file(path: str) -> str:
-    """Download a single file from HF Bucket and return the local path."""
+    """Download a single file from HF Bucket and return the local path.
+
+    Uses the in-process bucket API when available; otherwise falls back to an isolated
+    ``uv`` environment that has a hub version with bucket support (the qwen-asr stack
+    pins huggingface-hub<1.0, which lacks the bucket API).
+    """
     local_dir = tempfile.mkdtemp()
     local_path = os.path.join(local_dir, os.path.basename(path))
-    download_bucket_files(
-        HF_BUCKET_ID,
-        files=[(path, local_path)],
-        token=HF_TOKEN,
-    )
+    if download_bucket_files is not None:
+        download_bucket_files(
+            HF_BUCKET_ID,
+            files=[(path, local_path)],
+            token=HF_TOKEN,
+        )
+    else:
+        _download_bucket_file_via_uv(path, local_path)
     return local_path