zoom scribe + versioning

app.py

@@ -22,10 +22,13 @@ from metrics_config import LIVE_SCENARIO_KEYS, SCENARIO_METRICS
 from recipes.registry import RECIPE_CHOICES
 
 from init import (
+    LATEST_VERSION,
     is_model_on_hub,
+    list_leaderboard_versions,
     load_raw_results,
     load_results,
     normalize_legacy_csv_row,
+    raw_rows_for_version,
 )
 from utils_display import (
     AutoEvalColumn,
@@ -51,6 +54,11 @@ ALWAYS_VISIBLE_COLS = (MODEL_COL, AVG_WER_COL)
 # Empty table at import; real data loaded on demo.load (avoids blocking Space "preparing").
 original_df = pd.DataFrame(columns=COLS)
 
+# Raw CSV rows backing the currently displayed leaderboard version. ``None`` means "live"
+# (filter_main_table falls back to load_raw_results()). Set whenever a version is selected
+# so the Avg-WER recompute in filter_main_table matches the displayed snapshot.
+_active_raw_rows: list[dict] | None = None
+
 _NEXT_UP_PLACEHOLDER = (
     "<div class='next-up-panel' style='font-size:0.9em;opacity:0.85'>"
     "<em>Loading upcoming evaluations…</em></div>"
@@ -81,7 +89,7 @@ def filter_main_table(search_query, selected_columns):
     columns_to_hide = set(all_toggleable) - set(selected_columns)
     filtered_df = filtered_df[[c for c in filtered_df.columns if c not in columns_to_hide]]
 
-    raw_rows = load_raw_results()
+    raw_rows = _active_raw_rows if _active_raw_rows is not None else load_raw_results()
     for r in raw_rows:
         normalize_legacy_csv_row(r)
     raw_by_mid = {r["model_id"]: r for r in raw_rows}
@@ -117,6 +125,28 @@ def filter_main_table(search_query, selected_columns):
     return filtered_df
 
 
+def _format_version_recorded_at(ts: str) -> str:
+    from datetime import datetime
+
+    try:
+        dt = datetime.fromisoformat(ts.replace("Z", "+00:00"))
+        return dt.strftime("%Y-%m-%d %H:%M UTC")
+    except Exception:
+        return str(ts)
+
+
+def _version_choices() -> list[tuple[str, str]]:
+    """(label, value) pairs for the version dropdown; first entry is always 'Latest'."""
+    choices: list[tuple[str, str]] = [("Latest", LATEST_VERSION)]
+    try:
+        for v in list_leaderboard_versions():
+            label = f"{_format_version_recorded_at(v['recorded_at'])} — {v['label']}"
+            choices.append((label, v["version"]))
+    except Exception:
+        pass
+    return choices
+
+
 # ---------------------------------------------------------------------------
 # Submission handler
 # ---------------------------------------------------------------------------
@@ -353,6 +383,13 @@ with gr.Blocks(title=APP_TITLE, theme=_theme, css=LEADERBOARD_CSS) as demo:
                     placeholder="Filter by model name -- separate multiple terms with commas, e.g. whisper, nvidia",
                     scale=4,
                 )
+                version_dropdown = gr.Dropdown(
+                    choices=_version_choices(),
+                    value=LATEST_VERSION,
+                    label="Version",
+                    scale=2,
+                    min_width=200,
+                )
                 leaderboard_update_btn = gr.Button(
                     "Update", variant="primary", scale=1, min_width=120
                 )
@@ -377,34 +414,61 @@ with gr.Blocks(title=APP_TITLE, theme=_theme, css=LEADERBOARD_CSS) as demo:
                 wrap=False,
             )
 
-            def _leaderboard_refresh(search, cols):
-                """Reload results CSV from storage, re-apply current search/column filters."""
-                global original_df
+            def _set_active_version(version):
+                """Load the chosen version into the module globals used by filter_main_table."""
+                global original_df, _active_raw_rows
+                if version:
+                    _active_raw_rows = raw_rows_for_version(version)
+                    original_df = load_results(version)
+                else:
+                    _active_raw_rows = None
+                    original_df = load_results()
+
+            def _leaderboard_refresh(search, cols, version):
+                """Reload results from storage for the selected version, refresh version list."""
                 from init import invalidate_results_cache
 
                 try:
                     invalidate_results_cache()
-                    original_df = load_results()
+                    choices = _version_choices()
+                    valid = {v for _, v in choices}
+                    if version not in valid:
+                        version = LATEST_VERSION
+                    _set_active_version(version)
+                    return (
+                        filter_main_table(search, cols),
+                        gr.update(choices=choices, value=version),
+                    )
+                except Exception:
+                    return original_df, gr.update()
+
+            def _on_version_change(version, search, cols):
+                """Swap the displayed leaderboard to the selected version, keep filters."""
+                try:
+                    _set_active_version(version)
                     return filter_main_table(search, cols)
                 except Exception:
                     return original_df
 
             def _on_startup():
                 """Load leaderboard + next-up list after UI is up (keeps Space prepare step fast)."""
-                global original_df
+                global original_df, _active_raw_rows
                 from init import invalidate_results_cache
 
+                version_update = gr.update()
                 try:
                     invalidate_results_cache()
+                    _active_raw_rows = None
                     original_df = load_results()
                     table = filter_main_table("", _default_visible_cols)
+                    version_update = gr.update(choices=_version_choices(), value=LATEST_VERSION)
                 except Exception as exc:
                     table = original_df
                     next_html = (
                         "<div class='next-up-panel'><p style='color:orange'>"
                         f"<strong>Startup warning:</strong> {exc}</p></div>"
                     )
-                    return table, next_html
+                    return table, next_html, version_update
                 try:
                     job_queue.ensure_worker_started()
                     next_html = job_queue.next_up_html()
@@ -413,15 +477,20 @@ with gr.Blocks(title=APP_TITLE, theme=_theme, css=LEADERBOARD_CSS) as demo:
                         "<div class='next-up-panel'><p style='color:orange'>"
                         f"<strong>Queue unavailable:</strong> {exc}</p></div>"
                     )
-                return table, next_html
+                return table, next_html, version_update
 
             filter_inputs = [search_box, column_checkboxes]
             search_box.change(filter_main_table, inputs=filter_inputs, outputs=leaderboard_table)
             column_checkboxes.change(filter_main_table, inputs=filter_inputs, outputs=leaderboard_table)
+            version_dropdown.change(
+                fn=_on_version_change,
+                inputs=[version_dropdown, search_box, column_checkboxes],
+                outputs=leaderboard_table,
+            )
             leaderboard_update_btn.click(
                 fn=_leaderboard_refresh,
-                inputs=filter_inputs,
-                outputs=leaderboard_table,
+                inputs=[search_box, column_checkboxes, version_dropdown],
+                outputs=[leaderboard_table, version_dropdown],
             )
 
         with gr.TabItem(tab_label("submit", "Submit"), elem_id="submit-tab", id=1):
@@ -1345,7 +1414,7 @@ with gr.Blocks(title=APP_TITLE, theme=_theme, css=LEADERBOARD_CSS) as demo:
         _next_up_timer.tick(fn=job_queue.next_up_html, outputs=[next_up_panel])
         _progress_timer.tick(fn=_mod_progress_gated, inputs=[mod_unlocked], outputs=[mod_progress])
 
-    demo.load(fn=_on_startup, outputs=[leaderboard_table, next_up_panel])
+    demo.load(fn=_on_startup, outputs=[leaderboard_table, next_up_panel, version_dropdown])
     demo.load(
         fn=_analytics_initial,
         outputs=[

init.py

@@ -14,6 +14,7 @@ import pandas as pd
 from storage import (
     HF_BUCKET_ID,
     HF_TOKEN,
+    HISTORY_PATH,
     RESULTS_PATH,
     STORAGE_BACKEND,
     upload_to_bucket,
@@ -40,9 +41,15 @@ __all__ = [
     "load_audio_file",
     "load_transcript_file",
     "normalize_legacy_csv_row",
+    "list_leaderboard_versions",
+    "raw_rows_for_version",
+    "LATEST_VERSION",
 ]
 
 csv_lock = threading.Lock()
+# Serializes read-modify-write of the append-only history file (separate from the
+# leaderboard CSV lock so history bookkeeping can never deadlock a result save).
+_history_lock = threading.Lock()
 
 LEADERBOARD_COLUMNS = [c.name for c in fields(AutoEvalColumn)]
 
@@ -59,6 +66,14 @@ CSV_FIELDS = [
     "submitted_at",
 ]
 
+# Sentinel for "show the live leaderboard" (no historical reconstruction).
+LATEST_VERSION = ""
+
+# History rows are leaderboard rows plus version bookkeeping. Stored append-only:
+# each leaderboard change appends only the model row(s) that changed, tagged with a
+# version id (timestamp) so any past state can be reconstructed without full copies.
+HISTORY_FIELDS = [*CSV_FIELDS, "version", "recorded_at", "version_label"]
+
 # Legacy CSV / evaluation wire-format keys -> canonical ``SCENARIO_KEYS`` column names.
 _LEGACY_WER_TO_CANONICAL: tuple[tuple[str, str], ...] = (
     ("wer_clean", "wer_anechoic_speech"),
@@ -281,10 +296,19 @@ def load_raw_results(*, refresh: bool = False) -> list[dict]:
             return []
 
 
-def save_raw_results(rows: list[dict]):
-    """Write the leaderboard CSV back to storage."""
+def save_raw_results(rows: list[dict], *, record_version: bool = True):
+    """Write the leaderboard CSV back to storage.
+
+    When ``record_version`` is set (default), the model row(s) that changed relative to
+    the previously persisted state are appended to the history file so the new state is
+    selectable from the leaderboard version dropdown.
+    """
     if not rows:
         return
+    # Snapshot the previously persisted state BEFORE acquiring csv_lock (load_raw_results
+    # also takes csv_lock, which is non-reentrant) so we can diff for versioning.
+    prev_rows = load_raw_results() if record_version else None
+
     with csv_lock:
         normalized = [{k: row.get(k, "") for k in CSV_FIELDS} for row in rows]
         output = io.StringIO()
@@ -301,17 +325,342 @@ def save_raw_results(rows: list[dict]):
             )
             invalidate_results_cache()
 
+    if record_version:
+        # Never let history bookkeeping break a successful result save.
+        try:
+            _record_history_from_diff(prev_rows or [], normalized)
+        except Exception:
+            pass
+
+
+# ---------------------------------------------------------------------------
+# Leaderboard version history (append-only, delta-based)
+# ---------------------------------------------------------------------------
+
+
+def _now_iso() -> str:
+    """UTC timestamp with microseconds so successive versions sort and stay unique."""
+    from datetime import datetime, timezone
+
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
+
+
+def load_history_rows() -> list[dict]:
+    """All rows of the append-only history file (chronological), or ``[]`` if absent."""
+    if STORAGE_BACKEND != "hf_bucket":
+        return []
+    try:
+        local_path = download_bucket_file(HISTORY_PATH)
+    except Exception:
+        return []
+    try:
+        with open(local_path, "r") as f:
+            rows = list(csv.DictReader(f))
+    except Exception:
+        rows = []
+    finally:
+        try:
+            os.unlink(local_path)
+        except Exception:
+            pass
+    return rows
+
+
+def _append_history_rows(new_rows: list[dict]) -> None:
+    """Append rows to the history file (read-modify-write of the whole file)."""
+    if STORAGE_BACKEND != "hf_bucket" or not new_rows:
+        return
+    with _history_lock:
+        all_rows = load_history_rows() + new_rows
+        output = io.StringIO()
+        writer = csv.DictWriter(output, fieldnames=HISTORY_FIELDS, extrasaction="ignore")
+        writer.writeheader()
+        for row in all_rows:
+            writer.writerow({k: row.get(k, "") for k in HISTORY_FIELDS})
+        upload_to_bucket(
+            HF_BUCKET_ID,
+            add=[(output.getvalue().encode("utf-8"), HISTORY_PATH)],
+            token=HF_TOKEN,
+        )
+
+
+def _history_label(changed: list[dict]) -> str:
+    if len(changed) == 1:
+        mid = (changed[0].get("model_id") or "").strip()
+        return mid or "leaderboard updated"
+    return f"{len(changed)} models updated"
+
+
+def _record_history_from_diff(prev_rows: list[dict], curr_rows: list[dict]) -> None:
+    """Append the model rows that changed between ``prev_rows`` and ``curr_rows``.
+
+    The first ever call seeds a full snapshot ("Initial release") so the earliest
+    selectable version reconstructs the complete board; later calls store only deltas.
+    """
+    now = _now_iso()
+    existing = load_history_rows()
+
+    if not existing:
+        seed = [
+            {**{k: r.get(k, "") for k in CSV_FIELDS},
+             "version": now, "recorded_at": now, "version_label": "Initial release"}
+            for r in curr_rows
+        ]
+        _append_history_rows(seed)
+        return
+
+    prev_by_mid = {(r.get("model_id") or "").strip(): {k: r.get(k, "") for k in CSV_FIELDS}
+                   for r in prev_rows}
+    changed: list[dict] = []
+    for r in curr_rows:
+        mid = (r.get("model_id") or "").strip()
+        if not mid:
+            continue
+        if prev_by_mid.get(mid) != {k: r.get(k, "") for k in CSV_FIELDS}:
+            changed.append(r)
+    if not changed:
+        return
+
+    label = _history_label(changed)
+    _append_history_rows([
+        {**{k: r.get(k, "") for k in CSV_FIELDS},
+         "version": now, "recorded_at": now, "version_label": label}
+        for r in changed
+    ])
+
+
+def list_leaderboard_versions() -> list[dict]:
+    """Distinct versions, newest first: ``[{version, label, recorded_at}, ...]``."""
+    rows = load_history_rows()
+    by_version: dict[str, dict] = {}
+    for r in rows:
+        v = (r.get("version") or "").strip()
+        if not v:
+            continue
+        by_version[v] = {
+            "version": v,
+            "label": (r.get("version_label") or v),
+            "recorded_at": (r.get("recorded_at") or v),
+        }
+    items = list(by_version.values())
+    items.sort(key=lambda d: d["recorded_at"], reverse=True)
+    return items
+
+
+def raw_rows_for_version(version: str) -> list[dict]:
+    """Reconstruct the leaderboard (CSV_FIELDS rows) as of ``version``.
+
+    Accumulates every history entry recorded at or before the chosen version and keeps
+    the most recent row per model. Falls back to the live results if history is missing.
+    """
+    if not version:
+        return load_raw_results()
+    rows = load_history_rows()
+    if not rows:
+        return load_raw_results()
+
+    target = None
+    for r in rows:
+        if (r.get("version") or "").strip() == version:
+            ra = r.get("recorded_at") or ""
+            if target is None or ra > target:
+                target = ra
+    if target is None:
+        return load_raw_results()
+
+    # File order is chronological, so the last entry per model wins.
+    by_mid: dict[str, dict] = {}
+    for r in rows:
+        if (r.get("recorded_at") or "") <= target:
+            mid = (r.get("model_id") or "").strip()
+            if mid:
+                by_mid[mid] = r
+
+    out: list[dict] = []
+    for r in by_mid.values():
+        row = {k: r.get(k, "") for k in CSV_FIELDS}
+        if not row.get("eval_family"):
+            row["eval_family"] = "N/A"
+        row.setdefault("submission_notes", "")
+        normalize_legacy_csv_row(row)
+        out.append(row)
+    return out
 
-def load_results() -> pd.DataFrame:
+
+# ---------------------------------------------------------------------------
+# Leaderboard version history (append-only, delta-based)
+# ---------------------------------------------------------------------------
+
+
+def _now_iso() -> str:
+    """UTC timestamp with microseconds so successive versions sort and stay unique."""
+    from datetime import datetime, timezone
+
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
+
+
+def load_history_rows() -> list[dict]:
+    """All rows of the append-only history file (chronological), or ``[]`` if absent."""
+    if STORAGE_BACKEND != "hf_bucket":
+        return []
+    try:
+        local_path = download_bucket_file(HISTORY_PATH)
+    except Exception:
+        return []
+    try:
+        with open(local_path, "r") as f:
+            rows = list(csv.DictReader(f))
+    except Exception:
+        rows = []
+    finally:
+        try:
+            os.unlink(local_path)
+        except Exception:
+            pass
+    return rows
+
+
+def _append_history_rows(new_rows: list[dict]) -> None:
+    """Append rows to the history file (read-modify-write of the whole file)."""
+    if STORAGE_BACKEND != "hf_bucket" or not new_rows:
+        return
+    with _history_lock:
+        all_rows = load_history_rows() + new_rows
+        output = io.StringIO()
+        writer = csv.DictWriter(output, fieldnames=HISTORY_FIELDS, extrasaction="ignore")
+        writer.writeheader()
+        for row in all_rows:
+            writer.writerow({k: row.get(k, "") for k in HISTORY_FIELDS})
+        upload_to_bucket(
+            HF_BUCKET_ID,
+            add=[(output.getvalue().encode("utf-8"), HISTORY_PATH)],
+            token=HF_TOKEN,
+        )
+
+
+def _history_label(changed: list[dict]) -> str:
+    if len(changed) == 1:
+        mid = (changed[0].get("model_id") or "").strip()
+        return mid or "leaderboard updated"
+    return f"{len(changed)} models updated"
+
+
+def _record_history_from_diff(prev_rows: list[dict], curr_rows: list[dict]) -> None:
+    """Append the model rows that changed between ``prev_rows`` and ``curr_rows``.
+
+    The first ever call seeds a full snapshot ("Initial release") so the earliest
+    selectable version reconstructs the complete board; later calls store only deltas.
+    """
+    now = _now_iso()
+    existing = load_history_rows()
+
+    if not existing:
+        seed = [
+            {**{k: r.get(k, "") for k in CSV_FIELDS},
+             "version": now, "recorded_at": now, "version_label": "Initial release"}
+            for r in curr_rows
+        ]
+        _append_history_rows(seed)
+        return
+
+    prev_by_mid = {(r.get("model_id") or "").strip(): {k: r.get(k, "") for k in CSV_FIELDS}
+                   for r in prev_rows}
+    changed: list[dict] = []
+    for r in curr_rows:
+        mid = (r.get("model_id") or "").strip()
+        if not mid:
+            continue
+        if prev_by_mid.get(mid) != {k: r.get(k, "") for k in CSV_FIELDS}:
+            changed.append(r)
+    if not changed:
+        return
+
+    label = _history_label(changed)
+    _append_history_rows([
+        {**{k: r.get(k, "") for k in CSV_FIELDS},
+         "version": now, "recorded_at": now, "version_label": label}
+        for r in changed
+    ])
+
+
+def list_leaderboard_versions() -> list[dict]:
+    """Distinct versions, newest first: ``[{version, label, recorded_at}, ...]``."""
+    rows = load_history_rows()
+    by_version: dict[str, dict] = {}
+    for r in rows:
+        v = (r.get("version") or "").strip()
+        if not v:
+            continue
+        by_version[v] = {
+            "version": v,
+            "label": (r.get("version_label") or v),
+            "recorded_at": (r.get("recorded_at") or v),
+        }
+    items = list(by_version.values())
+    items.sort(key=lambda d: d["recorded_at"], reverse=True)
+    return items
+
+
+def raw_rows_for_version(version: str) -> list[dict]:
+    """Reconstruct the leaderboard (CSV_FIELDS rows) as of ``version``.
+
+    Accumulates every history entry recorded at or before the chosen version and keeps
+    the most recent row per model. Falls back to the live results if history is missing.
+    """
+    if not version:
+        return load_raw_results()
+    rows = load_history_rows()
+    if not rows:
+        return load_raw_results()
+
+    target = None
+    for r in rows:
+        if (r.get("version") or "").strip() == version:
+            ra = r.get("recorded_at") or ""
+            if target is None or ra > target:
+                target = ra
+    if target is None:
+        return load_raw_results()
+
+    # File order is chronological, so the last entry per model wins.
+    by_mid: dict[str, dict] = {}
+    for r in rows:
+        if (r.get("recorded_at") or "") <= target:
+            mid = (r.get("model_id") or "").strip()
+            if mid:
+                by_mid[mid] = r
+
+    out: list[dict] = []
+    for r in by_mid.values():
+        row = {k: r.get(k, "") for k in CSV_FIELDS}
+        if not row.get("eval_family"):
+            row["eval_family"] = "N/A"
+        row.setdefault("submission_notes", "")
+        normalize_legacy_csv_row(row)
+        out.append(row)
+    return out
+
+
+def load_results(version: str | None = None) -> pd.DataFrame:
     """Load results from storage and return a display-ready DataFrame.
 
+    With ``version`` empty/``None`` the live leaderboard is returned. Otherwise the
+    leaderboard is reconstructed from the append-only history as of that version.
+
     The leaderboard intentionally does NOT show eval_family, wall time, or submitted_at.
     Those fields remain in the CSV (for moderators and analytics) but are omitted from the
     public table.
     """
-    import analytics
+    if version:
+        raw_rows = raw_rows_for_version(version)
+    else:
+        raw_rows = load_raw_results()
+    return _display_df_from_raw_rows(raw_rows)
 
-    raw_rows = load_raw_results()
+
+def _display_df_from_raw_rows(raw_rows: list[dict]) -> pd.DataFrame:
+    """Transform raw CSV rows into the public, sorted, display-formatted DataFrame."""
+    import analytics
 
     if not raw_rows:
         return pd.DataFrame(columns=LEADERBOARD_COLUMNS)

recipes/registry.py

@@ -29,6 +29,15 @@ RECIPES: dict[str, dict] = {
         },
         "evaluate_relative": "recipes/mega_asr/evaluate.py",
     },
+    "zoom_scribe": {
+        "title": "Zoom Scribe API (zoom/scribe_v1)",
+        "model_id_patterns": ("zoom/", "zoom-scribe", "zoom_scribe"),
+        # API model: no checkpoint download. Requires ZOOM_API_KEY as a Space secret.
+        "extra_deps": ["requests"],
+        "setup_commands": [],
+        "env": {},
+        "evaluate_relative": "recipes/zoom_scribe/evaluate.py",
+    },
 }
 
 RECIPE_CHOICES: list[tuple[str, str]] = [

recipes/zoom_scribe/evaluate.py

@@ -0,0 +1,84 @@
+"""
+Zoom Scribe API custom evaluator for FFASR.
+
+Calls the Zoom Scribe v1 transcription endpoint once per audio sample. Adapted from the
+open_asr_leaderboard provider (huggingface/open_asr_leaderboard#130). FFASR serves a
+private held-out set as local files (no public URLs), so audio is uploaded inline as a
+base64 ``data:`` payload; it is downmixed to mono FLAC to stay under Zoom's ~2MB
+local-upload limit.
+
+Requires ``ZOOM_API_KEY`` in the environment. For local (on-Space) evaluation, add it as
+a Space repository secret. ``requests`` is pulled in via the recipe's extra deps.
+"""
+
+from __future__ import annotations
+
+import base64
+import io
+import os
+import time
+from pathlib import Path
+
+import soundfile as sf
+
+ENDPOINT = "https://api.zoom.us/v2/aiservices/scribe/transcribe"
+MAX_UPLOAD_BYTES = 2_000_000  # Zoom Scribe ~2MB local-file limit
+_TIMEOUT_S = 300
+_RETRYABLE_STATUS = (429, 500, 502, 503, 504)
+
+
+def _encode_payload(file: Path) -> tuple[str, float]:
+    """Return ``(data-URI base64 payload, duration_s)``; mono FLAC keeps us under 2MB."""
+    audio, sr = sf.read(str(file), dtype="float32", always_2d=True)
+    audio = audio.mean(axis=1)  # downmix to mono
+    duration = len(audio) / float(sr)
+
+    buf = io.BytesIO()
+    sf.write(buf, audio, int(sr), format="FLAC")
+    raw = buf.getvalue()
+    if len(raw) > MAX_UPLOAD_BYTES:
+        raise RuntimeError(
+            f"{file.name}: {len(raw)} bytes exceeds Zoom's {MAX_UPLOAD_BYTES}-byte upload limit"
+        )
+    return f"data:audio/flac;base64,{base64.b64encode(raw).decode('ascii')}", duration
+
+
+def evaluate(file: Path) -> str:
+    import requests
+
+    api_key = (os.getenv("ZOOM_API_KEY") or "").strip()
+    if not api_key or api_key == "your_api_key":
+        raise ValueError(
+            "ZOOM_API_KEY environment variable not set (add it as a Space secret)."
+        )
+
+    file_payload, duration = _encode_payload(Path(file))
+    # Short clips transcribe in a single pass; longer ones need auto segmentation.
+    segmentation_mode = "none" if duration <= 29.9 else "auto"
+
+    body = {
+        "file": file_payload,
+        "config": {
+            "language": "en-US",
+            "segmentation_mode": segmentation_mode,
+            "experimental_feature": {"model_pro": True},
+            "timestamps": True,
+        },
+    }
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+    }
+
+    last_err: Exception | None = None
+    for attempt in range(4):
+        try:
+            resp = requests.post(ENDPOINT, headers=headers, json=body, timeout=_TIMEOUT_S)
+            if resp.status_code in _RETRYABLE_STATUS:
+                raise RuntimeError(f"Zoom API {resp.status_code}: {resp.text[:200]}")
+            resp.raise_for_status()
+            return resp.json().get("result", {}).get("text_display", "") or ""
+        except Exception as e:  # noqa: BLE001
+            last_err = e
+            time.sleep(2.0 * (2 ** attempt))
+    raise RuntimeError(f"Zoom Scribe request failed after retries: {last_err}")

storage.py

@@ -33,6 +33,9 @@ HF_BUCKET_ID = os.environ.get("FFASR_BUCKET_ID", "treble-technologies/FFASR_Lead
 DATASET_PREFIX = ""
 RESULTS_PATH = os.environ.get("FFASR_RESULTS_PATH", "results/leaderboard.csv")
 JOBS_STATE_PATH = os.environ.get("FFASR_JOBS_PATH", "results/jobs_state.csv")
+# Append-only leaderboard history (one row per changed model per version). Used to
+# reconstruct and display past leaderboard states from the version dropdown.
+HISTORY_PATH = os.environ.get("FFASR_HISTORY_PATH", "results/leaderboard_history.csv")
 
 HF_TOKEN = os.environ.get("HF_TOKEN") or os.environ.get("ds_token")