leaderboard: fetch results.jsonl via direct cache-busted HTTPS

hf_hub_download (even with force_download=True) hands back stale
bytes for several minutes after a commit: the local disk cache,
revision pinning, and the Hub's CDN-fronted resolve endpoint all
add their own staleness windows. End effect: pending and failed
rows landed by the submit worker were on the Hub but invisible
on the leaderboard tab until you waited it out, defeating the
whole point of Refresh.

Switch _load_rows_from_hub to a plain requests.get against the
dataset's resolve/main URL with Cache-Control: no-cache and a
millisecond cache-bust query param. Auth via huggingface_hub
get_token() so the same code reads the still-private submissions
dataset from the Space (HF_TOKEN secret) and from local dev
(~/.cache/huggingface/token) without forking the code path.

Adds requests to requirements.txt (was a transitive dep via
huggingface_hub; making it explicit so a future upstream change
doesn't silently drop it).

leaderboard.py

@@ -8,11 +8,16 @@ the env-var-driven repo identities that the submit path also consumes.
 from __future__ import annotations
 
 import json
+import logging
 import os
+import time
 from pathlib import Path
 
 import pandas as pd
-from huggingface_hub import hf_hub_download
+import requests
+from huggingface_hub import get_token
+
+logger = logging.getLogger(__name__)
 
 HF_ORG = os.getenv("HF_ORG", "michaelr27")
 HF_SUBMISSIONS_REPO = os.getenv(
@@ -21,6 +26,8 @@ HF_SUBMISSIONS_REPO = os.getenv(
 HF_DATA_REPO = os.getenv("HF_DATA_REPO", f"{HF_ORG}/cadgenbench-data")
 
 LOCAL_RESULTS_PATH = Path(__file__).parent / "results.jsonl"
+RESULTS_FILENAME = "results.jsonl"
+HUB_FETCH_TIMEOUT_SECONDS = 30
 
 LEADERBOARD_COLS = [
     "status",
@@ -37,24 +44,40 @@ FAILED_CELL_TAG = "✗ failed"
 
 
 def _load_rows_from_hub() -> list[dict] | None:
-    """Pull results.jsonl from the submissions dataset.
-
-    Returns None on any failure so callers can fall back to the local file.
+    """Pull results.jsonl from the submissions dataset via raw HTTPS.
+
+    Avoids :func:`huggingface_hub.hf_hub_download` because its layered
+    caching (local disk cache + revision pinning + the Hub's own
+    CDN-fronted resolve endpoint) can hand back stale bytes for a few
+    minutes even with ``force_download=True``, which makes pending
+    rows look like they never landed. A direct GET with a cache-bust
+    query param and ``Cache-Control: no-cache`` consistently sees the
+    latest commit on the dataset's ``main`` branch within seconds.
+
+    Returns None on any failure so callers can fall back to the local
+    mirror.
     """
+    url = (
+        f"https://huggingface.co/datasets/{HF_SUBMISSIONS_REPO}"
+        f"/resolve/main/{RESULTS_FILENAME}"
+    )
+    headers = {"Cache-Control": "no-cache"}
+    token = get_token()
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
     try:
-        path = hf_hub_download(
-            repo_id=HF_SUBMISSIONS_REPO,
-            filename="results.jsonl",
-            repo_type="dataset",
-            force_download=True,
+        r = requests.get(
+            url,
+            headers=headers,
+            params={"_cb": str(int(time.time() * 1000))},
+            timeout=HUB_FETCH_TIMEOUT_SECONDS,
         )
-        return [
-            json.loads(line)
-            for line in Path(path).read_text().splitlines()
-            if line.strip()
-        ]
+        r.raise_for_status()
+        rows = [json.loads(line) for line in r.text.splitlines() if line.strip()]
+        logger.info("Loaded %d rows from Hub", len(rows))
+        return rows
     except Exception as e:  # noqa: BLE001 - any failure should fall back
-        print(f"[load_leaderboard] Hub fetch failed ({type(e).__name__}: {e})")
+        logger.warning("Hub fetch failed (%s: %s)", type(e).__name__, e)
         return None
 
 

requirements.txt

@@ -2,3 +2,4 @@ gradio==6.14.0
 pandas>=2.0
 huggingface_hub>=0.27.0
 datasets>=3.0
+requests>=2.31