| """Read-only release validation; --tensors/--media explicitly broaden coverage.""" |
| import argparse |
| import json |
| from pathlib import Path |
| import subprocess |
| import sys |
|
|
| def load(p): |
| return json.loads(p.read_text(encoding='utf-8-sig')) |
|
|
| def refs(value): |
| if isinstance(value, dict): |
| for k, v in value.items(): |
| if k.endswith('_ref') and isinstance(v, str): |
| yield k, v |
| elif k != 'source_locator': |
| yield from refs(v) |
| elif isinstance(value, list): |
| for v in value: |
| yield from refs(v) |
|
|
| def check(release, tensors=False, media=False, output=None, sequence_id=None): |
| if tensors: |
| import torch |
| torch.set_num_threads(1) |
| results=[] |
| sequences=sorted(p for p in (release/'data').iterdir() if p.is_dir()) |
| if sequence_id is not None: sequences=[p for p in sequences if p.name==sequence_id] |
| if not sequences: |
| raise RuntimeError('No sequences found') |
| for sequence in sequences: |
| errors=[]; count=0; frames_total=0 |
| views=sorted(p for p in sequence.iterdir() if p.is_dir()) |
| if not views: errors.append('no views') |
| for view in views: |
| try: |
| m=load(view/'metainfo.json'); T=m['num_frames']; count+=1; frames_total+=T |
| assert isinstance(T,int) and T>0, 'invalid T' |
| assert m['sequence_id']==sequence.name and m['camera_id']==view.name, 'identity mismatch' |
| assert m['view_type'] in ('ego','exo','unknown'), 'view_type' |
| assert m['split'] in ('train','val','test','unknown'), 'split' |
| assert m['schema_version']=='hand-warehouse/1.0', 'schema_version' |
| frame_path=view/m['sampling']['frames_ref'] |
| frames=[json.loads(line) for line in frame_path.read_text().splitlines() if line.strip()] |
| assert len(frames)==T, 'frame count mismatch' |
| assert [r['frame_index'] for r in frames]==list(range(T)), 'frame_index' |
| assert all(r.get('source_frame_id') is not None for r in frames), 'source_frame_id missing' |
| assert len({str(r['source_frame_id']) for r in frames})==T, 'duplicate source IDs' |
| for key, rel in refs(m.get('components',{})): |
| p=(view/rel).resolve() |
| assert p.is_relative_to(release.resolve()), 'reference escapes release' |
| assert p.is_file(), 'missing reference '+rel |
| for name,c in m['components'].items(): |
| if not isinstance(c,dict) or not c.get('available',True): continue |
| rel=c.get('data_ref') |
| if not rel: continue |
| p=view/rel |
| if tensors and p.suffix=='.pt': |
| x=torch.load(p,map_location='cpu',weights_only=True) |
| assert isinstance(x,torch.Tensor), name+': not tensor' |
| if c.get('axes',[None])[0]=='T': assert x.shape[0]==T, name+': T' |
| valid_ref=c.get('valid_ref') |
| if valid_ref: |
| valid=torch.load(view/valid_ref,map_location='cpu',weights_only=True) |
| assert valid.dtype==torch.bool, name+': valid dtype' |
| assert valid.shape[0]==T, name+': valid T' |
| if x.is_floating_point(): |
| assert x.dtype==torch.float32, name+': float dtype' |
| mask=valid |
| while mask.ndim<x.ndim: mask=mask.unsqueeze(-1) |
| mask=mask.expand_as(x) |
| assert torch.isfinite(x[mask]).all(), name+': valid nonfinite' |
| if name=='extrinsic': |
| assert x.shape==(T,4,4), 'extrinsic shape' |
| R=x[:,:3,:3] |
| assert torch.allclose(R@R.transpose(1,2),torch.eye(3).expand(T,3,3),atol=1e-3), 'rotation orthogonality' |
| assert torch.allclose(torch.det(R),torch.ones(T),atol=1e-3), 'rotation determinant' |
| if media and p.suffix=='.mkv': |
| probe=json.loads(subprocess.check_output(['ffprobe','-v','error','-count_frames','-select_streams','v:0','-show_entries','stream=nb_read_frames,width,height','-of','json',str(p)]))['streams'][0] |
| assert int(probe['nb_read_frames'])==T, name+': media T' |
| assert [probe['width'],probe['height']]==m['camera']['image_size'], name+': media dimensions' |
| except Exception as exc: |
| errors.append(view.name+': '+str(exc)) |
| row={'sequence_id':sequence.name,'views':count,'frame_rows':frames_total,'errors':errors,'status':'failed' if errors else 'passed'} |
| results.append(row) |
| if output: |
| target=output/'sequences'/f'{sequence.name}.json'; target.parent.mkdir(parents=True,exist_ok=True) |
| target.write_text(json.dumps(row,indent=2)+'\n') |
| result={'scope':{'metadata_frame_mapping_references':True,'tensors':tensors,'media_decode_frame_count':media,'source_pixel_equivalence':False,'independent_official_digest':False},'sequences':len(results),'views':sum(x['views'] for x in results),'frame_rows':sum(x['frame_rows'] for x in results),'errors':[{'sequence':x['sequence_id'],'errors':x['errors']} for x in results if x['errors']]} |
| result['status']='failed' if result['errors'] else 'passed' |
| if output: |
| output.mkdir(parents=True,exist_ok=True); (output/'summary.json').write_text(json.dumps(result,indent=2)+'\n') |
| return result |
|
|
| if __name__=='__main__': |
| parser=argparse.ArgumentParser(description=__doc__) |
| parser.add_argument('--tensors',action='store_true') |
| parser.add_argument('--media',action='store_true') |
| parser.add_argument('--output',type=Path) |
| parser.add_argument('--sequence',help='Optional single sequence; default checks all sequences') |
| args=parser.parse_args() |
| result=check(Path(__file__).resolve().parent.parent,args.tensors,args.media,args.output,args.sequence) |
| print(json.dumps(result)); sys.exit(bool(result['errors'])) |
|
|
