| """Recording-selective Hub access; metadata never triggers volume acquisition.""" |
|
|
| from __future__ import annotations |
|
|
| import json |
| from pathlib import Path |
|
|
|
|
| class MissingComponentError(LookupError): |
| """A requested component is unavailable, rather than an empty measurement.""" |
|
|
|
|
| class BenchmarkClient: |
| """Read a pinned release or local assembly with a per-file download budget. |
| |
| Tables retain native XYZ voxel coordinates. Physical XYZ fields are null if |
| calibration is unknown. Volumes return CZYX, without intensity normalization. |
| Local assemblies support the same API as remote commits. Remote callers must |
| explicitly select a revision; this prevents silent changes in experiments. |
| """ |
|
|
| def __init__( |
| self, |
| repo_id="pytc/trackingBench", |
| *, |
| revision=None, |
| root=None, |
| cache_dir=None, |
| max_download_bytes=128 * 1024**2, |
| ): |
| if root is None and revision is None: |
| raise ValueError("Pin a Hub commit/tag with revision, or supply root") |
| self.repo_id = repo_id |
| self.revision = revision |
| self.root = Path(root) if root is not None else None |
| self.cache_dir = cache_dir |
| self.max_download_bytes = max_download_bytes |
| self.manifest = json.loads(self._file("metadata/client_manifest.json").read_text()) |
|
|
| def _file(self, path): |
| logical = Path(path) |
| if logical.is_absolute() or ".." in logical.parts: |
| raise ValueError("Manifest paths must stay within the repository") |
| if self.root is not None: |
| return self.root / logical |
| from huggingface_hub import HfApi, hf_hub_download |
|
|
| info = next( |
| iter( |
| HfApi().get_paths_info( |
| self.repo_id, [path], repo_type="dataset", revision=self.revision |
| ) |
| ), |
| None, |
| ) |
| if info is None or getattr(info, "size", None) is None: |
| raise MissingComponentError(path) |
| if info.size > self.max_download_bytes: |
| raise ValueError(f"{path} exceeds the {self.max_download_bytes}-byte file budget") |
| return Path( |
| hf_hub_download( |
| self.repo_id, |
| path, |
| repo_type="dataset", |
| revision=self.revision, |
| cache_dir=self.cache_dir, |
| ) |
| ) |
|
|
| def list_recordings(self, **filters): |
| import pandas as pd |
|
|
| df = pd.read_parquet(self._file(self.manifest["recordings"])) |
| for key, value in filters.items(): |
| df = df.loc[df[key] == value] |
| return df.reset_index(drop=True) |
|
|
| def _component(self, recording_id, component): |
| import pandas as pd |
|
|
| entry = self.manifest["components"].get(recording_id) |
| if entry is None: |
| raise MissingComponentError(f"Unknown recording: {recording_id}") |
| path = entry.get(component) |
| if path is None: |
| raise MissingComponentError(f"{component} unavailable for {recording_id}") |
| return pd.read_parquet(self._file(path)) |
|
|
| def load_detections(self, recording_id): |
| return self._component(recording_id, "detections") |
|
|
| def load_tracks(self, recording_id, label_source=None): |
| df = self._component(recording_id, "tracks") |
| if label_source is not None: |
| df = df.loc[df.annotation_type == label_source].reset_index(drop=True) |
| return df |
|
|
| def load_reference_cloud(self, recording_id): |
| return self._component(recording_id, "anatomy") |
|
|
| def load_posture(self, recording_id): |
| return self._component(recording_id, "posture") |
|
|
| def load_corruptions(self, recording_id): |
| return self._component(recording_id, "perturbations") |
|
|
| def get_split(self, protocol, partition): |
| if protocol not in {"tracking_gt", "anatomical_verification", "anatomical_consistency"}: |
| raise ValueError(f"Unknown protocol: {protocol}") |
| if partition not in {"train", "validation", "test", "development", "quarantine"}: |
| raise ValueError(f"Unknown partition: {partition}") |
| return self.manifest["splits"][protocol].get(partition, []) |
|
|
| def load_volume(self, recording_id, frame, channels=None): |
| """Download only the small declared imaging pilot and return one CZYX frame. |
| |
| Frames outside the hosted pilot raise MissingComponentError with upstream |
| resolution details. Original multi-GB recordings are never auto-downloaded. |
| """ |
| import h5py |
| import numpy as np |
|
|
| entry = self.manifest["components"].get(recording_id, {}) |
| volume = entry.get("volume") |
| if volume is None or frame not in volume["frames"]: |
| raise MissingComponentError( |
| f"No hosted frame {frame} for {recording_id}; consult metadata/upstream_assets.json" |
| ) |
| with h5py.File(self._file(volume["path"]), "r") as h: |
| data = h[f"frames/{frame}"][()] |
| return data if channels is None else np.take(data, channels, axis=0) |
|
|
