Blame for FreiHAND/shared-v1.1/script/validate_freihand.py

#!/usr/bin/env python3
"""Validate the fixed FreiHAND migration; media decoding is a separate gate."""
import argparse
from collections import Counter
import hashlib
import json
from pathlib import Path

import torch

from bundle_io import LAYOUT, PROFILE, ViewReader, safe_path
from fetch_shared_subset import REPO, REVISION, PREFIX, file_digests, json_write, verified
from migrate_freihand import check_field, validate_view

SOURCE_MANIFEST_SHA256 = "1b846defe770c148761b1918cccb8369fd7fdc5f661142d0a9ed250bb9867c9d"
REGISTRY_SHA256 = "9f3769f950b36f75f3d571c77b5a661ca8e72afae20c9f1ddd1deef140e6cca8"
NUMERIC_SCHEMAS = {"intrinsic": "camera/pinhole/v1", "keypoints_xyz": "keypoints/xyz/v1", "mano": "mano/axis_angle61/v1"}
AXES = {"intrinsic": ["T", "row", "column"], "keypoints_xyz": ["T", "hand", "joint", "coordinate"],
        "mano": ["T", "hand", "parameter"], "rgb": ["T", "height", "width", "channel"], "segment": ["T", "height", "width"]}


def canonical_hash(value):
    return hashlib.sha256(json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode()).hexdigest()


def require_fields(value, fields, label):
    if not isinstance(value, dict) or not set(fields).issubset(value):
        missing = set(fields) - set(value) if isinstance(value, dict) else set(fields)
        raise ValueError(f"{label}: missing required fields {sorted(missing)}")


def expected_views():
    return {f"training_{start:08d}": ("train", start, min(4096, 130240-start)) for start in range(0, 130240, 4096)} | {"evaluation_00000000": ("test", 0, 3960)}


def check_source_manifest(manifest):
    if (manifest.get("repo"), manifest.get("revision"), manifest.get("source_prefix")) != (REPO, REVISION, PREFIX.rstrip("/")):
        raise ValueError("Wrong fixed source repository/revision/prefix")
    if canonical_hash(manifest) != SOURCE_MANIFEST_SHA256:
        raise ValueError("Source manifest differs from the audited immutable file inventory")


def check_source_tree(source, manifest):
    """Re-authenticate the numerical baseline once, not once per view."""
    check_source_manifest(manifest)
    entries = [item for item in manifest["files"] if item["download"]]
    for item in entries:
        verified(safe_path(source, item["relative_path"]), item)
    return len(entries)


def check_complete_media(release, reused_paths):
    for name in sorted(reused_paths):
        if not safe_path(release, name).is_file():
            raise FileNotFoundError(f"Required reused media is missing: {name}")


def check_plan(release, plan):
    """Authenticate the source inventory, then check the entire declared file set."""
    if (plan.get("repo"), plan.get("revision"), plan.get("source_prefix"), plan.get("target_prefix")) != (REPO, REVISION, PREFIX.rstrip("/"), "FreiHAND/shared-v1.1"):
        raise ValueError("Wrong assembly plan repository/revision/prefix")
    manifest = plan.get("source_manifest", {})
    check_source_manifest(manifest)
    original = {item["relative_path"]: item for item in manifest["files"]}
    expected_reuse = {name: item for name, item in original.items() if not item["download"]}
    reuse_rows = plan.get("reuse_unchanged", [])
    reuse = {item["relative_path"]: item for item in reuse_rows}
    if len(reuse) != len(reuse_rows) or reuse != expected_reuse:
        raise ValueError("Media reuse plan differs from the fixed source inventory")
    replacements = {f"data/{seq}/camera/{name}" for seq in expected_views() for name in (
        "camera/intrinsic.pt", "camera/intrinsic_valid.pt", "annotation/mano/motion.pt",
        "annotation/mano/motion_valid.pt", "annotation/keypoints/xyz.pt", "annotation/keypoints/xyz_valid.pt")}
    if set(plan.get("remove_only_after_verification", [])) != replacements or len(plan.get("remove_only_after_verification", [])) != len(replacements):
        raise ValueError("Old numerical-file removal list differs from the fixed layout")
    rows = plan.get("files", [])
    files = {item["relative_path"]: item for item in rows}
    if not files or len(files) != len(rows) or files.keys() & reuse.keys():
        raise ValueError("Invalid overlay file manifest")
    for name in files.keys() | reuse.keys():
        safe_path(release, name)
    if set(original) - replacements - set(reuse) - set(files):
        raise ValueError("Source files are missing from the assembly plan")
    actual = {p.relative_to(release).as_posix() for p in release.rglob("*") if p.is_file() and "__pycache__" not in p.parts}
    if not set(files).issubset(actual) or actual - set(files) - set(reuse):
        raise ValueError("Release file set does not match the assembly plan")
    for name, item in files.items():
        digest = file_digests(release / name)
        if any(digest[k] != item[k] for k in ("size", "sha256", "git_blob_sha1")):
            raise ValueError(f"Delivery digest changed: {name}")
    for name in actual & set(reuse):
        verified(release / name, reuse[name])
    if (plan.get("source_file_count"), plan.get("overlay_file_count"), plan.get("expected_assembled_file_count")) != (len(original), len(files), len(files)+len(reuse)):
        raise ValueError("Assembly plan file counts disagree")
    if plan.get("overlay_bytes") != sum(item["size"] for item in files.values()):
        raise ValueError("Assembly plan byte count disagrees")
    return set(reuse), {"source_bound": True, "overlay_hashes": len(files), "reused_media_hashes": len(actual & set(reuse))}


def check_metadata(meta, view, registry):
    require_fields(meta, registry["view_metadata"]["required_fields"], "view metadata")
    seq = view.parent.name
    if seq not in expected_views() or view.name != "camera":
        raise ValueError("Unknown FreiHAND view")
    split, start, total = expected_views()[seq]
    if (meta["schema_version"], meta["dataset_id"], meta["release_id"], meta["sequence_id"], meta["camera_id"]) != ("hand-warehouse/1.1", "FreiHAND", "shared-v1.1", seq, "camera"):
        raise ValueError("View identity/version does not match its directory")
    if type(meta["num_frames"]) is not int or meta["num_frames"] != total or meta["hand_slots"] != ["left", "right"] or meta["view_type"] != "exo" or meta["split"] != split:
        raise ValueError("Frame count/hand slots/view type/split mismatch")
    prefix = "training" if split == "train" else "evaluation"
    archive = "raw/data/FreiHAND_pub_v2.zip" if split == "train" else "raw/data/FreiHAND_pub_v2_eval.zip"
    if meta.get("split_scheme") != "FreiHAND_official_train_evaluation" or meta.get("split_source_locator") != {"archive": archive, "member_prefix": prefix + "/"}:
        raise ValueError("Missing or wrong official split provenance")
    require_fields(meta["sampling"], {"type", "source_fps", "frames_ref", "selection", "shard_max_images"}, "sampling")
    if meta["sample_type"] != "image" or meta["sampling"].get("type") != "independent" or meta["sampling"].get("source_fps") is not None or meta["sampling"].get("frames_ref") != "camera/frames.jsonl" or meta["sampling"]["shard_max_images"] != 4096:
        raise ValueError("Independent-image sampling or frame reference mismatch")
    if meta["camera"] != {"model": "pinhole", "schema_id": "camera/pinhole/v1", "image_size": [224, 224]}:
        raise ValueError("Camera model or image size mismatch")
    if set(meta["components"]) != set(AXES):
        raise ValueError("Missing or unregistered FreiHAND component")
    required = {"available", "schema_id", "data_ref", "axes", "valid_ref", "valid_axes", "provenance", "source_locator"}
    for name, comp in meta["components"].items():
        require_fields(comp, required, name)
        schema = NUMERIC_SCHEMAS.get(name, "rgb/uint8/v1" if name == "rgb" else ("segment/foreground_intensity/v1" if split == "train" else "segment/uint16_labels/v1"))
        if comp["available"] is not True or comp["schema_id"] != schema or comp["axes"] != AXES[name]:
            raise ValueError(f"Component availability/schema/axes mismatch: {name}")
        definition = registry["components"][schema]
        require_fields(comp, definition.get("required_metadata", []), name)
        if comp.get("attributes"):
            raise ValueError("Unregistered attributes in this fixed FreiHAND release")
        for key in ("unit", "angle_unit", "coordinate_frame"):
            if key in definition and comp.get(key) != definition[key]:
                raise ValueError(f"Component {name}: wrong {key}")
        if name == "keypoints_xyz" and comp["keypoint_schema"] != "mano21/v1":
            raise ValueError("Wrong keypoint convention")
        if name in {"keypoints_xyz", "mano"} and comp.get("coordinate_frame") != "camera":
            raise ValueError(f"Component {name}: wrong coordinate_frame")
        if name == "mano" and comp.get("model_profile") != {"version": "MANO-v1.2", "flat_hand_mean": True, "left_shapedirs_fix": False}:
            raise ValueError("Wrong MANO model profile")
        valid_axes = AXES[name][:len(definition["valid_shape"])]
        if comp["valid_axes"] != valid_axes or not isinstance(comp["source_locator"], dict) or not comp["source_locator"]:
            raise ValueError(f"Wrong validity axes or missing provenance: {name}")
        if not isinstance(comp["provenance"], dict) or comp["provenance"].get("kind") not in {"source", "format_conversion", "derived"} or not comp["provenance"].get("method"):
            raise ValueError(f"Invalid provenance: {name}")
        for key in ("data_ref", "valid_ref"):
            safe_path(view, comp[key])
        if name in LAYOUT:
            continue
        if "data_key" in comp or "valid_key" in comp or comp.get("valid_storage", {}).get("profile") == PROFILE:
            raise ValueError("Media validity cannot be wrapped as a bundle")
        expected_ref = "observation/rgb.mkv" if name == "rgb" else "annotation/segment/mask.mkv"
        expected_valid = "observation/rgb_valid.pt" if name == "rgb" else "annotation/segment/mask_valid.pt"
        if (comp["data_ref"], comp["valid_ref"]) != (expected_ref, expected_valid):
            raise ValueError("Media references differ from this fixed source")
        require_fields(comp["storage"], registry["video_metadata"]["required"], "video storage")
        if comp["storage"]["profile"] not in definition["allowed_storage_profiles"] or comp["storage"]["encoded_size"] != [224, 224] or comp.get("storage_fps") != 1 or comp.get("timebase_role") != "index_only":
            raise ValueError("Wrong media storage profile/size/timebase")
        storage = comp["storage"]
        # Training foreground values came from JPEG: lossless FFV1 storage
        # does not erase that upstream lossy provenance.
        expected_encoding = ("mkv/mjpeg_copy/v1", "mjpeg", "yuvj420p", True) if name == "rgb" else ("mkv/uint16_ffv1/v1", "ffv1", "gray" if split == "train" else "gray16le", split == "train")
        if (storage["profile"], storage["codec"], storage["pixel_format"], storage["source_lossy"]) != expected_encoding:
            raise ValueError("Media encoding declaration differs from the fixed source")
    segment = meta["components"]["segment"]
    if segment.get("coverage") != {"kind": "selected_entities", "entities": ["hand_right"]} or segment.get("segmentation_type") != "semantic":
        raise ValueError("Wrong segment coverage or segmentation_type")
    if split == "train" and (segment.get("value_range") != [0, 255] or segment.get("normalization_scale") != 1/255 or segment.get("foreground_category") != "hand" or segment.get("entity_id") != "hand_right"):
        raise ValueError("Training foreground-intensity semantics changed")
    if split == "test" and segment.get("mapping_ref") != "annotation/segment/instances.jsonl":
        raise ValueError("Missing or wrong instance mapping reference")
    return split, start, total


def check_mapping(view, meta):
    comp = meta["components"]["segment"]
    if "mapping_ref" not in comp:
        return
    path = safe_path(view, comp["mapping_ref"])
    rows = [json.loads(line) for line in path.read_text().splitlines()]
    if len(rows) != meta["num_frames"]:
        raise ValueError("Instance mapping length mismatch")
    for i, row in enumerate(rows):
        if row.get("frame_index") != i or not isinstance(row.get("labels"), list) or not row["labels"]:
            raise ValueError("Invalid instance mapping row")
        seen = set()
        for label in row["labels"]:
            require_fields(label, {"mask_value", "category_id", "entity_id", "part_id", "source_instance_id"}, "instance mapping")
            code = label["mask_value"]
            if type(code) is not int or not 1 <= code <= 65534 or code in seen:
                raise ValueError("Unknown, reserved, or duplicate mapping code")
            seen.add(code)
            if label["part_id"] is not None:
                raise ValueError("Unregistered part_id in FreiHAND instance mapping")
            if code == 65534:
                if (label["category_id"], label["entity_id"], label["source_instance_id"]) != ("background", None, 0):
                    raise ValueError("Wrong background mapping")
            elif (label["category_id"], label["entity_id"], label["source_instance_id"]) != ("hand", "hand_right", code):
                raise ValueError("Wrong hand mapping")


def validate(release, source=None, overlay_plan=None, assembly_plan=None, source_manifest=None):
    torch.set_num_threads(1)
    release = Path(release)
    if overlay_plan is not None and assembly_plan is not None:
        raise ValueError("Choose either overlay or full assembly validation")
    registry_path = safe_path(release, "doc/schema.json")
    if file_digests(registry_path)["sha256"] != REGISTRY_SHA256:
        raise ValueError("Registry differs from the supplied v1.1 specification")
    registry = json.loads(registry_path.read_text())
    if registry["schema_version"] != "hand-warehouse/1.1":
        raise ValueError("Wrong registry")
    omitted, plan_result = (set(), None)
    plan = overlay_plan if overlay_plan is not None else assembly_plan
    if plan is not None:
        omitted, plan_result = check_plan(release, plan)
        if overlay_plan is None:
            check_complete_media(release, omitted)
            omitted = set()
    source_hashes = None
    if source is not None:
        manifest = plan["source_manifest"] if plan is not None else source_manifest
        if manifest is None:
            raise ValueError("Fixed source manifest required for exact source comparison")
        source_hashes = check_source_tree(source, manifest)
    missing, seen, counts, fields, views = [], set(), Counter(), 0, 0
    expected_data_paths = set()
    for metadata in sorted((release / "data").glob("*/*/metainfo.json")):
        safe_path(release, metadata.relative_to(release).as_posix())
        reader = ViewReader(metadata.parent)
        meta = reader.meta
        split, start, total = check_metadata(meta, metadata.parent, registry)
        view_relative = metadata.parent.relative_to(release)
        paths = {"metainfo.json", "camera/frames.jsonl", *(item[0] for item in LAYOUT.values())}
        for name in LAYOUT:
            component = meta["components"][name]
            data, valid = reader.numeric(name)
            definition = registry["components"][component["schema_id"]]
            check_field(data, valid, definition, total)
            fields += 1
        for name in ("rgb", "segment"):
            component = meta["components"][name]
            valid = reader.validity(name)
            if valid.dtype != torch.bool or tuple(valid.shape) != (total,):
                raise ValueError("Media validity is not an independent bool [T] tensor")
            paths.update((component["data_ref"], component["valid_ref"]))
            path = safe_path(metadata.parent, component["data_ref"])
            if not path.is_file():
                relative = path.relative_to(release).as_posix()
                if relative not in omitted:
                    raise FileNotFoundError(f"Required media is missing: {relative}")
                missing.append(relative)
        check_mapping(metadata.parent, meta)
        if "mapping_ref" in meta["components"]["segment"]:
            paths.add(meta["components"]["segment"]["mapping_ref"])
        expected_data_paths.update((view_relative / p).as_posix() for p in paths)
        rows = [json.loads(line) for line in safe_path(metadata.parent, meta["sampling"]["frames_ref"]).read_text().splitlines()]
        if len(rows) != total:
            raise ValueError("Frame count mismatch")
        prefix = "training" if split == "train" else "evaluation"
        modulus = 32560 if split == "train" else 3960
        archive = "raw/data/FreiHAND_pub_v2.zip" if split == "train" else "raw/data/FreiHAND_pub_v2_eval.zip"
        for i, frame in enumerate(rows):
            index = start+i
            if type(frame.get("frame_index")) is not int or frame["frame_index"] != i or frame.get("sample_id") != f"FreiHAND/{prefix}/{index:08d}" or frame["sample_id"] in seen:
                raise ValueError("Frame order or sample identity mismatch")
            if "timestamp_ns" not in frame or frame["timestamp_ns"] is not None or "clock_domain" not in frame or frame["clock_domain"] is not None:
                raise ValueError("Independent images must retain unknown capture time")
            seen.add(frame["sample_id"])
            if frame.get("source_frame_id") != str(index) or frame.get("image_variant") != {"base_sample_id": index % modulus, "variant_index": index // modulus}:
                raise ValueError("Source frame or background variant mapping mismatch")
            locator = frame.get("source_locator", {})
            if (locator.get("annotation_index"), locator.get("member"), locator.get("archive")) != (index % modulus, f"{prefix}/rgb/{index:08d}.jpg", archive):
                raise ValueError("Image-to-annotation provenance mismatch")
        if source:
            validate_view(Path(source) / view_relative, metadata.parent, registry)
        counts[split] += total
        views += 1
    if views != 33 or dict(counts) != {"test": 3960, "train": 130240}:
        raise ValueError(f"Wrong full-dataset coverage: views={views}, counts={dict(counts)}")
    actual_data = {p.relative_to(release).as_posix() for p in (release / "data").rglob("*") if p.is_file()}
    if actual_data != expected_data_paths - set(missing):
        raise ValueError("Unexpected, obsolete, or missing files in the data tree")
    return {"numeric_structure_passed": True, "exact_source_comparison": bool(source),
            "verified_source_file_hashes": source_hashes,
            "views": views, "counts": dict(counts), "numeric_fields": fields,
            "missing_media": missing, "mode": "overlay" if overlay_plan is not None else "full_tree",
            "complete_media_present": not missing, "assembly_plan_checks": plan_result,
            "visual_review": "not_performed", "media_decoding": "not_performed",
            "scope": "All fixed-release structure and references; optional exact v1.0 tensor comparison and bound-manifest hashes. Media decoding and human approval are separate gates."}


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--release", type=Path, default=Path(__file__).resolve().parents[1])
    parser.add_argument("--source", type=Path, help="Original v1.0 subset for exact byte comparisons")
    parser.add_argument("--source-manifest", type=Path, help="Fixed source inventory; required with --source when no assembly/overlay plan is supplied")
    plans = parser.add_mutually_exclusive_group()
    plans.add_argument("--overlay-plan", type=Path, help="Verify the fixed-source plan and allow its absent unchanged media")
    plans.add_argument("--assembly-plan", type=Path, help="Verify the plan and require all declared reused media to be present")
    parser.add_argument("--report", type=Path)
    args = parser.parse_args()
    overlay = json.loads(args.overlay_plan.read_text()) if args.overlay_plan else None
    assembly = json.loads(args.assembly_plan.read_text()) if args.assembly_plan else None
    manifest = json.loads(args.source_manifest.read_text()) if args.source_manifest else None
    result = validate(args.release, args.source, overlay, assembly, manifest)
    if args.report:
        json_write(args.report, result)
    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()