"""Read the HandDiffuse relative-path episode layout without modifying data. NumPy is needed only for load_motion(). No MANO models, renderer, video decoder, or machine-specific paths are required. See README.md for the draft's limits. """ from __future__ import annotations import csv import json from dataclasses import dataclass from fractions import Fraction from pathlib import Path, PurePosixPath from typing import Callable, Iterator @dataclass(frozen=True) class Frame: motion_index: int video_index: int | None video_pts: int | None video_time_base: Fraction | None video_timestamp_seconds: str | None quality_flags: tuple[str, ...] = () alignment_certainty: str = 'SUPPORTED_BY_RECORDED_EVIDENCE' alternative_video_index: int | None = None alternative_video_pts: int | None = None alternative_video_timestamp_seconds: str | None = None @property def has_approximate_timing(self) -> bool: return self.alignment_certainty == 'APPROXIMATE_ADJACENT_FRAME_SELECTION' @property def available(self) -> bool: return self.video_index is not None @property def passes_recorded_screens(self) -> bool: """Availability and recorded screens only; not an accuracy guarantee.""" return self.available and not self.quality_flags def _relative(value: str) -> PurePosixPath: path = PurePosixPath(value) if not value or path.is_absolute() or '..' in path.parts or '\\' in value: raise ValueError(f'Expected a confined relative package path: {value!r}') return path class Episode: """One selected pair of hands and explicitly listed camera views. root is the package root containing episodes/. An optional resolver maps package-relative paths to existing read-only files for curation without staging media. Published datasets use the default relative-path resolver. """ def __init__(self, root: str | Path, episode_id: str, resolver: Callable[[str], Path] | None = None): if len(_relative(episode_id).parts) != 1 or episode_id in ('.', ''): raise ValueError('episode_id must be one directory name') self.root = Path(root).resolve() self.prefix = PurePosixPath('episodes') / episode_id self._resolver = resolver self.metadata = self._json(self.path('metadata.json')) if self.metadata['episode_id'] != episode_id: raise ValueError('Episode ID differs from metadata') self.frames = int(self.metadata['motion']['frames']) if self.frames < 0: raise ValueError('Negative motion length') self.cameras = {} for camera in self.metadata['cameras']: uid = camera['camera_uid'] if uid in self.cameras: raise ValueError(f'Duplicate camera UID: {uid}') self.cameras[uid] = camera self.motion_files = {} for item in self.metadata['motion']['files']: side = item['side'] if side in self.motion_files or side not in ('left', 'right'): raise ValueError('Expected one selected file per hand') self.motion_files[side] = item if set(self.motion_files) != {'left', 'right'}: raise ValueError('Episode requires both selected hand files') self._calibrations: dict[str, dict] = {} self._flags: dict[int, set[str]] | None = None @staticmethod def _json(path: Path): with path.open(encoding='utf-8') as handle: return json.load(handle) def path(self, episode_relative: str) -> Path: target = (self.prefix / _relative(episode_relative)).as_posix() if self._resolver is not None: return Path(self._resolver(target)) result = (self.root / target).resolve() if not result.is_relative_to(self.root): raise ValueError('Resolved path escapes the package root') return result def load_motion(self, side: str): """Memory-map numeric source values read-only; never invent betas.""" import numpy as np item = self.motion_files[side] array = np.load(self.path(item['file']), mmap_mode='r', allow_pickle=False) expected = (self.frames, int(item['parameter_columns'])) if expected[1] not in (51, 61) or tuple(array.shape) != expected: raise ValueError(f'Unexpected {side} motion shape: {array.shape}') if tuple(item['shape']) != expected or str(array.dtype) != item['dtype']: raise ValueError(f'{side} shape/dtype differs from metadata') if bool(item['betas_present']) != (expected[1] == 61): raise ValueError(f'{side} beta declaration differs from shape') return array def calibration(self, camera_uid: str) -> dict: """Return the original parameter entry, without changing order or values.""" camera = self.cameras[camera_uid] filename = camera['calibration_file'] if filename not in self._calibrations: self._calibrations[filename] = self._json(self.path(filename)) data = self._calibrations[filename] if data['episode_id'] != self.metadata['episode_id']: raise ValueError('Calibration belongs to a different episode') return data['namespaces'][camera['parameter_namespace']]['parameters'][str(camera['original_parameter_id'])] def _indices(self, values) -> set[int]: result = set() for index in values: if isinstance(index, bool) or not isinstance(index, int) or not 0 <= index < self.frames: raise ValueError(f'Invalid motion quality index: {index!r}') result.add(index) return result def _quality(self) -> dict[int, set[str]]: if self._flags is not None: return self._flags flags: dict[int, set[str]] = {} boundary = self.metadata.get('boundary_quality_mask_file') if boundary: count = 0 with self.path(boundary).open(newline='', encoding='utf-8') as handle: for count, row in enumerate(csv.DictReader(handle), start=1): index = int(row['motion_frame_index']) if index != count - 1 or index >= self.frames: raise ValueError('Boundary mask must cover consecutive motion rows') if row['boundary_usable'] not in ('0', '1'): raise ValueError('Invalid boundary availability flag') if row['boundary_usable'] == '0': flags.setdefault(index, set()).add('boundary_screen') if count != self.frames: raise ValueError('Incomplete boundary mask') local = self._indices(self.metadata.get('locally_excluded_motion_indices', [])) events_path = self.metadata.get('local_motion_quality_events_file') if events_path: events = self._json(self.path(events_path)) if events['episode_id'] != self.metadata['episode_id'] or events['motion_frames'] != self.frames: raise ValueError('Local events belong to a different motion') if self._indices(events['strict_pair_excluded_motion_indices']) != local: raise ValueError('Local event indices differ from metadata') for side, item in self.motion_files.items(): if events['motion_file_sha256_by_side'][side] != item['sha256']: raise ValueError('Local events are bound to a different selected motion') elif local: raise ValueError('Local mask declared without event annotations') for index in local: flags.setdefault(index, set()).add('local_motion_screen') self._flags = flags return flags def quality_flags(self, motion_index: int) -> tuple[str, ...]: self._indices([motion_index]) return tuple(sorted(self._quality().get(motion_index, ()))) def iter_frame_map(self, camera_uid: str) -> Iterator[Frame]: """Yield every motion row, including explicit missing video frames. Consume the iterator to exhaustion to validate its complete row count. PTS/time_base remain exact; no fixed FPS or nearest-frame inference. """ camera = self.cameras[camera_uid] certainty = camera.get('alignment_certainty', 'SUPPORTED_BY_RECORDED_EVIDENCE') approximate = certainty == 'APPROXIMATE_ADJACENT_FRAME_SELECTION' if approximate: if camera.get('exact_extraction_index_recovered') is not False: raise ValueError('Approximate timing cannot declare exact extraction recovery') if abs(camera['selected_fixed_offset'] - camera['alternative_fixed_offset']) != 1: raise ValueError('Expected adjacent alternative offsets') flags = self._quality() missing = [] count = 0 with self.path(camera['frame_map_file']).open(newline='', encoding='utf-8') as handle: for count, row in enumerate(csv.DictReader(handle), start=1): index = int(row['motion_frame_index']) if index != count - 1 or index >= self.frames: raise ValueError('Frame map must cover consecutive motion rows') video = row['video_frame_index'].strip() available = bool(video) explicit = row.get('source_frame_available') if explicit is not None and explicit not in ('0', '1'): raise ValueError('Invalid source_frame_available flag') if explicit is not None and (explicit == '1') != available: raise ValueError('Availability flag contradicts source index') raw_pts = row['video_pts'].strip() raw_base = row['video_time_base'].strip() raw_seconds = row['video_timestamp_seconds'].strip() if not available: if raw_pts or raw_base or raw_seconds: raise ValueError('Missing video row contains a timestamp') missing.append(index) video_index = pts = base = seconds = None else: if not raw_pts or not raw_base or not raw_seconds: raise ValueError('Available video row has incomplete timing') video_index, pts = int(video), int(raw_pts) base, seconds = Fraction(raw_base), raw_seconds if video_index < 0 or base <= 0: raise ValueError('Invalid video index/time base') alternate_index = alternate_pts = alternate_seconds = None row_certainty = row.get('alignment_certainty', certainty) if row_certainty != certainty: raise ValueError('Frame timing certainty differs from camera metadata') if approximate: alternate = row.get('alternative_video_frame_index', '').strip() alternate_tick = row.get('alternative_video_pts', '').strip() alternate_seconds = row.get('alternative_video_timestamp_seconds', '').strip() if not available or not alternate or not alternate_tick or not alternate_seconds: raise ValueError('Approximate frame map requires both candidate timestamps') alternate_index, alternate_pts = int(alternate), int(alternate_tick) if (video_index != index + camera['selected_fixed_offset'] or alternate_index != index + camera['alternative_fixed_offset'] or alternate_index < 0): raise ValueError('Approximate candidate indices differ from recorded offsets') yield Frame(index, video_index, pts, base, seconds, tuple(sorted(flags.get(index, ()))), certainty, alternate_index, alternate_pts, alternate_seconds) if count != self.frames: raise ValueError('Incomplete frame map') if missing != camera.get('unobserved_motion_indices', []): raise ValueError('Missing source rows differ from camera metadata') if self.frames - len(missing) != camera['source_video_observed_motion_frames']: raise ValueError('Observed row count differs from metadata')