Upload app.py with huggingface_hub

app.py

@@ -19,8 +19,7 @@ os.environ.setdefault("HF_XET_HIGH_PERFORMANCE", "1")
 
 N_CPUS = os.cpu_count() or 2
 BATCH_SIZE = 64  # max clips per ONNX forward pass
-API_TIMEOUT = 15   # seconds per datasets-server attempt
-API_RETRIES = 2
+API_TIMEOUT = 12   # seconds per datasets-server attempt (one try per endpoint)
 STREAMING_TIMEOUT = 45  # seconds before giving up on streaming fallback
 
 
@@ -84,41 +83,51 @@ def _parse_audio_urls(rows: list) -> list[str]:
     return urls
 
 
+def _try_endpoint(endpoint: str, params: dict, headers: dict) -> tuple[list[str], str]:
+    """Single request attempt. Returns (urls, status_str)."""
+    try:
+        t0 = time.time()
+        resp = requests.get(f"{DATASETS_SERVER}{endpoint}", params=params,
+                            headers=headers, timeout=API_TIMEOUT)
+        elapsed = int((time.time() - t0) * 1000)
+        if not resp.ok:
+            return [], f"{endpoint} HTTP {resp.status_code} ({elapsed}ms)"
+        rows = resp.json().get("rows", [])
+        if not rows:
+            return [], f"{endpoint} empty ({elapsed}ms)"
+        urls = _parse_audio_urls(rows)
+        if urls:
+            return urls, f"{endpoint} {elapsed}ms"
+        return [], f"{endpoint} no src ({elapsed}ms)"
+    except requests.Timeout:
+        return [], f"{endpoint} timeout>{API_TIMEOUT}s"
+    except Exception as exc:
+        return [], f"{endpoint} {exc}"
+
+
 def _fetch_audio_urls(repo_id: str, n: int, token: str | None) -> tuple[list[str], str]:
-    """Try /rows then /first-rows endpoints with retry. Returns (urls, status)."""
+    """Fire /rows and /first-rows in parallel, return first successful result.
+    Uses shutdown(wait=False) so the losing request doesn't block the caller."""
     headers = {"Authorization": f"Bearer {token}"} if token else {}
-    endpoints = [
+    calls = [
         ("/rows",       {"dataset": repo_id, "config": "default", "split": "train", "offset": 0, "length": n}),
         ("/first-rows", {"dataset": repo_id, "config": "default", "split": "train"}),
     ]
-    last_err = ""
-    for endpoint, params in endpoints:
-        for attempt in range(1, API_RETRIES + 1):
-            try:
-                t0 = time.time()
-                resp = requests.get(
-                    f"{DATASETS_SERVER}{endpoint}", params=params,
-                    headers=headers, timeout=API_TIMEOUT,
-                )
-                elapsed = int((time.time() - t0) * 1000)
-                if not resp.ok:
-                    last_err = f"{endpoint} HTTP {resp.status_code} (attempt {attempt}, {elapsed}ms)"
-                    break  # 4xx/5xx — no point retrying same endpoint
-                key = "rows" if endpoint == "/rows" else "rows"
-                rows = resp.json().get(key, [])
-                if not rows:
-                    last_err = f"{endpoint} empty ({elapsed}ms)"
-                    break
-                urls = _parse_audio_urls(rows[:n])
-                if urls:
-                    return urls, f"{endpoint} {elapsed}ms"
-                last_err = f"{endpoint} no src ({elapsed}ms)"
-                break
-            except requests.Timeout:
-                last_err = f"{endpoint} timeout>{API_TIMEOUT}s (attempt {attempt})"
-            except Exception as exc:
-                last_err = f"{endpoint} {exc} (attempt {attempt})"
-    return [], last_err
+    ex = concurrent.futures.ThreadPoolExecutor(max_workers=2)
+    futs = {ex.submit(_try_endpoint, ep, params, headers): ep for ep, params in calls}
+    errs = []
+    try:
+        for fut in concurrent.futures.as_completed(futs, timeout=API_TIMEOUT + 2):
+            urls, status = fut.result()
+            if urls:
+                ex.shutdown(wait=False, cancel_futures=True)
+                return urls[:n], status
+            errs.append(status)
+    except concurrent.futures.TimeoutError:
+        errs.append("both endpoints timed out")
+    finally:
+        ex.shutdown(wait=False, cancel_futures=True)
+    return [], " | ".join(errs)
 
 
 def _download_audio(url: str, token: str | None, max_sec: int) -> tuple[np.ndarray, int, int]: