"""CONTRACT 6.5: read one complete shard through the v1.1 reader, every component. Acceptance item 5 asks for a check the byte-level ones cannot give. ``verify.py`` compares a view's bytes against its own v1.0 source, which proves repackaging preserved them, but it never decodes media and never crosses components -- a release whose bundles are each individually byte-perfect and whose RGB, camera and annotations no longer line up would pass it. ``validate.py`` does cross components, but per view and against the schema, not against the media. So this opens the finished release the way a consumer would, through ``Registry.resolve`` and ``BundleReader``, and checks the joins: frames the RGB's real frame count (ffprobe, demux only -- ``nb_frames`` is absent in Matroska) equals the metainfo ``num_frames``, the length of ``frames.jsonl`` and the ``T`` axis of every field the view declares. Depth, depth validity and the segment mask are counted the same way. camera the directory the view lives in, its ``camera_id``, its ``camera`` block and the intrinsic component's ``schema_id`` all name the same camera presence a component declaring ``available: false`` leaves no file behind, and every declared one opens; a media component's standalone bool validity is a real file of the declared length (CONTRACT 4) frames.jsonl one row per frame, indices contiguous, ``sample_id`` unique, the split directory in ``sample_id`` equal to the declared ``split``, and ``source_locator.annotation_index`` equal to ``source_frame_id`` -- the frame-level association the release claims visibility RHD's own join: ``xyz`` and ``uv`` are two components sharing one ``visibility`` leaf. Reading it through each component's declared attribute and finding the same bytes is what "written once and referenced twice" (RAW_MAPPING.md) has to mean in the finished tree. What it does not do: it never decodes pixels, compares an image to anything, or forms an opinion about whether a mask looks right. CONTRACT 6.5 keeps that -- human visual acceptance -- separate from this, and this tool is on the packaging side of that line. """ from __future__ import annotations import argparse import json import subprocess import sys from pathlib import Path import torch from rhd_common import RELEASE_ROOT, TMP_ROOT, load from warehouse import BundleReader, Registry def wildcard(segment: str) -> bool: return "<" in segment and ">" in segment def registered_entry(registry, bundle_rel: str, keys: list) -> bool: """Is ``bundle_rel`` + ``keys`` an entry the registry declares? ``Registry.resolve`` answers the migrator's question -- given a *v1.0* ref, where did those bytes go. A consumer asks the other direction: the v1.1 metainfo names a bundle and a key path, and that pair has to be a registered entry. Same templates, matched from the target side. """ ref = Path(bundle_rel).parts for bundle in registry.bundles.values(): template = Path(bundle["path"]).parts if len(ref) != len(template) or ref[-1] != template[-1]: continue if not all(wildcard(w) or w == g for w, g in zip(template[:-1], ref[:-1])): continue for name in bundle["entries"]: wanted = name.split("/") if len(wanted) == len(keys) and all( wildcard(w) or w == k for w, k in zip(wanted, keys) ): return True return False def packet_count(path: Path) -> int: """Frames in an encoded video, by demux -- not by decoding.""" out = subprocess.run( ["ffprobe", "-v", "error", "-select_streams", "v:0", "-count_packets", "-show_entries", "stream=nb_read_packets", "-of", "csv=p=0", str(path)], capture_output=True, text=True, check=True, ).stdout.strip() return int(out) def view_dirs(root: Path, sequence: str) -> list[Path]: sequence_dir = root / "data" / sequence if not sequence_dir.is_dir(): raise SystemExit(f"no such shard in the release: {sequence}") return sorted((p for p in sequence_dir.iterdir() if p.is_dir()), key=lambda p: (len(p.name), p.name)) def all_sequences(root: Path) -> list[str]: return sorted(p.name for p in (root / "data").iterdir() if p.is_dir()) def read_media(registry, reader, view: Path, name: str, component: dict, record: dict, problem) -> None: """A preserved file (mkv or jsonl) and its standalone validity, if declared. A bundled leaf holds its own validity; a media component may not, so CONTRACT 4 keeps that validity beside it -- a bool Tensor for RGB and the mask, a bool video for depth. Either way the length has to match the declared frames. """ ref = view / component["data_ref"] if not ref.is_file(): problem(f"{name}: preserved file {component['data_ref']} is missing") return frames = None if ref.suffix == ".mkv": frames = packet_count(ref) declared = component["axes"].index("T") record["media"].append({"component": name, "ref": component["data_ref"], "bytes": ref.stat().st_size, "frames": frames, "declared_T_axis": declared}) if frames != record["num_frames"]: problem(f"{name}: {frames} packets, metainfo declares " f"{record['num_frames']}") else: record["media"].append({"component": name, "ref": component["data_ref"], "bytes": ref.stat().st_size, "frames": None}) valid_ref = component.get("valid_ref") if not valid_ref: record["media"][-1]["valid"] = None return valid_path = view / valid_ref if not valid_path.is_file(): problem(f"{name}: declared validity {valid_ref} is missing") return if valid_ref.endswith(".pt"): #: CONTRACT 4: media validity stays a standalone bool Tensor. It is not #: registered as a bundle, so the reader cannot address it by key payload = load_tensor(valid_path) length = payload.shape[0] if payload.ndim else 0 record["media"][-1]["valid"] = {"ref": valid_ref, "kind": "pt", "dtype": str(payload.dtype), "shape": list(payload.shape)} if payload.dtype != torch.bool: problem(f"{name}: validity {valid_ref} is {payload.dtype}, not bool") if length != record["num_frames"]: problem(f"{name}: validity {valid_ref} holds {length} frames, " f"metainfo declares {record['num_frames']}") else: frames = packet_count(valid_path) record["media"][-1]["valid"] = {"ref": valid_ref, "kind": "media", "frames": frames} if frames != record["num_frames"]: problem(f"{name}: validity {valid_ref} holds {frames} frames, " f"metainfo declares {record['num_frames']}") def load_tensor(path: Path) -> torch.Tensor: """A standalone ``.pt`` outside the registry, read the way the release stores it.""" with path.open("rb") as stream: return torch.load(stream, map_location="cpu", weights_only=True) def read_view(registry, reader, view: Path) -> dict: """Open every component of one view; return what the reader found.""" meta = load(view / "metainfo.json") where = f"{view.parent.name}/{view.name}" record = {"view": where, "camera_id": meta.get("camera_id"), "view_type": meta.get("view_type"), "num_frames": meta.get("num_frames"), "fields": [], "media": [], "absent": [], "problems": []} problem = record["problems"].append #: the view's own directory name and its declared camera must agree; the whole #: release is laid out as //, so a mismatch would mean the #: calibration and the pixels come from different cameras if meta.get("camera_id") != view.name: problem(f"directory {view.name} but camera_id {meta.get('camera_id')!r}") for name, component in meta["components"].items(): ref = component.get("data_ref") if not component.get("available", True): #: an omitted component must not leave a file claiming otherwise if ref and (view / ref).exists(): problem(f"{name}: available=false but {ref} exists") record["absent"].append(name) continue if not ref: problem(f"{name}: available but declares no data_ref") continue #: a component carrying ``data_key`` is bundled numeric data; one with only #: ``data_ref`` is a preserved media/JSONL file (validate.py rebuilds on the #: same predicate). The registry entry is matched from the target side. if "data_key" not in component: read_media(registry, reader, view, name, component, record, problem) continue leaves = [(name, component["data_ref"], component["data_key"], component["valid_key"], list(component.get("axes") or []))] for attribute, spec in (component.get("attributes") or {}).items(): leaves.append((f"{name}.{attribute}", spec["data_ref"], spec["data_key"], spec["valid_key"], list(spec.get("axes") or []))) for owner, bundle, data_key, valid_key, axes in leaves: try: data = reader.get(view, bundle, data_key) valid = reader.get(view, bundle, valid_key) except (KeyError, TypeError, FileNotFoundError) as error: problem(f"{owner}: reader could not open {bundle}: {error}") continue if not isinstance(data, torch.Tensor) or valid.dtype != torch.bool: problem(f"{owner}: {bundle} does not hold (Tensor, bool Tensor)") continue frames = data.shape[axes.index("T")] if "T" in axes else None if frames is not None and frames != meta["num_frames"]: problem(f"{owner}: {frames} frames on its T axis, " f"metainfo declares {meta['num_frames']}") if valid.shape != tuple(data.shape[: valid.ndim]): problem(f"{owner}: valid {list(valid.shape)} is not a prefix of " f"data {list(data.shape)}") if not registered_entry(registry, bundle, data_key[:-1]): problem(f"{owner}: {bundle}:{'/'.join(data_key[:-1])} is not a " f"registered bundle entry") record["fields"].append({ "component": owner, "entry": f"{bundle}:{'/'.join(data_key)}", "dtype": str(data.dtype), "shape": list(data.shape), "T": frames, "valid_true": int(valid.sum()), "valid_false": int((~valid).sum()), }) return record def check_visibility(registry, reader, view: Path, meta: dict) -> list[str]: """RHD's own join: one ``visibility`` leaf, read through two components. v1.0 stored a single ``annotation/keypoints/visibility.pt`` referenced by both the xyz and the uv component; v1.1's registry fixes one entry for it, so the migration wrote the leaf once and both components point at it. A reader that finds different bytes through the two declarations would mean the migration silently kept one and dropped the other -- the failure mode RAW_MAPPING.md says it refuses to paper over. """ problems = [] specs = [(name, (component.get("attributes") or {}).get("visibility")) for name, component in meta["components"].items() if isinstance(component, dict)] specs = [(name, spec) for name, spec in specs if spec] if len(specs) < 2: problems.append(f"expected two components declaring a visibility attribute, " f"found {len(specs)}") return problems reference = None for name, spec in sorted(specs): try: data = reader.get(view, spec["data_ref"], spec["data_key"]) valid = reader.get(view, spec["data_ref"], spec["valid_key"]) except (KeyError, TypeError, FileNotFoundError) as error: problems.append(f"{name}.visibility: reader could not open " f"{spec['data_ref']}: {error}") continue if reference is None: reference = (name, data, valid) continue if data.shape != reference[1].shape or data.dtype != reference[1].dtype: problems.append(f"{name}.visibility and {reference[0]}.visibility differ " f"in shape/dtype") elif data.contiguous().numpy().tobytes() != reference[1].contiguous().numpy().tobytes(): problems.append(f"{name}.visibility and {reference[0]}.visibility " f"are different bytes") elif valid.contiguous().numpy().tobytes() != reference[2].contiguous().numpy().tobytes(): problems.append(f"{name}.visibility and {reference[0]}.visibility have " f"different validity bytes") return problems #: RHD ships two official directories, _published_v2/{training,evaluation}, #: and the release maps them onto the train/test splits (split_scheme #: "RHD_official_training_evaluation"). A shard whose own frames name one #: directory while its split label says the other would file one split's frames #: under the other's label, so the three places that state it are read together. SOURCE_DIRECTORY_SPLIT = {"training": "train", "evaluation": "test"} def check_frames(view: Path, meta: dict) -> list[str]: """``frames.jsonl`` is what makes a sample_type=image shard a sequence.""" problems = [] path = view / (meta["sampling"].get("frames_ref") or "camera/frames.jsonl") if not path.is_file(): return [f"frames table {path.name} is missing"] rows = [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line.strip()] if len(rows) != meta["num_frames"]: problems.append(f"frames.jsonl holds {len(rows)} rows, metainfo declares " f"{meta['num_frames']}") seen = set() for index, row in enumerate(rows): if row.get("frame_index") != index: problems.append(f"frames.jsonl row {index} has frame_index " f"{row.get('frame_index')!r}") break sample = row.get("sample_id") if sample in seen: problems.append(f"sample_id {sample!r} appears twice") break seen.add(sample) #: sample_id is "//"; both parts have to agree #: with what the metainfo declares about this shard parts = str(sample).split("/") if len(parts) == 3: if parts[0] != meta["dataset_id"]: problems.append(f"sample_id {sample!r} names dataset {parts[0]!r}") break if SOURCE_DIRECTORY_SPLIT.get(parts[1]) != meta.get("split"): problems.append(f"sample_id {sample!r} is filed under {parts[1]!r} " f"but the shard split is {meta.get('split')!r}") break locator = row.get("source_locator") or {} if locator.get("annotation_index") != int(row.get("source_frame_id")): problems.append(f"frame {index}: annotation_index " f"{locator.get('annotation_index')!r} != source_frame_id " f"{row.get('source_frame_id')!r}") break return problems def check_shard(meta: dict, frames_problems: list[str]) -> list[str]: """The shard-level claim: the split label, the locator and the frames agree.""" problems = list(frames_problems) prefix = (meta.get("split_source_locator") or {}).get("member_prefix") or "" if not prefix: problems.append("split_source_locator names no member_prefix") return problems directory = prefix.rstrip("/").split("/")[-1] if SOURCE_DIRECTORY_SPLIT.get(directory) != meta.get("split"): problems.append(f"split {meta.get('split')!r} does not match the source " f"directory {directory!r}") sequence = meta.get("sequence_id") or "" if sequence and not sequence.startswith(directory): #: shard ids carry their source directory, e.g. evaluation_00000512 problems.append(f"sequence_id {sequence!r} does not start with " f"{directory!r}") return problems def sweep(root: Path, registry, reader, sequence: str, quiet: bool) -> dict: records, metas, shard_problems = [], {}, [] for view in view_dirs(root, sequence): meta = load(view / "metainfo.json") record = read_view(registry, reader, view) #: the visibility join and the frame table are per-view checks, so their #: findings are recorded against the view that failed; split/sequence #: consistency is stated once for the shard record["problems"].extend(check_visibility(registry, reader, view, meta)) record["problems"].extend(check_frames(view, meta)) records.append(record) metas[view.name] = meta for name, meta in sorted(metas.items()): shard_problems.extend(check_shard(meta, [])) per_view_problems = [(r["view"], p) for r in records for p in r["problems"]] if not quiet: print(f"{sequence}: {len(records)} view(s)") for record in records: print(f" {record['view']:<28} {record['view_type']:<4} " f"cam={record['camera_id']} frames={record['num_frames']} " f"fields={len(record['fields'])} media={len(record['media'])} " f"absent={len(record['absent'])}") for field in record["fields"]: print(f" {field['component']:<26} {field['dtype']:<14} " f"{str(field['shape']):<20} invalid={field['valid_false']}") for media in record["media"]: print(f" {media['component']:<26} {media['ref']:<28} " f"{media['bytes']} B frames={media['frames']}") for view, problem in per_view_problems: print(f"FAIL {view}: {problem}", file=sys.stderr) for problem in shard_problems: print(f"FAIL {sequence}: {problem}", file=sys.stderr) return { "sequence": sequence, "views": records, "shard_problems": shard_problems, "view_problems": {record["view"]: record["problems"] for record in records}, "accepted": not shard_problems and not per_view_problems, "scope": "repackaging equivalent by reading the release; not visual acceptance", } def main(argv=None): parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) parser.add_argument("sequence", nargs="?", help="shard id, e.g. training_00000000 (omit with --all)") parser.add_argument("--all", action="store_true", help="walk every shard in the release") parser.add_argument("--root", type=Path, default=RELEASE_ROOT) parser.add_argument("--schema", type=Path, default=RELEASE_ROOT / "doc" / "schema.json", help="v1.1 schema.json (default /doc/schema.json)") parser.add_argument("--report", type=Path, help="write the full record here as JSON " "(default: tmp/rhd-tools/read_sequence.json with --all)") parser.add_argument("--quiet", action="store_true") args = parser.parse_args(argv) if not args.sequence and not args.all: parser.error("name a shard, or pass --all to walk the release") registry = Registry.load(args.schema) reader = BundleReader() sequences = all_sequences(args.root) if args.all else [args.sequence] records = [sweep(args.root, registry, reader, sequence, args.quiet) for sequence in sequences] accepted = all(record["accepted"] for record in records) failed = [record["sequence"] for record in records if not record["accepted"]] report = { "release": "shared-v1.1", "shards": len(records), "shards_accepted": len(records) - len(failed), "failed": failed, "records": records if args.all else records[0], "accepted": accepted, "scope": "repackaging equivalent by reading the release; not visual acceptance", } target = args.report or (TMP_ROOT / "read_sequence.json" if args.all else None) if target: target.parent.mkdir(parents=True, exist_ok=True) target.write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding="utf-8") print(f"wrote {target}") if not args.quiet and args.all: print(f"{len(records) - len(failed)}/{len(records)} shard(s) accepted") print("ACCEPTANCE_PASS" if accepted else "ACCEPTANCE_FAIL") return 0 if accepted else 1 if __name__ == "__main__": sys.dont_write_bytecode = True raise SystemExit(main())