| """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/<id>/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() |
|
|
