| """Selective official benchmark examples. Run: prepare, download, render, package, publish. |
| The same implementation supports ReflexBench and DynamicVLA using the workspace name. |
| """ |
| from pathlib import Path |
| import ast, collections, concurrent.futures as cf, hashlib, io, json, math, shutil, subprocess, sys, time |
| from fractions import Fraction |
| import requests |
| from requests.adapters import HTTPAdapter |
| from urllib3.util.retry import Retry |
| import pyarrow as pa |
| import pyarrow.parquet as pq |
|
|
| ROOT=Path(__file__).resolve().parents[1] |
| NAME=json.loads((ROOT/'provenance/source.json').read_text(encoding='utf-8'))['benchmark'] if (ROOT/'provenance/source.json').exists() else ROOT.name |
| REFLEX=NAME=='ReflexBench' |
| REPO='cyx337/ReflexBench_dataset' if REFLEX else 'hzxie/DOM' |
| DEST=f'Travor278/{NAME}-Task-Examples' |
| WORK=ROOT/'work';OUT=ROOT if (ROOT/'provenance/source.json').exists() else ROOT/'dataset' |
| CODE=WORK/'official-code' |
| GITHUB='LxRoboticsLab/ReflexBench' if REFLEX else 'hzxie/DynamicVLA' |
| SESSION=requests.Session() |
| SESSION.mount('https://',HTTPAdapter(max_retries=Retry(total=4,backoff_factor=.6,status_forcelist=[429,500,502,503,504]))) |
|
|
| def read(p):return json.loads(p.read_text(encoding='utf-8')) |
| def write(p,x):p.parent.mkdir(parents=True,exist_ok=True);p.write_text(json.dumps(x,indent=2,ensure_ascii=False),encoding='utf-8') |
| def readable_instruction(meta): |
| obj=meta['objects'][0];obj_phrase=obj if obj.lower().startswith(('the ','all ')) else 'the '+obj |
| if meta['task']=='pick':return f'Pick up {obj_phrase}.' |
| container=meta.get('containers',['target container'])[0] |
| container_phrase=container if container.lower().startswith('the ') else 'the '+container |
| pronoun='them' if 'set of objects' in obj.lower() else 'it' |
| return f'Pick up {obj_phrase} and place {pronoun} in/on {container_phrase}.' |
| def url(p):return f'https://huggingface.co/datasets/{REPO}/resolve/{SOURCE_REV}/{p}' |
| def download_file(p,dst): |
| if dst.exists():return |
| dst.parent.mkdir(parents=True,exist_ok=True) |
| with SESSION.get(url(p),stream=True,timeout=(20,120)) as r: |
| r.raise_for_status() |
| with dst.with_suffix(dst.suffix+'.part').open('wb') as f: |
| for b in r.iter_content(1024*1024):f.write(b) |
| dst.with_suffix(dst.suffix+'.part').replace(dst) |
|
|
| class RangeReader(io.RawIOBase): |
| """Seekable HTTP range reader: no full video-shard download or hidden HF cache.""" |
| def __init__(self,path,size,block=262144): |
| self.path=path;self.size=size;self.block=block;self.pos=0;self.cache=collections.OrderedDict();self.transferred=0 |
| def readable(self):return True |
| def seekable(self):return True |
| def tell(self):return self.pos |
| def seek(self,offset,whence=0): |
| self.pos=offset if whence==0 else self.pos+offset if whence==1 else self.size+offset |
| if self.pos<0:raise ValueError('negative seek') |
| return self.pos |
| def read(self,n=-1): |
| if n<0:n=self.size-self.pos |
| n=min(n,self.size-self.pos);out=[] |
| while n>0: |
| index=self.pos//self.block |
| if index not in self.cache: |
| start=index*self.block;end=min(start+self.block,self.size)-1 |
| r=SESSION.get(url(self.path),headers={'Range':f'bytes={start}-{end}'},timeout=(20,90));r.raise_for_status() |
| if r.status_code!=206 or not r.headers.get('Content-Range','').startswith(f'bytes {start}-'): |
| raise ValueError('Source did not honor bounded HTTP range') |
| self.cache[index]=r.content;self.transferred+=len(r.content) |
| if len(self.cache)>24:self.cache.popitem(last=False) |
| b=self.cache[index];offset=self.pos%self.block;amount=min(n,len(b)-offset) |
| if amount<=0:raise EOFError('truncated HTTP range') |
| out.append(b[offset:offset+amount]);self.pos+=amount;n-=amount |
| return b''.join(out) |
|
|
| def lookup_jsonl(path,target,field,size): |
| """Locate a sorted metadata record using small byte ranges, retaining only matched rows.""" |
| low=0;high=size;low_id=0;high_id=(207306 if field=='episode_index' else 140932) |
| for attempt in range(22): |
| guess=int(low+(high-low)*max(0,min(1,(target-low_id)/max(1,high_id-low_id)))) |
| start=max(0,min(size-131072,guess-32768));end=min(size-1,start+131071) |
| r=SESSION.get(url(path),headers={'Range':f'bytes={start}-{end}'},timeout=60);r.raise_for_status();assert r.status_code==206 |
| raw=r.content;position=start;records=[] |
| for line in raw.splitlines(keepends=True): |
| try: |
| row=json.loads(line);records.append((row[field],position,row)) |
| except (ValueError,KeyError):pass |
| position+=len(line) |
| assert records |
| for index,pos,row in records: |
| if index==target:return row |
| if target<records[0][0]:high=records[0][1];high_id=records[0][0] |
| elif target>records[-1][0]:low=records[-1][1];low_id=records[-1][0] |
| else:raise ValueError(f'Missing official metadata record {field}={target}') |
| raise ValueError(f'Lookup failed: {path} {target}') |
|
|
| def keep_source(path): |
| dst=OUT/'reference'/path;dst.parent.mkdir(parents=True,exist_ok=True);shutil.copy2(CODE/path,dst) |
|
|
| def prepare(): |
| if all((OUT/'provenance'/name).exists() for name in ['source.json','tasks.json','samples.json']): |
| print('Using retained, source-pinned selected manifests; no new source metadata download is needed.',flush=True) |
| return |
| from huggingface_hub import HfApi |
| api=HfApi();info=api.dataset_info(REPO);global SOURCE_REV;SOURCE_REV=info.sha |
| code_rev=subprocess.check_output(['git','-C',str(CODE),'rev-parse','HEAD'],text=True).strip() |
| tasks=[];samples=[] |
| if REFLEX: |
| table=pq.read_table(WORK/'episodes-file-000.parquet') |
| columns=[c for c in table.column_names if not c.startswith('stats/')] |
| eps=table.select(columns).to_pylist();official=pq.read_table(WORK/'tasks.parquet').to_pylist() |
| keys=['ball_catching','conveyor_belt_pick_and_place','whack_a_mole','rolling_ball_interception','ball_throwing','rotating_peg_insertion'] |
| descriptions=['Catch a launched ball with a held container.','Pick from the moving conveyor and release into the bin.','Strike the active mole using the closed gripper during its popup window.','Intercept the ball or orange rolling down the ramp.','Throw the pre-grasped ball into the target bin.','Time peg insertion into the moving hole of a rotating disc.'] |
| rules=[ |
| 'Episode success is task_phase == 4. The ball must remain in the virtual catch zone below the end effector for the configured consecutive-step threshold.', |
| 'Success requires the object inside the bin in environment-local coordinates: x in [-0.2,0.2], y in [-0.6,-0.3], z in [0.0,0.08] m.', |
| 'Unified evaluation success is valid_hits > 0. A valid hit requires proximity to the active mole, closed gripper and the configured dwell. Current eval profile uses 2.0 s popup, 0.3 s gap, 0 s initial delay and 3.0 s evaluation length. Completing the window schedule alone is not success.', |
| 'Episode success is task_phase == 4. The rolling object must stay in the virtual catch zone for the configured hold threshold.', |
| 'Success is task_phase == 2, meaning the ball entered the target bin. Documentation bounds relative to bin center: |x-cx| <= 0.13, |y-cy| <= 0.09, z in [0.02,0.18] m.', |
| 'Success is task_phase == 4. Peg tip enters the hole within its radius tolerance, descends at least 0.02 m below the disc surface, and holds for at least 5 control steps (task README).'] |
| profiles_source=(CODE/'scripts/evaluation/task_profiles.py').read_text(encoding='utf-8') |
| profiles=next(ast.literal_eval(n.value) for n in ast.parse(profiles_source).body if isinstance(n,ast.AnnAssign) and getattr(n.target,'id','')=='TASK_PROFILES') |
| for item,key,desc,rule in zip(official,keys,descriptions,rules): |
| index=item['task_index'];local=[e for e in eps if e['tasks']==[item['task']]] |
| relative=f'source/reflexbench/reflexbench/tasks/manager_based/{key}/README.md' |
| task=dict(task_index=index,key=key,name=key.replace('_',' ').title(),category='Reaction-critical',instruction=item['task'],description=desc,success_rule=rule,profile=profiles[key],official_gym_id=profiles[key]['gym_id'],doc_url=f'https://github.com/{GITHUB}/blob/{code_rev}/{relative}',published_episode_count=len(local)) |
| tasks.append(task);keep_source(relative) |
| for j in [0,len(local)//2,len(local)-1]: |
| ep=local[j];eid=ep['episode_index'];views=[] |
| for camera,label in [('fixed_cam','FIXED CAMERA'),('wrist_cam','WRIST CAMERA')]: |
| prefix=f'videos/observation.images.{camera}' |
| path=f"{prefix}/chunk-{ep[prefix+'/chunk_index']:03d}/file-{ep[prefix+'/file_index']:03d}.mp4" |
| obj=api.get_paths_info(REPO,[path],repo_type='dataset',revision=SOURCE_REV)[0] |
| views.append(dict(camera=camera,label=label,path=f'media/{key}/episode_{eid:06d}/{camera}.mp4',source_path=path,source_bytes=obj.size,from_timestamp=ep[prefix+'/from_timestamp'],to_timestamp=ep[prefix+'/to_timestamp'])) |
| samples.append(dict(task_index=index,task_key=key,episode_index=eid,frame_count=ep['length'],fps=25,instruction=item['task'],metadata=ep,views=views,trajectory_path=f'trajectories/{key}/episode_{eid:06d}.parquet',composite_path=f'media/{key}/episode_{eid:06d}/synchronized.mp4',preview_path=f'media/{key}/episode_{eid:06d}/preview.jpg')) |
| for f in ['scripts/evaluation/task_profiles.py','scripts/data_collection/task_prompts.py']:keep_source(f) |
| shutil.copy2(WORK/'tasks.parquet',OUT/'provenance'/'official_tasks.parquet') |
| note='Six official task_index values 0–5. Single Franka arm; only fixed_cam and wrist_cam exist. Do not relabel the wrist as left/right. Success rules describe evaluation, not an unprovided per-demo score.' |
| else: |
| |
| windows={'long_horizon':['episode-window-0.json'], 'pick':['episode-window-0.08.json','episode-window-0.3.json','episode-window-0.42.json'],'place':['episode-window-0.54.json','episode-window-0.78.json','episode-window-0.999.json']} |
| selected=[] |
| for kind,files in windows.items(): |
| for filename in files: |
| xs=read(WORK/filename) |
| positions=[0,200,400,600,800,1000] if kind=='long_horizon' else [50,len(xs)-51] |
| selected.extend(xs[i] for i in positions) |
| for ep in selected: |
| eid=ep['episode_index'];path=f'data/chunk-{eid//1000:03d}/episode_{eid:06d}.parquet';local=WORK/f'episode_{eid:06d}.parquet';download_file(path,local);table=pq.read_table(local);ids=set(table['task_index'].to_pylist());assert len(ids)==1;index=ids.pop();assert set(table['episode_index'].to_pylist())=={eid};assert table.num_rows==ep['length'] |
| task_meta=lookup_jsonl('meta/tasks.jsonl',index,'task_index',63111962);assert task_meta['task']==ep['tasks'];meta=json.loads(ep['tasks']);kind=meta['task'];cam=lookup_jsonl('meta/camera.jsonl',eid,'episode_index',173353120) |
| obj=meta['objects'][0];container=meta.get('containers',[''])[0] |
| instruction=readable_instruction(meta) |
| |
| rule='Success requires object-to-end-effector distance < tolerance and end-effector-to-configured-goal distance < tolerance. The current default tolerance is 0.015 m; per-scene overrides may differ.' if kind=='pick' else 'Success requires ALL target objects to satisfy the container-relative geometric placement check, and the end effector to return within tolerance of the configured goal. Current default return tolerance is 0.015 m; per-scene overrides may differ.' |
| key=f'task_{index:06d}' |
| task=dict(task_index=index,key=key,name=f'{kind.replace("_"," ").title()} · {container if kind=="long_horizon" else obj}',category={'pick':'Pick','place':'Place','long_horizon':'Long-Horizon'}[kind],instruction=instruction,instruction_note='根据官方结构化 instruction 和首个别名确定性呈现；原记录没有保存采集时使用的具体随机语言变体，完整别名见下方元数据。',instruction_metadata=meta,description=f'Official DOM simulation scenario {cam["filename"]}. Object/container aliases are preserved in the metadata.',success_rule=rule,doc_url=f'https://github.com/{GITHUB}/blob/{code_rev}/simulations/configs/termination_cfg.py',source_filename=cam['filename'],published_episode_count=None) |
| if index not in {t['task_index'] for t in tasks}:tasks.append(task) |
| views=[dict(camera=c,label=label,path=f'media/{key}/episode_{eid:06d}/{c}.mp4',source_path=f'videos/chunk-{eid//1000:03d}/observation.images.{c}/episode_{eid:06d}.mp4') for c,label in [('opst_cam','OPPOSITE CAMERA'),('wrist_cam','WRIST CAMERA'),('side_cam','SIDE CAMERA')]] |
| samples.append(dict(task_index=index,task_key=key,episode_index=eid,frame_count=ep['length'],fps=25,instruction=instruction,instruction_metadata=meta,official_task_record=task_meta,camera_metadata=cam,source_filename=cam['filename'],views=views,trajectory_source_path=path,trajectory_path=f'trajectories/{key}/episode_{eid:06d}.parquet',composite_path=f'media/{key}/episode_{eid:06d}/synchronized.mp4',preview_path=f'media/{key}/episode_{eid:06d}/preview.jpg')) |
| print(f'Mapped {kind} task_index={index} episode_index={eid} ({cam["filename"]})',flush=True) |
| for f in ['simulations/configs/termination_cfg.py','utils/instruction_generator.py','simulations/helpers.py','simulations/configs/sim_cfg.yaml']:keep_source(f) |
| note='DOM has 3 task families, not 3 task_index values: 140,932 structured instruction IDs and 207,306 episodes. This subset selects 6 demonstrations per family (18 total), preserving actual task_index/episode_index and structured instructions. All 3 published cameras are single-arm cameras: opposite, wrist, side, not top/left/right arms.' |
| keep_source('LICENSE');keep_source('README.md') |
| shutil.copy2(CODE/'LICENSE',OUT/'LICENSE') |
| write(OUT/'provenance/tasks.json',tasks);write(OUT/'provenance/samples.json',samples) |
| source=dict(benchmark=NAME,repo_id=REPO,revision=SOURCE_REV,code_repository=GITHUB,code_revision=code_rev,note=note,date='2026-10-03',video_policy='Complete selected episodes, converted to browser-friendly H.264 MP4 at original 25 FPS. No generated simulation rollouts.',actual_episode_score='Not published in released LeRobot features; null, not assumed successful.',episode_selection='First/middle/last episode per official task' if REFLEX else 'Two episodes from three spaced metadata windows for pick/place, six spaced long-horizon scenarios.',camera_order=[v['camera'] for v in samples[0]['views']]) |
| write(OUT/'provenance/source.json',source);shutil.copy2(WORK/'info.json',OUT/'provenance/official_info.json');print(note,flush=True) |
|
|
| def encode_frames(frames,path): |
| import av |
| path.parent.mkdir(parents=True,exist_ok=True) |
| with av.open(str(path),'w') as output: |
| stream=None;count=0 |
| for frame in frames: |
| if stream is None: |
| stream=output.add_stream('libx264',rate=25);stream.width=frame.width;stream.height=frame.height;stream.pix_fmt='yuv420p';stream.options={'crf':'18','preset':'fast'} |
| frame=frame.reformat(format='yuv420p');frame.pts=count;frame.time_base=Fraction(1,25) |
| for packet in stream.encode(frame):output.mux(packet) |
| count+=1 |
| if stream is None:raise ValueError('No frames extracted') |
| for packet in stream.encode():output.mux(packet) |
| return count |
|
|
| def download(): |
| import av |
| source=read(OUT/'provenance/source.json');samples=read(OUT/'provenance/samples.json');summary=[] |
| if REFLEX: |
| path='data/chunk-000/file-000.parquet';download_file(path,WORK/'trajectories.parquet');data=pq.read_table(WORK/'trajectories.parquet') |
| for s in samples: |
| table=data.filter(pa.compute.equal(data['episode_index'],s['episode_index']));assert table.num_rows==s['frame_count'];assert set(table['task_index'].to_pylist())=={s['task_index']};target=OUT/s['trajectory_path'];target.parent.mkdir(parents=True,exist_ok=True);pq.write_table(table,target) |
| for view_index in range(2): |
| model=samples[0]['views'][view_index];reader=RangeReader(model['source_path'],model['source_bytes']);container=av.open(reader);stream=container.streams.video[0] |
| for s in sorted(samples,key=lambda s:s['episode_index']): |
| view=s['views'][view_index];target=OUT/view['path'] |
| if target.exists():continue |
| start=view['from_timestamp'];container.seek(int(start/stream.time_base),stream=stream,backward=True) |
| def frames(): |
| found=0 |
| for f in container.decode(stream): |
| if f.time+0.00001<start:continue |
| if found>=s['frame_count']:break |
| yield f;found+=1 |
| assert found==s['frame_count'],(s['episode_index'],found,s['frame_count']) |
| n=encode_frames(frames(),target);view['output_sha256']=hashlib.sha256(target.read_bytes()).hexdigest();print('Extracted',view['camera'],s['episode_index'],n,'frames',flush=True) |
| container.close();summary.append({'source_path':model['source_path'],'source_shard_size':reader.size,'range_bytes_received':reader.transferred}) |
| else: |
| def run(s): |
| cached_trajectory=WORK/f"episode_{s['episode_index']:06d}.parquet" |
| download_file(s['trajectory_source_path'],cached_trajectory) |
| target=OUT/s['trajectory_path'];target.parent.mkdir(parents=True,exist_ok=True);shutil.copy2(WORK/f"episode_{s['episode_index']:06d}.parquet",target) |
| for v in s['views']: |
| original=WORK/f"{s['episode_index']:06d}-{v['camera']}.mp4";download_file(v['source_path'],original) |
| dst=OUT/v['path'];dst.parent.mkdir(parents=True,exist_ok=True) |
| if not dst.exists(): |
| subprocess.run(['ffmpeg','-v','error','-y','-i',str(original),'-c:v','libx264','-crf','18','-preset','fast','-pix_fmt','yuv420p','-movflags','+faststart',str(dst)],check=True,capture_output=True) |
| v['source_sha256']=hashlib.sha256(original.read_bytes()).hexdigest();v['source_bytes']=original.stat().st_size;v['output_sha256']=hashlib.sha256(dst.read_bytes()).hexdigest() |
| print('Downloaded/transcoded',s['episode_index'],flush=True) |
| with cf.ThreadPoolExecutor(max_workers=4) as ex:list(ex.map(run,samples)) |
| summary=[dict(source_video_files=sum(len(s['views']) for s in samples),source_video_bytes=sum(v['source_bytes'] for s in samples for v in s['views']))] |
| write(OUT/'provenance/samples.json',samples);write(OUT/'provenance/download_report.json',dict(details=summary,whole_repo_downloaded=False,assets_downloaded=False,checkpoints_downloaded=False)) |
|
|
| def render(): |
| from PIL import Image,ImageDraw |
| samples=read(OUT/'provenance/samples.json');n=len(samples[0]['views']);labels=Image.new('RGB',(320*n,28),'#14251e');draw=ImageDraw.Draw(labels) |
| for i,v in enumerate(samples[0]['views']):draw.text((i*320+10,8),v['label'],fill='white') |
| label_path=WORK/'labels.png';labels.save(label_path) |
| def run(s): |
| target=OUT/s['composite_path'];target.parent.mkdir(parents=True,exist_ok=True) |
| if not target.exists(): |
| height=320 if REFLEX else 240;cmd=['ffmpeg','-v','error','-y'] |
| for v in s['views']:cmd+=['-i',str(OUT/v['path'])] |
| cmd+=['-loop','1','-i',str(label_path)] |
| filters=';'.join(f'[{i}:v]scale=320:{height},setsar=1[c{i}]' for i in range(n))+f';'+''.join(f'[c{i}]' for i in range(n))+f'hstack=inputs={n}[v];[{n}:v]format=yuv420p[l];[l][v]vstack=inputs=2:shortest=1[out]' |
| cmd+=['-filter_complex',filters,'-map','[out]','-c:v','libx264','-crf','21','-preset','fast','-pix_fmt','yuv420p','-frames:v',str(s['frame_count']),'-r','25','-movflags','+faststart',str(target)];subprocess.run(cmd,check=True,capture_output=True) |
| subprocess.run(['ffmpeg','-v','error','-y','-i',str(target),'-frames:v','1','-q:v','2',str(OUT/s['preview_path'])],check=True,capture_output=True) |
| with cf.ThreadPoolExecutor(max_workers=3) as ex:list(ex.map(run,samples)) |
| checks=[] |
| for s in samples: |
| table=pq.read_table(OUT/s['trajectory_path']);assert table.num_rows==s['frame_count'];assert set(table['task_index'].to_pylist())=={s['task_index']} |
| frames=[] |
| for path in [v['path'] for v in s['views']]+[s['composite_path']]: |
| r=json.loads(subprocess.check_output(['ffprobe','-v','error','-select_streams','v:0','-show_entries','stream=codec_name,width,height,nb_frames,duration','-of','json',str(OUT/path)],text=True))['streams'][0] |
| assert r['codec_name']=='h264' and int(r['nb_frames'])==s['frame_count'],(path,r,s['frame_count']);frames.append(dict(path=path,**r)) |
| checks.append(dict(task_index=s['task_index'],episode_index=s['episode_index'],videos=frames)) |
| write(OUT/'provenance/validation.json',dict(passed=True,episodes=len(samples),checks=checks));print('Verified full frame counts, task IDs and H.264 MP4:',len(samples),'episodes',flush=True) |
|
|
| def package(): |
| import yaml |
| from datasets import Dataset,Features,Value,Video,Image |
| tasks=read(OUT/'provenance/tasks.json');samples=read(OUT/'provenance/samples.json');source=read(OUT/'provenance/source.json');rows=[] |
| for s in samples: |
| t=next(t for t in tasks if t['task_index']==s['task_index']) |
| row=dict(task_index=s['task_index'],task_name=t['name'],category=t['category'],episode_index=s['episode_index'],synchronized= {'path':f'hf://datasets/{DEST}@main/'+s['composite_path'],'bytes':None}) |
| for v in s['views']:row[v['camera']]={'path':f'hf://datasets/{DEST}@main/'+v['path'],'bytes':None} |
| row.update(instruction=s['instruction'],instruction_metadata=json.dumps(s.get('instruction_metadata'),ensure_ascii=False),success_rule=t['success_rule'],actual_episode_success=None,frame_count=s['frame_count'],fps=25,duration_seconds=s['frame_count']/25,source_repo=REPO,source_revision=source['revision'],trajectory_url=f'https://huggingface.co/datasets/{DEST}/resolve/main/'+s['trajectory_path'],official_doc=t['doc_url'],source_filename=s.get('source_filename',''),camera_metadata=json.dumps(s.get('camera_metadata'),ensure_ascii=False)) |
| rows.append(row) |
| video_columns=['synchronized']+source['camera_order'];features=Features({k:Video(decode=False) if k in video_columns else Value('int64') if k in ['task_index','episode_index','frame_count','fps'] else Value('float64') if k=='duration_seconds' else Value('bool') if k=='actual_episode_success' else Value('string') for k in rows[0]}) |
| ds=Dataset.from_list(rows,features=features);(OUT/'data').mkdir(exist_ok=True);configs=[] |
| def subset(name,indices,default=False): |
| p=f'data/{name}.parquet';ds.select(indices).to_parquet(str(OUT/p),batch_size=32);entry=dict(config_name=name,data_files=[dict(split='examples',path=p)]) |
| if default:entry['default']=True |
| configs.append(entry) |
| subset('all',list(range(len(rows))),True) |
| for t in tasks:subset(f"task_{t['task_index']:06d}",[i for i,r in enumerate(rows) if r['task_index']==t['task_index']]) |
| for category in sorted({t['category'] for t in tasks}):subset(category.lower().replace('-','_'),[i for i,r in enumerate(rows) if r['category']==category]) |
| header=dict(language=['en','zh'],license='other',pretty_name=NAME+' Simulation Task Examples',configs=configs,tags=['robotics','video','simulation']) |
| if REFLEX:header.update(license_name='upstream-reflexbench-terms',license_link='LICENSE') |
| if not REFLEX:header.update(license_name='slab-license',license_link='LICENSE') |
| browser=f'https://travor278-{NAME.lower()}-task-examples.static.hf.space' |
| lines=['---',yaml.safe_dump(header,sort_keys=False,allow_unicode=True).rstrip(),'---',f'# {NAME} Simulation Task Examples',f'\n[打开 MP4 任务浏览页]({browser}/?task={tasks[0]["task_index"]})', '\n'+source['note'], |
| '\n所有示例是完整 H.264 MP4。单臂相机保留官方名称：'+ ' / '.join(source['camera_order'])+'。每条有同步合并视频、各路原视频与官方动作/状态 Parquet。', |
| '\n评估标准根据官方代码和文档整理；发布数据未保存逐条示教 success 标签，故 actual_episode_success 为 null。本文不编造 0–100 得分。', |
| '\n| 官方 task_index | Task / instruction scenario | 分类 | 直接浏览 |','|---|---|---|---|'] |
| for t in sorted(tasks,key=lambda t:t['task_index']):lines.append(f"| {t['task_index']} | {t['name']} | {t['category']} | [打开]({browser}/?task={t['task_index']}) |") |
| if REFLEX:lines.append('\nReflexBench 上游 episode 本身很短，多数选取记录只有约 1 秒。此处保持完整官方 length 和时间区间，没有人为截短、慢放或补帧。') |
| for t in tasks: |
| lines.extend([f"\n## task_index={t['task_index']} · {t['name']}",f"\n**Instruction:** {t['instruction']}",f"\n**Description:** {t['description']}",f"\n**Success / evaluation:** {t['success_rule']}",f"\n[官方说明]({t['doc_url']})"]) |
| if t.get('instruction_metadata'):lines.extend(['\n结构化原始 instruction（完整别名）：','\n```json',json.dumps(t['instruction_metadata'],ensure_ascii=False,indent=2),'```','\n'+t['instruction_note']]) |
| if t.get('official_gym_id'):lines.append(f"\n**Gym ID:** `{t['official_gym_id']}`") |
| for s in [s for s in samples if s['task_index']==t['task_index']]:lines.extend([f"\n**episode_index={s['episode_index']}** · {s['frame_count']} frames / {s['frame_count']/25:.2f} s",f"\n",f"\n[同步 MP4]({s['composite_path']}) · "+' · '.join(f"[{v['camera']} MP4]({v['path']})" for v in s['views'])+f" · [官方轨迹]({s['trajectory_path']})"]) |
| lines.extend(['\n## 来源、许可与复现',f'\n官方数据：[原仓库](https://huggingface.co/datasets/{REPO}) · 固定 revision `{source["revision"]}`。',f'\n官方代码：[GitHub](https://github.com/{GITHUB}) · revision `{source["code_revision"]}`。','\n保留上游 LICENSE 和来源文件在 `reference/`。ReflexBench 官方数据未单列许可证元数据；保留官方实现 BSD-3-Clause 来源，不扩大作者权利。' if REFLEX else '\n遵循上游 S-Lab License 1.0，仅允许非商业用途；见 LICENSE。','\n选择性提取记录、原始时间区间、task/episode 对应、相机元数据和校验均在 `provenance/`。不下载场景资产、模型权重或完整数据仓库。','\n复现脚本：`scripts/build_examples.py`。浏览页源码另见 `browser/` 和 `scripts/build_browser.py`。']) |
| (OUT/'README.md').write_text('\n'.join(lines)+'\n',encoding='utf-8');(OUT/'scripts').mkdir(exist_ok=True) |
| script_target=OUT/'scripts/build_examples.py' |
| if Path(__file__).resolve()!=script_target.resolve():shutil.copy2(__file__,script_target) |
| print('Packaged',len(rows),'rows,',len(configs),'native HF subsets',flush=True) |
|
|
| if __name__=='__main__': |
| WORK.mkdir(exist_ok=True);(OUT/'provenance').mkdir(parents=True,exist_ok=True) |
| if (OUT/'provenance/source.json').exists():SOURCE_REV=read(OUT/'provenance/source.json')['revision'] |
| globals()[sys.argv[1]]() |
|
|
