#!/usr/bin/env python3 """Validate the prepared MatrixCity Hugging Face dataset directory.""" from __future__ import annotations import argparse import csv import hashlib import json import sys from collections import Counter from pathlib import Path ROOT = Path(__file__).resolve().parents[1] def sha256(path: Path) -> str: digest = hashlib.sha256() with path.open("rb") as handle: for chunk in iter(lambda: handle.read(8 * 1024 * 1024), b""): digest.update(chunk) return digest.hexdigest() def fail(errors: list[str], message: str) -> None: errors.append(message) def validate_metadata(errors: list[str]) -> Counter: metadata_path = ROOT / "data" / "metadata.jsonl" if not metadata_path.is_file(): fail(errors, "Missing data/metadata.jsonl") return Counter() counts: Counter = Counter() sample_ids: set[str] = set() video_paths: set[str] = set() with metadata_path.open("r", encoding="utf-8") as handle: for line_number, line in enumerate(handle, start=1): try: row = json.loads(line) except json.JSONDecodeError as error: fail(errors, f"metadata line {line_number}: {error}") continue sample_id = row.get("sample_id") if not sample_id or sample_id in sample_ids: fail(errors, f"metadata line {line_number}: missing/duplicate sample_id {sample_id!r}") sample_ids.add(sample_id) file_name = row.get("file_name") if not file_name or file_name in video_paths: fail(errors, f"metadata line {line_number}: missing/duplicate file_name {file_name!r}") continue video_paths.add(file_name) video_path = ROOT / "data" / Path(file_name) if not video_path.is_file(): fail(errors, f"metadata line {line_number}: missing video {file_name}") annotations = row.get("annotations") or [] has_annotations = bool(row.get("has_annotations")) if len(annotations) != row.get("annotation_frame_count"): fail(errors, f"{sample_id}: annotation_frame_count mismatch") if has_annotations and len(annotations) != row.get("frame_count"): fail(errors, f"{sample_id}: video/annotation frame count mismatch") if not has_annotations and annotations: fail(errors, f"{sample_id}: unannotated record contains frame annotations") expected_ids = list(range(1, len(annotations) + 1)) actual_ids = [annotation.get("frame_id") for annotation in annotations] if actual_ids != expected_ids: fail(errors, f"{sample_id}: frame IDs are not contiguous and one-based") width = row.get("width") height = row.get("height") bbox_count = 0 usable_count = 0 for annotation in annotations: bbox = annotation.get("bbox_xywh") has_bbox = bool(annotation.get("has_bbox")) if has_bbox != (bbox is not None): fail(errors, f"{sample_id} frame {annotation.get('frame_id')}: has_bbox mismatch") continue if bbox is None: continue bbox_count += 1 if not annotation.get("source_marked_invalid"): usable_count += 1 if not isinstance(bbox, list) or len(bbox) != 4: fail(errors, f"{sample_id} frame {annotation.get('frame_id')}: malformed bbox") continue x, y, box_width, box_height = bbox if min(x, y, box_width, box_height) < 0 or box_width <= 0 or box_height <= 0: fail(errors, f"{sample_id} frame {annotation.get('frame_id')}: invalid bbox values") if x + box_width > width or y + box_height > height: fail(errors, f"{sample_id} frame {annotation.get('frame_id')}: bbox out of bounds") if bbox_count != row.get("bbox_frame_count"): fail(errors, f"{sample_id}: bbox_frame_count mismatch") if usable_count != row.get("usable_bbox_frame_count"): fail(errors, f"{sample_id}: usable_bbox_frame_count mismatch") annotation_path = row.get("annotation_path") if has_annotations: if not annotation_path or not (ROOT / Path(annotation_path)).is_file(): fail(errors, f"{sample_id}: missing canonical annotation CSV") elif annotation_path is not None: fail(errors, f"{sample_id}: unannotated record has annotation_path") counts["videos"] += 1 counts["annotated_videos"] += has_annotations counts["annotation_rows"] += len(annotations) counts["bbox_rows"] += bbox_count counts["usable_bbox_rows"] += usable_count counts[f"subset:{row.get('subset')}"] += 1 disk_videos = set( path.relative_to(ROOT / "data").as_posix() for path in (ROOT / "data" / "videos").rglob("*.mp4") ) extras = sorted(disk_videos - video_paths) if extras: fail(errors, f"{len(extras)} unreferenced MP4 files; first: {extras[0]}") return counts def validate_manifest(errors: list[str], checksums: bool) -> Counter: manifest_path = ROOT / "manifests" / "files.csv" counts: Counter = Counter() if not manifest_path.is_file(): fail(errors, "Missing manifests/files.csv") return counts with manifest_path.open("r", encoding="utf-8", newline="") as handle: for row in csv.DictReader(handle): path = ROOT / Path(row["path"]) if not path.is_file(): fail(errors, f"Manifest file missing: {row['path']}") continue if path.stat().st_size != int(row["size_bytes"]): fail(errors, f"Manifest size mismatch: {row['path']}") if checksums and sha256(path) != row["sha256"]: fail(errors, f"Manifest SHA-256 mismatch: {row['path']}") counts[f"manifest:{row['role']}"] += 1 return counts def main() -> int: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--checksums", action="store_true", help="Recompute every payload SHA-256.") args = parser.parse_args() errors: list[str] = [] counts = validate_metadata(errors) counts.update(validate_manifest(errors, args.checksums)) if errors: print(f"FAILED: {len(errors)} issue(s)", file=sys.stderr) for error in errors[:100]: print(f"- {error}", file=sys.stderr) if len(errors) > 100: print(f"- ... {len(errors) - 100} more", file=sys.stderr) return 1 mode = "structure and checksums" if args.checksums else "structure" print(f"PASS: {mode}") for key in sorted(counts): print(f"{key}: {counts[key]}") return 0 if __name__ == "__main__": sys.exit(main())