Fall back to complete downloads for stalled shards

Read each source shard atomically. If HfFileSystem streaming exhausts retries with a read timeout, download the complete pinned blob and process it instead of failing the daily publisher. Apply the same path to session ingestion and dashboard query scans.

pipeline.py

@@ -12,7 +12,6 @@ from __future__ import annotations
 
 import argparse
 import json
-import os
 import re
 import sys
 import tempfile
@@ -21,10 +20,6 @@ from datetime import date, datetime, timedelta, timezone
 from pathlib import Path
 from typing import Any, Iterable
 
-# Large source scans occasionally stall longer than the Hub client's 10-second
-# default while reading an otherwise healthy shard.
-os.environ["HF_HUB_DOWNLOAD_TIMEOUT"] = "60"
-
 from huggingface_hub import CommitOperationAdd, HfApi, HfFileSystem, hf_hub_download
 from huggingface_hub.errors import EntryNotFoundError
 
@@ -306,19 +301,47 @@ def source_paths(fs: HfFileSystem, repo: str, revision: str, days: Iterable[date
     return found
 
 
-def read_events(fs: HfFileSystem, paths: Iterable[str], counters: dict[str, int]) -> Iterable[dict[str, Any]]:
-    for path in paths:
+def source_lines(
+    fs: HfFileSystem,
+    path: str,
+    repo: str,
+    revision: str,
+    download=hf_hub_download,
+) -> list[str]:
+    try:
         with fs.open(path, "rt") as stream:
-            for line in stream:
-                counters["source_rows"] += 1
-                try:
-                    event = json.loads(line)
-                except json.JSONDecodeError:
-                    counters["invalid_json"] += 1
-                    continue
-                if event.get("methodName") == "initialize":
-                    counters["initialize_rows"] += 1
-                yield event
+            text = stream.read()
+    except Exception as error:
+        if "timed out" not in str(error).casefold():
+            raise
+        prefix = f"datasets/{repo}@{revision}/"
+        if not path.startswith(prefix):
+            raise RuntimeError(f"cannot resolve timed-out source path: {path}") from error
+        filename = path.removeprefix(prefix)
+        print(f"stream timed out; downloading complete source shard: {filename}", file=sys.stderr)
+        cached = download(repo_id=repo, filename=filename, repo_type="dataset", revision=revision)
+        text = Path(cached).read_text()
+    return text.splitlines()
+
+
+def read_events(
+    fs: HfFileSystem,
+    paths: Iterable[str],
+    counters: dict[str, int],
+    repo: str,
+    revision: str,
+) -> Iterable[dict[str, Any]]:
+    for path in paths:
+        for line in source_lines(fs, path, repo, revision):
+            counters["source_rows"] += 1
+            try:
+                event = json.loads(line)
+            except json.JSONDecodeError:
+                counters["invalid_json"] += 1
+                continue
+            if event.get("methodName") == "initialize":
+                counters["initialize_rows"] += 1
+            yield event
 
 
 def client_group(name: str) -> str | None:
@@ -443,47 +466,46 @@ def dashboard_report(
     paths = report_paths(fs, repo, revision, start, through)
 
     for path in paths:
-        with fs.open(path, "rt") as stream:
-            for line in stream:
-                try:
-                    row = json.loads(line)
-                    seen = parse_time(row["time"])
-                except (json.JSONDecodeError, KeyError, TypeError, ValueError):
-                    health["invalid_query_rows"] += 1
-                    continue
-                if not start <= seen.date() <= through or row.get("methodName") in {"initialize", "session_delete"}:
-                    continue
-                name = row.get("name")
-                if not isinstance(name, str) or not name:
-                    health["missing_client_name_tool_calls"] += 1
-                    continue
-                if "mcp-remote" in name.casefold():
-                    health["excluded_mcp_remote_tool_calls"] += 1
-                    continue
-                protocol = row.get("protocolVersion")
-                if not isinstance(protocol, str) or not protocol:
-                    health["missing_protocol_version_tool_calls"] += 1
-                    continue
-                if protocol not in VALID_PROTOCOLS:
-                    health["invalid_protocol_version_tool_calls"] += 1
-                    continue
-
-                stamp = seen.date().isoformat()
-                health["valid_tool_calls"] += 1
-                group = client_group(name)
-                if group:
-                    named_daily[group][stamp][protocol] += 1
-                    group_names[group].add(name)
-                    if protocol == MODERN_PROTOCOL:
-                        capability_counts[group]["observations"] += 1
-                        flags, valid = feature_flags(row.get("clientCapabilities"))
-                        health["modern_tool_calls_with_valid_capabilities" if valid else "modern_tool_calls_without_valid_capabilities"] += 1
-                        if valid and flags:
-                            for feature, present in flags.items():
-                                capability_counts[group][feature] += present
-                else:
-                    other_daily[name][stamp][protocol] += 1
-                    other_totals[name] += 1
+        for line in source_lines(fs, path, repo, revision):
+            try:
+                row = json.loads(line)
+                seen = parse_time(row["time"])
+            except (json.JSONDecodeError, KeyError, TypeError, ValueError):
+                health["invalid_query_rows"] += 1
+                continue
+            if not start <= seen.date() <= through or row.get("methodName") in {"initialize", "session_delete"}:
+                continue
+            name = row.get("name")
+            if not isinstance(name, str) or not name:
+                health["missing_client_name_tool_calls"] += 1
+                continue
+            if "mcp-remote" in name.casefold():
+                health["excluded_mcp_remote_tool_calls"] += 1
+                continue
+            protocol = row.get("protocolVersion")
+            if not isinstance(protocol, str) or not protocol:
+                health["missing_protocol_version_tool_calls"] += 1
+                continue
+            if protocol not in VALID_PROTOCOLS:
+                health["invalid_protocol_version_tool_calls"] += 1
+                continue
+
+            stamp = seen.date().isoformat()
+            health["valid_tool_calls"] += 1
+            group = client_group(name)
+            if group:
+                named_daily[group][stamp][protocol] += 1
+                group_names[group].add(name)
+                if protocol == MODERN_PROTOCOL:
+                    capability_counts[group]["observations"] += 1
+                    flags, valid = feature_flags(row.get("clientCapabilities"))
+                    health["modern_tool_calls_with_valid_capabilities" if valid else "modern_tool_calls_without_valid_capabilities"] += 1
+                    if valid and flags:
+                        for feature, present in flags.items():
+                            capability_counts[group][feature] += present
+            else:
+                other_daily[name][stamp][protocol] += 1
+                other_totals[name] += 1
 
     dates = [day.isoformat() for day in daterange(start, through)]
     coverage = {}
@@ -598,7 +620,13 @@ def run(args: argparse.Namespace) -> int:
     fs = HfFileSystem()
     partitions = source_paths(fs, args.source_repo, source.sha, daterange(start, through))
     counters: dict[str, int] = defaultdict(int)
-    events = read_events(fs, (path for paths in partitions.values() for path in paths), counters)
+    events = read_events(
+        fs,
+        (path for paths in partitions.values() for path in paths),
+        counters,
+        args.source_repo,
+        source.sha,
+    )
     state, updates = merge(rows, events)
     raw, dedup = sorted_raw(state), deduplicate(state.values())
     report = dashboard_report(

test_pipeline.py

@@ -23,10 +23,40 @@ class SourceSimulator:
 
 
 class PipelineTest(unittest.TestCase):
-    def test_hub_download_timeout_allows_slow_shards(self):
-        from huggingface_hub.constants import HF_HUB_DOWNLOAD_TIMEOUT
+    def test_source_lines_downloads_complete_shard_after_stream_timeout(self):
+        class TimedOutSource:
+            def open(self, path, mode):
+                raise TimeoutError("The read operation timed out")
 
-        self.assertEqual(HF_HUB_DOWNLOAD_TIMEOUT, 60)
+        with tempfile.TemporaryDirectory() as directory:
+            fallback = Path(directory) / "shard.jsonl"
+            fallback.write_text('{"methodName":"initialize"}\n{"methodName":"session_delete"}\n')
+            calls = []
+
+            def download(**kwargs):
+                calls.append(kwargs)
+                return fallback
+
+            lines = pipeline.source_lines(
+                TimedOutSource(),
+                "datasets/source/repo@revision/sessions/2026-08-29/shard.jsonl",
+                "source/repo",
+                "revision",
+                download,
+            )
+
+        self.assertEqual(lines, ['{"methodName":"initialize"}', '{"methodName":"session_delete"}'])
+        self.assertEqual(
+            calls,
+            [
+                {
+                    "repo_id": "source/repo",
+                    "filename": "sessions/2026-08-29/shard.jsonl",
+                    "repo_type": "dataset",
+                    "revision": "revision",
+                }
+            ],
+        )
 
     def test_merge_retains_seed_and_latest_event(self):
         seed = [{"name": "Cursor", "version": "1", "capabilities": "{}", "last_seen": "2026-07-22T00:00:00Z"}]