| """HOT3D's actual v1.1 fields; CPU-only, without geometry recomputation.""" |
| import copy |
| import json |
| import re |
| from pathlib import Path, PurePosixPath |
|
|
| import torch |
|
|
| PROFILE = "pt/tensor_bundle/v1" |
| VERSION = "hand-warehouse/1.1" |
| RELEASE = "shared-v1.1" |
|
|
|
|
| def safe_path(root, ref): |
| if not isinstance(ref, str) or not ref or any(c in ref for c in ("\\", ":", "<", ">")): |
| raise ValueError(f"Invalid relative path: {ref!r}") |
| p = PurePosixPath(ref) |
| if p.is_absolute() or ".." in p.parts or str(p) != ref or ref == ".": |
| raise ValueError(f"Invalid relative path: {ref}") |
| result = Path(root) / ref |
| if not result.resolve().is_relative_to(Path(root).resolve()): |
| raise ValueError(f"Reference escapes view: {ref}") |
| return result |
|
|
|
|
| def exact(a, b): |
| return (a.dtype == b.dtype and a.shape == b.shape and |
| torch.equal(a.contiguous().reshape(-1).view(torch.uint8), |
| b.contiguous().reshape(-1).view(torch.uint8))) |
|
|
|
|
| def at(root, keys): |
| for key in keys: |
| root = root[key] |
| return root |
|
|
|
|
| def fields(meta): |
| """Return the fixed registered grouping, not a guessed filename merge.""" |
| if meta["dataset_id"] != "HOT3D" or meta["hand_slots"] != ["left", "right"]: |
| raise ValueError("Expected HOT3D and left/right slots") |
| if meta["camera"]["model"] != "fisheye624": |
| raise ValueError("Unreviewed camera model") |
| result = [] |
| for name, component in meta["components"].items(): |
| if not component.get("available"): |
| continue |
| schema = component["schema_id"] |
| locator = ["components", name] |
| if name == "intrinsic" and schema == "camera/fisheye624/v1": |
| bundle, key, old = "camera/camera.pt", "intrinsic", "camera/intrinsic.pt" |
| elif name == "extrinsic" and schema == "transform/se3/v1": |
| bundle, key, old = "camera/camera.pt", "extrinsic", "camera/extrinsic.pt" |
| elif name == "mano" and schema == "mano/axis_angle61/v1": |
| bundle, key, old = "annotation/mano/mano.pt", "motion", "annotation/mano/motion.pt" |
| elif re.fullmatch(r"object_[0-9]+_pose", name) and schema == "object/rigid/v1": |
| oid = name[7:-5] |
| bundle, key, old = f"annotation/object/{oid}/object.pt", "pose", f"annotation/object/{oid}/pose.pt" |
| elif ((name == "rgb" and schema == "rgb/uint8/v1") or |
| (re.fullmatch(r"object_[0-9]+_mesh", name) and schema == "mesh/obj/v1")): |
| if component.get("attributes"): |
| raise ValueError(f"Unreviewed nonnumeric attributes: {name}") |
| continue |
| else: |
| raise ValueError(f"Unreviewed HOT3D component: {name} / {schema}") |
| result.append({"locator": locator, "bundle": bundle, "entry": key, |
| "old": old, "schema": schema}) |
| for attribute, value in component.get("attributes", {}).items(): |
| if attribute != "visibility" or key not in {"motion", "pose"}: |
| raise ValueError(f"Unreviewed attribute: {name}/{attribute}") |
| result.append({"locator": locator + ["attributes", attribute], |
| "bundle": bundle, "entry": "visibility", |
| "old": str(PurePosixPath(old).with_name("visibility.pt")), |
| "schema": "visibility/hand" if key == "motion" else "visibility/object"}) |
| return result |
|
|
|
|
| def new_metadata(old): |
| if old["schema_version"] != "hand-warehouse/1.0" or old["release_id"] != "shared-v1.0": |
| raise ValueError("Source must be shared-v1.0") |
| meta = copy.deepcopy(old) |
| for field in fields(old): |
| original = at(old, field["locator"]) |
| valid_ref = str(PurePosixPath(field["old"]).with_stem(PurePosixPath(field["old"]).stem + "_valid")) |
| if original["data_ref"] != field["old"] or original.get("valid_ref") != valid_ref: |
| raise ValueError(f"Unexpected source references: {field['locator']}") |
| if any(k in original for k in ("data_key", "valid_key")): |
| raise ValueError("Source is already bundled") |
| component = at(meta, field["locator"]) |
| component.update(data_ref=field["bundle"], valid_ref=field["bundle"], |
| data_key=[field["entry"], "data"], valid_key=[field["entry"], "valid"], |
| storage={"profile": PROFILE}, valid_storage={"profile": PROFILE}) |
| meta["schema_version"], meta["release_id"] = VERSION, RELEASE |
| return meta |
|
|
|
|
| def check_field(data, valid, field, component, total, registry): |
| if field["schema"].startswith("visibility/"): |
| rule = registry["tensor_attributes"]["visibility"] |
| |
| |
| required = set(rule["required_metadata"]) - {"data_key", "valid_key", "storage", "valid_storage"} |
| if not required.issubset(component): |
| raise ValueError(f"Missing visibility metadata: {sorted(required - set(component))}") |
| if component["dtype"] not in rule["allowed_dtypes"]: |
| raise ValueError("Visibility dtype is not registered") |
| shape = (total, 2) if field["schema"] == "visibility/hand" else (total,) |
| valid_shape, dtype = shape, component["dtype"] |
| if component["visibility_type"] not in {"boolean", "ratio"}: |
| raise ValueError("Unregistered visibility type") |
| else: |
| rule = registry["components"][field["schema"]] |
| shape = tuple(total if d == "T" else d for d in rule["shape"]) |
| valid_shape = tuple(total if d == "T" else d for d in rule["valid_shape"]) |
| dtype = rule["dtype"] |
| if not isinstance(data, torch.Tensor) or data.device.type != "cpu" or data.dtype != getattr(torch, dtype) or tuple(data.shape) != shape: |
| raise ValueError(f"Wrong data dtype/shape: {field['locator']}") |
| if not isinstance(valid, torch.Tensor) or valid.device.type != "cpu" or valid.dtype != torch.bool or tuple(valid.shape) != valid_shape: |
| raise ValueError(f"Wrong validity dtype/shape: {field['locator']}") |
| if data.is_floating_point(): |
| if not torch.isfinite(data[valid]).all() or not torch.isnan(data[~valid]).all(): |
| raise ValueError(f"Source/schema finite-NaN conflict (not repaired): {field['locator']}") |
| if field["schema"].startswith("visibility/") and component["visibility_type"] == "ratio": |
| if not ((data[valid] >= 0) & (data[valid] <= 1)).all(): |
| raise ValueError("Visibility ratios outside [0,1]; do not rescale during migration") |
|
|
|
|
| class Reader: |
| def __init__(self, view): |
| self.view = Path(view) |
| self.meta = json.loads((self.view / "metainfo.json").read_text()) |
| if self.meta["schema_version"] != VERSION or self.meta["release_id"] != RELEASE: |
| raise ValueError("Reader expects shared-v1.1") |
| self.cache = {} |
|
|
| def load(self, ref): |
| if ref not in self.cache: |
| self.cache[ref] = torch.load(safe_path(self.view, ref), map_location="cpu", weights_only=True) |
| return self.cache[ref] |
|
|
| def numeric(self, field): |
| component = at(self.meta, field["locator"]) |
| if component["data_ref"] != field["bundle"] or component["valid_ref"] != field["bundle"]: |
| raise ValueError("Bundle path does not match registered grouping") |
| if component["data_key"] != [field["entry"], "data"] or component["valid_key"] != [field["entry"], "valid"]: |
| raise ValueError("Bundle key does not match registered grouping") |
| if any(component[k] != {"profile": PROFILE} for k in ("storage", "valid_storage")): |
| raise ValueError("Wrong numerical storage profile") |
| bundle = self.load(field["bundle"]) |
| entry = bundle[field["entry"]] |
| if type(entry) is not dict or set(entry) != {"data", "valid"}: |
| raise ValueError("Unexpected bundle leaves") |
| return entry["data"], entry["valid"] |
|
|
|
|
| def audit_view(view, registry, source=None, require_media=False, check_frames=True): |
| reader = Reader(view) |
| meta = reader.meta |
| if source is not None: |
| before = json.loads((Path(source) / "metainfo.json").read_text()) |
| if meta != new_metadata(before): |
| raise ValueError(f"Metadata changed beyond version/references: {view}") |
| total = meta["num_frames"] |
| grouping, rows = {}, [] |
| for field in fields(meta): |
| grouping.setdefault(field["bundle"], set()).add(field["entry"]) |
| data, valid = reader.numeric(field) |
| check_field(data, valid, field, at(meta, field["locator"]), total, registry) |
| if source is not None: |
| component = at(before, field["locator"]) |
| for name, tensor in (("data_ref", data), ("valid_ref", valid)): |
| old = torch.load(safe_path(source, component[name]), map_location="cpu", weights_only=True) |
| if not exact(old, tensor): |
| raise ValueError(f"Changed tensor bytes: {view} {field['locator']} {name}") |
| rows.append({"field": "/".join(field["locator"]), "bundle": field["bundle"], |
| "shape": list(data.shape), "valid_shape": list(valid.shape), |
| "valid_true": int(valid.sum()), "valid_total": valid.numel(), |
| "exact_source_bytes": source is not None}) |
| for ref, entries in grouping.items(): |
| if type(reader.cache[ref]) is not dict or set(reader.cache[ref]) != entries: |
| raise ValueError(f"Extra/missing fields in {ref}") |
| missing = [] |
| for name, component in meta["components"].items(): |
| if not component.get("available") or component.get("schema_id") not in {"rgb/uint8/v1", "mesh/obj/v1"}: |
| continue |
| if "data_key" in component or "valid_key" in component: |
| raise ValueError("Media/mesh validity must stay standalone") |
| for key in ("data_ref", "valid_ref"): |
| if not safe_path(view, component[key]).is_file(): |
| missing.append(component[key]) |
| valid_path = safe_path(view, component["valid_ref"]) |
| if valid_path.is_file(): |
| tensor = reader.load(component["valid_ref"]) |
| expected = (total,) if name == "rgb" else () |
| if not isinstance(tensor, torch.Tensor) or tensor.dtype != torch.bool or tuple(tensor.shape) != expected: |
| raise ValueError("Wrong standalone validity") |
| if source is not None: |
| old_ref = before["components"][name]["valid_ref"] |
| old_valid = torch.load(safe_path(source, old_ref), map_location="cpu", weights_only=True) |
| if not exact(old_valid, tensor): |
| raise ValueError(f"Standalone validity changed: {name}") |
| elif name == "rgb": |
| raise ValueError("RGB validity is part of the numerical-stage input, not deferred") |
| if require_media and missing: |
| raise ValueError(f"Incomplete view: {len(missing)} missing media/asset references") |
| if check_frames: |
| frame_path = safe_path(view, meta["sampling"]["frames_ref"]) |
| count = 0 |
| with frame_path.open() as handle: |
| for line in handle: |
| frame = json.loads(line) |
| if frame["frame_index"] != count or frame["source_locator"]["stream_id"] != meta["camera_id"]: |
| raise ValueError("Broken frame/camera order") |
| count += 1 |
| if count != total: |
| raise ValueError("Frame table length mismatch") |
| return {"sequence": meta["sequence_id"], "camera": meta["camera_id"], |
| "frames": total, "split": meta["split"], "fields": rows, |
| "bundles": len(grouping), "missing_media_asset_refs": missing, |
| "numerical_bytes_exact": source is not None} |
|
|
