"""Small numerical and negative tests, no downloads or GPU.""" import copy import json from pathlib import Path import tempfile import unittest import torch from hot3d_bundle import PROFILE, Reader, at, audit_view, check_field, exact, fields, new_metadata, safe_path def sample(): def component(schema, path, axes, vaxes): return {"available": True, "schema_id": schema, "data_ref": path, "valid_ref": path.replace(".pt", "_valid.pt"), "axes": axes, "valid_axes": vaxes, "provenance": {"kind": "source"}, "source_locator": {"file": "raw/example"}} meta = {"dataset_id": "HOT3D", "schema_version": "hand-warehouse/1.0", "release_id": "shared-v1.0", "sequence_id": "example", "camera_id": "214-1", "num_frames": 2, "split": "train", "hand_slots": ["left", "right"], "camera": {"model": "fisheye624"}, "sampling": {"frames_ref": "camera/frames.jsonl"}, "components": {}} c = meta["components"] c["intrinsic"] = component("camera/fisheye624/v1", "camera/intrinsic.pt", ["T", "parameter"], ["T"]) c["extrinsic"] = component("transform/se3/v1", "camera/extrinsic.pt", ["T", "row", "column"], ["T"]) c["mano"] = component("mano/axis_angle61/v1", "annotation/mano/motion.pt", ["T", "hand", "parameter"], ["T", "hand"]) c["object_123_pose"] = component("object/rigid/v1", "annotation/object/123/pose.pt", ["T", "row", "column"], ["T"]) for name, path, shape in [("mano", "annotation/mano/visibility.pt", ["T", "hand"]), ("object_123_pose", "annotation/object/123/visibility.pt", ["T"])]: v = component("unused", path, shape, shape) v.pop("schema_id"); v.update(dtype="float32", visibility_type="ratio", meaning="whole_hand" if name=="mano" else "whole_object", valid_policy={"formula": "independent"}) c[name]["attributes"] = {"visibility": v} c["rgb"] = {"available": True, "schema_id": "rgb/uint8/v1", "data_ref": "observation/rgb.mkv", "valid_ref": "observation/rgb_valid.pt", "storage": {"profile": "mkv/mjpeg_copy/v1"}} c["object_123_mesh"] = {"available": True, "schema_id": "mesh/obj/v1", "data_ref": "annotation/object/123/assets/obj.obj", "valid_ref": "annotation/object/123/assets/obj_valid.pt"} return meta class MigrationTest(unittest.TestCase): @classmethod def setUpClass(cls): torch.set_num_threads(1) root = Path(__file__).resolve().parents[1] schema = root / "doc/schema.json" if not schema.exists(): schema = root / "spec/hand-warehouse-1.1/schema.json" cls.registry = json.loads(schema.read_text()) def test_grouping(self): fs = fields(sample()) self.assertEqual(len(fs), 6) self.assertEqual(len({x['bundle'] for x in fs}), 3) def test_no_semantic_drift(self): old = sample(); new = new_metadata(old) back = copy.deepcopy(new); back['schema_version'] = old['schema_version']; back['release_id'] = old['release_id'] for f in fields(old): oldc, newc = at(old, f['locator']), at(back, f['locator']) for k in ['data_ref', 'valid_ref', 'data_key', 'valid_key', 'storage', 'valid_storage']: if k in oldc: newc[k] = copy.deepcopy(oldc[k]) else: newc.pop(k, None) self.assertEqual(old, back) def test_test_split_no_invented_mano_or_pose(self): old = sample(); old['split'] = 'test'; del old['components']['mano']; del old['components']['object_123_pose'] new = new_metadata(old) self.assertNotIn('mano', new['components']) self.assertEqual({x['entry'] for x in fields(new)}, {'intrinsic', 'extrinsic'}) def test_media_and_asset_valid_unchanged(self): old = sample(); new = new_metadata(old) for name in ['rgb', 'object_123_mesh']: self.assertEqual(old['components'][name], new['components'][name]) def test_independent_visibility(self): old = sample(); new = new_metadata(old) c = new['components']['mano']; v = c['attributes']['visibility'] self.assertEqual(v['valid_key'], ['visibility', 'valid']) self.assertNotEqual(v['valid_key'], c['valid_key']) self.assertEqual(v['valid_policy'], old['components']['mano']['attributes']['visibility']['valid_policy']) def test_object_id_mismatch(self): old = sample(); old['components']['object_123_pose']['data_ref'] = 'annotation/object/124/pose.pt' with self.assertRaises(ValueError): new_metadata(old) def test_unknown_component(self): old = sample(); old['components']['new_depth'] = {'available': True, 'schema_id': 'depth/z_float32/v1'} with self.assertRaises(ValueError): new_metadata(old) def test_unknown_attribute(self): old = sample(); old['components']['mano']['attributes']['confidence'] = {} with self.assertRaises(ValueError): new_metadata(old) def test_no_double_migration(self): with self.assertRaises(ValueError): new_metadata(new_metadata(sample())) def test_no_altered_hand_order(self): old = sample(); old['hand_slots'] = ['right','left'] with self.assertRaises(ValueError): new_metadata(old) def test_fisheye_remains_15(self): f = fields(sample())[0]; c = at(sample(), f['locator']) check_field(torch.zeros(2,15), torch.ones(2,dtype=torch.bool), f, c, 2, self.registry) with self.assertRaises(ValueError): check_field(torch.zeros(2,3,3), torch.ones(2,dtype=torch.bool), f, c, 2, self.registry) def test_valid_dtype_shape_and_nan(self): f = fields(sample())[0]; c = at(sample(), f['locator']) for valid in [torch.ones(2), torch.ones(2,15,dtype=torch.bool), torch.zeros(2,dtype=torch.bool)]: with self.assertRaises(ValueError): check_field(torch.zeros(2,15), valid, f, c, 2, self.registry) def test_nan_payload_bytes(self): a = torch.tensor([2143289345], dtype=torch.int32).view(torch.float32) b = torch.tensor([2143289346], dtype=torch.int32).view(torch.float32) self.assertTrue(torch.isnan(a).all() and torch.isnan(b).all()) self.assertFalse(exact(a,b)); self.assertTrue(exact(a,a.clone())) self.assertTrue(exact(torch.tensor(True),torch.tensor(True))) def test_visibility_rejects_unregistered_dtype(self): meta=sample();f=next(x for x in fields(meta) if x['schema']=='visibility/hand');c=at(meta,f['locator']) c['dtype']='float64' with self.assertRaisesRegex(ValueError,'dtype is not registered'): check_field(torch.zeros(2,2,dtype=torch.float64),torch.ones(2,2,dtype=torch.bool),f,c,2,self.registry) def test_visibility_requires_source_locator(self): meta=sample();f=next(x for x in fields(meta) if x['schema']=='visibility/hand');c=at(meta,f['locator']) del c['source_locator'] with self.assertRaisesRegex(ValueError,'Missing visibility metadata'): check_field(torch.zeros(2,2),torch.ones(2,2,dtype=torch.bool),f,c,2,self.registry) def test_safe_paths(self): for ref in ['../outside', '/absolute', 'https://host/a', 'a//b', 'a//x']: with self.assertRaises(ValueError): safe_path('/tmp/view',ref) def test_roundtrip_reader_and_strict_missing_media(self): with tempfile.TemporaryDirectory() as tmp: view = Path(tmp); old=sample(); new=new_metadata(old) (view/'metainfo.json').write_text(json.dumps(new)); bundles={} for f in fields(new): c=at(new,f['locator']) if f['schema'].startswith('visibility'): shape=(2,2) if f['schema']=='visibility/hand' else (2,); vshape=shape else: rule=self.registry['components'][f['schema']] shape=tuple(2 if x=='T' else x for x in rule['shape']); vshape=tuple(2 if x=='T' else x for x in rule['valid_shape']) bundles.setdefault(f['bundle'],{})[f['entry']]={'data':torch.zeros(shape),'valid':torch.ones(vshape,dtype=torch.bool)} for ref,b in bundles.items(): p=view/ref;p.parent.mkdir(parents=True,exist_ok=True);torch.save(b,p) (view/'observation').mkdir();torch.save(torch.ones(2,dtype=torch.bool),view/'observation/rgb_valid.pt') reader=Reader(view) for f in fields(new):reader.numeric(f) self.assertEqual(len(reader.cache),3) audit_view(view,self.registry,check_frames=False) with self.assertRaises(ValueError):audit_view(view,self.registry,require_media=True,check_frames=False) bundles['camera/camera.pt']['extra']={'data':torch.zeros(1),'valid':torch.ones(1,dtype=torch.bool)} torch.save(bundles['camera/camera.pt'],view/'camera/camera.pt') with self.assertRaises(ValueError):audit_view(view,self.registry,check_frames=False) def test_source_rgb_valid_bit_must_match(self): with tempfile.TemporaryDirectory() as tmp: source=Path(tmp)/'old';view=Path(tmp)/'new';source.mkdir();view.mkdir() old=sample();old['components']={'rgb':old['components']['rgb']} (source/'metainfo.json').write_text(json.dumps(old));(view/'metainfo.json').write_text(json.dumps(new_metadata(old))) for p in [source,view]: (p/'observation').mkdir();torch.save(torch.ones(2,dtype=torch.bool),p/'observation/rgb_valid.pt') audit_view(view,self.registry,source=source,check_frames=False) torch.save(torch.tensor([False,True]),view/'observation/rgb_valid.pt') with self.assertRaisesRegex(ValueError,'Standalone validity changed: rgb'): audit_view(view,self.registry,source=source,check_frames=False) if __name__ == '__main__': unittest.main()