Datasets:

myendless
/

action-repre-robotwin-v4-data

#!/usr/bin/env python3
"""Public HF release of the audited v4 data/weights. No source files are modified."""
from __future__ import annotations
import argparse, contextlib, csv, hashlib, json, os, random, re, shutil, subprocess, sys, tarfile, time
from collections import defaultdict
from datetime import datetime, timezone
from email.utils import parsedate_to_datetime
from pathlib import Path, PurePosixPath

ROOT=Path(__file__).resolve().parent
DEFAULT_INVENTORY=Path('/media/damoxing/ckp/final_experiment_inventory_20261023_v1')
RAW_ROOT=Path('/media/damoxing/datasets/RoboTwin2_0/dataset')
DEFAULT_TOKEN=Path('/media/damoxing/fileset/LVTA/hf_token')
LABELS={'base':'执行动作','lap':'文本动作','lvta':'图像轨迹','xtokenizer':'离散动作'}

def now():return datetime.now(timezone.utc).isoformat()
def read(path):return json.loads(Path(path).read_text())
def atomic(path,data):
 p=Path(path);p.parent.mkdir(parents=True,exist_ok=True);temp=p.with_name(p.name+'.tmp')
 temp.write_text(json.dumps(data,ensure_ascii=False,indent=2)+'\n');os.replace(temp,p)
def file_hash(path):
 h=hashlib.sha256()
 with Path(path).open('rb') as f:
  while chunk:=f.read(8*1024*1024):h.update(chunk)
 return h.hexdigest()
def fingerprint(obj):return hashlib.sha256(json.dumps(obj,ensure_ascii=False,sort_keys=True,separators=(',',':')).encode()).hexdigest()
def event(kind,**kwargs):
 row={'time':now(),'event':kind,**kwargs}
 print(json.dumps(row,ensure_ascii=False),flush=True)
 with (ROOT/'events.jsonl').open('a') as f:f.write(json.dumps(row,ensure_ascii=False)+'\n')

def retry(call,attempts=8,sleep=time.sleep):
 import requests
 for attempt in range(attempts):
  try:return call()
  except Exception as exc:
   response=getattr(exc,'response',None);code=getattr(response,'status_code',None)
   transient=code in (408,409,425,429) or (code is not None and code>=500) or isinstance(exc,(requests.ConnectionError,requests.Timeout,TimeoutError,ConnectionError))
   if not transient or attempt+1==attempts:raise
   delay=min(300,2**attempt)+random.uniform(1,2)
   header=response.headers.get('Retry-After') if response is not None else None
   if header:
    try:delay=max(delay,float(header))
    except ValueError:
     try:delay=max(delay,parsedate_to_datetime(header).timestamp()-time.time())
     except (ValueError,TypeError):pass
   sleep(delay)

def check_account(api,owner):
 actual=retry(api.whoami).get('name')
 if actual!=owner:raise ValueError(f'Authenticated account {actual!r} differs from expected account {owner!r}')
 return actual

def model_repo_name(owner,run_id,step):
 family='arx-core8' if run_id.startswith('core8_arx_') else 'aloha-core8' if run_id.startswith('core8_aloha_') else 'newtask14-n32' if run_id.startswith('new_task/') else 'newtask33' if run_id.startswith('new_task_source_') else 'composition6' if run_id.startswith('composition6_') else 'core8-history'
 rep=next((r for r in LABELS if re.search(r'(^|[_/])'+r+r'([_/#]|$)',run_id)), 'actiononly')
 role='source' if 'backbone' in run_id or 'source_' in run_id or 'repronly' in run_id else 'head'
 name=f'action-repre-{family}-{rep}-v4-j14-h32-{role}{step//1000}k-{hashlib.sha256(run_id.encode()).hexdigest()[:8]}'
 return owner+'/'+name[:96]

def entry(path,arcname):
 p=Path(path).resolve(strict=True);arc=PurePosixPath(arcname)
 if arc.is_absolute() or '..' in arc.parts or not arc.parts:raise ValueError('Unsafe archive path')
 st=p.stat()
 if not p.is_file():raise ValueError(f'Not a regular file: {p}')
 return {'path':str(p),'arcname':str(arc),'size':st.st_size,'mtime_ns':st.st_mtime_ns}

def validate_entry(e):
 st=Path(e['path']).stat()
 if st.st_size!=e['size'] or st.st_mtime_ns!=e['mtime_ns']:raise ValueError(f'Source changed since plan: {e["path"]}')

def pack_shards(entries,directory,limit=2*1024**3):
 directory=Path(directory);directory.mkdir(parents=True,exist_ok=True);unique={}
 for e in entries:
  validate_entry(e)
  if e['arcname'] in unique and unique[e['arcname']]!=e:raise ValueError('Conflicting archive member')
  unique[e['arcname']]=e
 groups=[];group=[];size=10240
 for e in sorted(unique.values(),key=lambda e:e['arcname']):
  added=((e['size']+511)//512)*512+2048
  if group and size+added>limit:groups.append(group);group=[];size=10240
  group.append(e);size+=added
 if group:groups.append(group)
 output=[]
 for i,group in enumerate(groups):
  dest=directory/f'raw-{i:05}.tar';seal=dest.with_suffix('.tar.seal.json');identity=fingerprint(group)
  if seal.exists():
   old=read(seal)
   if old['input_signature']!=identity:raise ValueError(f'Shard input plan changed: {dest}')
   if dest.exists() and dest.stat().st_size==old['size'] and file_hash(dest)==old['sha256']:
    output.append(old);continue
  temp=dest.with_suffix('.tar.partial')
  with tarfile.open(temp,'w',format=tarfile.PAX_FORMAT) as tar:
   for e in group:
    validate_entry(e);info=tarfile.TarInfo(e['arcname']);info.size=e['size'];info.mode=0o644;info.mtime=0;info.uid=info.gid=0
    with Path(e['path']).open('rb') as f:tar.addfile(info,f)
    validate_entry(e)
  os.replace(temp,dest)
  row={'path':str(dest),'sha256':file_hash(dest),'size':dest.stat().st_size,'members':len(group),'input_signature':identity}
  atomic(seal,row);output.append(row);event('shard_ready',index=i,**row)
 return output

def published_paths(folder):
 return sorted(str(p.relative_to(folder)) for p in folder.rglob('*') if p.is_file() and '.cache' not in p.parts and 'blobs' not in p.relative_to(folder).parts and not p.name.endswith(('.partial','.seal.json')))

def validate_checkpoint_claim(digest,claims):
 if claims and set(claims)!={digest}:raise ValueError('Checkpoint hash differs from audited identity')

def instruction_for(task,instructions,mode):
 if mode=='simplified':return str(task).replace('_',' ')
 if mode not in ('seen','unseen'):raise ValueError('Unknown instruction mode')
 return instructions[mode]

def build_plan(inventory,owner):
 inventory=Path(inventory).resolve(strict=True);training=read(inventory/'training_weights.json');known_weights=read(inventory/'weights.json');bydir={r['run_dir']:r for r in training};jobs=[]
 for value in (inventory/'selected_weight_paths.txt').read_text().splitlines():
  p=Path(value).resolve(strict=True);run=bydir[str(p.parent.parent)];match=re.search(r'steps_(\d+)',p.name);step=int(match[1]) if match else run['configured_steps']
  claims=sorted({h for w in known_weights if str(p) in w['aliases'] or str(p)==w['canonical_path'] for h in w['sha256_claims']})
  jobs.append({'recorded_sha256':claims,'repo_id':model_repo_name(owner,run['run_id']+'#'+p.parent.name+'/'+p.name,step),'run_id':run['run_id'],'step':step,'weight':entry(p,'model.pt'),'training':run})
 raw=[entry(r['realpath'],'raw/'+str(Path(r['realpath']).relative_to(RAW_ROOT))) for r in read(inventory/'raw_hdf5_files.json')]
 plan={'schema_version':1,'owner':owner,'public':True,'inventory':str(inventory),'dataset_repo':owner+'/action-repre-robotwin-v4-data','collection':read(ROOT/'collection.json'),'models':jobs,'raw_entries':raw,'shard_bytes':2*1024**3,'raw_bytes':sum(r['size'] for r in raw),'weight_bytes':sum(j['weight']['size'] for j in jobs)}
 plan['plan_sha256']=fingerprint(plan)
 path=ROOT/'upload_plan.json'
 if path.exists() and read(path)['plan_sha256']!=plan['plan_sha256']:raise ValueError('Upload plan changed; use a new delivery directory')
 atomic(path,plan);return plan

def load_token(path):
 token=Path(path).read_text().strip()
 if not token:raise ValueError('Empty project credential file')
 return token

def make_api(args):
 from huggingface_hub import HfApi
 return HfApi(token=load_token(args.token_file))

def configure_proxy(proxy):
 if not proxy:return
 from urllib.parse import urlsplit
 value=urlsplit(proxy)
 if value.scheme not in ('http','https') or not value.hostname or value.username or value.password:
  raise ValueError('Proxy must be an HTTP(S) URL without embedded credentials')
 for key in ('http_proxy','https_proxy','HTTP_PROXY','HTTPS_PROXY'):os.environ[key]=proxy

def stage_supplement(source,folder):
 """Publish a sealed, additive snapshot without changing the weight/data plan."""
 source=Path(source).resolve(strict=True);manifest=read(source/'snapshot.json')
 snapshot_id=manifest['snapshot_id']
 if not re.fullmatch(r'[A-Za-z0-9][A-Za-z0-9_.-]*',snapshot_id):raise ValueError('Unsafe snapshot ID')
 entries=manifest['files'];expected={e['path'] for e in entries}|{'snapshot.json'}
 actual={str(p.relative_to(source)) for p in source.rglob('*') if p.is_file()}
 if actual!=expected:raise ValueError('Snapshot contains missing or unlisted files')
 for e in entries:
  rel=PurePosixPath(e['path']);p=source/rel
  if rel.is_absolute() or '..' in rel.parts or not p.resolve().is_relative_to(source) or p.is_symlink():raise ValueError('Unsafe snapshot path')
  if p.stat().st_size!=e['size'] or file_hash(p)!=e['sha256']:raise ValueError('Snapshot file changed: '+str(p))
 dest=folder/'updates'/snapshot_id
 if dest.exists():
  if (dest/'snapshot.json').read_bytes()!=(source/'snapshot.json').read_bytes():raise ValueError('Snapshot identity already exists with different content')
  for name in expected:
   if not (dest/name).is_file() or file_hash(dest/name)!=file_hash(source/name):raise ValueError('Staged snapshot changed: '+name)
 else:
  dest.parent.mkdir(parents=True,exist_ok=True);shutil.copytree(source,dest)
 readme=folder/'README.md'
 with readme.open('a') as f:
  f.write(f'\n## 更新快照 {snapshot_id}\n\n最新训练核查、原生结果导出和文档见 [更新说明](updates/{snapshot_id}/README.md)。该快照独立于原始catalog；部分评测仍标为partial，不与完整结果合并排名。snapshot.json列出每个附加文件的SHA256。\n')
 return [str((dest/name).relative_to(folder)) for name in sorted(expected)]

def verify_supplement(api,repo,folder,paths):
 for start in range(0,len(paths),100):
  subset=paths[start:start+100];infos=retry(lambda:api.get_paths_info(repo_id=repo,repo_type='dataset',paths=subset));found={i.path:i for i in infos}
  for name in subset:
   p=folder/name;info=found.get(name)
   if info is None or info.size!=p.stat().st_size:raise ValueError('Remote snapshot file missing or wrong size: '+name)
   lfs=getattr(info,'lfs',None)
   if lfs:
    digest=lfs.get('sha256') if isinstance(lfs,dict) else getattr(lfs,'sha256',None)
    if digest!=file_hash(p):raise ValueError('Remote snapshot SHA256 mismatch: '+name)
   else:
    data=p.read_bytes();digest=hashlib.sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest()
    if getattr(info,'blob_id',None)!=digest:raise ValueError('Remote snapshot Git blob mismatch: '+name)

def blob_file(source,blobdir):
 source=Path(source);digest=file_hash(source);dest=blobdir/digest
 dest.parent.mkdir(parents=True,exist_ok=True)
 if not dest.exists():shutil.copyfile(source,dest)
 elif file_hash(dest)!=digest:raise ValueError('Corrupt content-addressed blob')
 return digest

def stage_metadata(plan):
 inventory=Path(plan['inventory']);folder=ROOT/'stage/data';folder.mkdir(parents=True,exist_ok=True);blobs=folder/'blobs';mapping={};views=[]
 def add(path):
  p=Path(path)
  if p.is_file():mapping[str(p)]=blob_file(p,blobs)
 for r in read(inventory/'unique_data_files.json'):
  for p in r['paths']:add(p)
 for name in ('final_results.json','final_results.csv','training_weights.json','datasets.json','dedup_summary.json','verification.json','data_overlaps.json'):
  src=inventory/name;dest=folder/'catalog'/name;dest.parent.mkdir(exist_ok=True);shutil.copyfile(src,dest)
 for j in plan['models']:
  run=Path(j['training']['run_dir'])
  for name in ('resolved.yaml','config.yaml','config.full.yaml','checkpoint_metadata.json','run_manifest.json','added_tokens.json','summary.jsonl'):add(run/name)
  for p in (run/'processor').rglob('*'):
   if p.is_file() and p.suffix in ('.json','.txt','.model','.yaml','.py') and p.stat().st_size<100*1024**2:add(p)
 for r in read(inventory/'final_results.json'):
  add(r['run_manifest'])
  for p in r['result_paths']:add(p)
  seed=r.get('seed_store_or_plan')
  if seed:
   p=Path(seed)
   if p.is_file():add(p)
   elif p.is_dir():
    for q in p.rglob('*.json'):
     if q.name not in ('owner.json','pending.json') and 'lock' not in str(q):add(q)
 for d in read(inventory/'datasets.json'):
  original=read(d['canonical_manifest']);eps=[]
  for ep in original['episodes']:
   row=dict(ep)
   for key in ('joint_hdf5','image_hdf5'):
    if row.get(key):row[key]='raw/'+str(Path(row[key]).relative_to(RAW_ROOT))
   # Exact historical instruction remains in the tiny original manifest blob; raw payload is never duplicated.
   eps.append(row)
  target=folder/'views'/f'{d["data_id"]}.json';atomic(target,{'data_id':d['data_id'],'original_manifest_sha256':d['manifest_sha256'],'episodes':eps});views.append(str(target.relative_to(folder)))
 idx=folder/'instructions.jsonl';temp=idx.with_suffix('.jsonl.partial')
 with temp.open('w') as f:
  for e in plan['raw_entries']:
   raw=Path(e['path']);source=raw.parent.parent/'instructions'/(raw.stem+'.json')
   if not source.exists():raise ValueError(f'Missing episode instructions: {source}')
   f.write(json.dumps({'hdf5':e['arcname'],'task':raw.parent.parent.parent.name,'instructions':read(source),'source_sha256':file_hash(source)},ensure_ascii=False,separators=(',',':'))+'\n')
 os.replace(temp,idx)
 support=pack_shards([entry(p,'blobs/'+p.name) for p in sorted(blobs.iterdir())],folder/'support',2*1024**3)
 atomic(folder/'support_shards.json',[{**r,'path':'support/'+Path(r['path']).name} for r in support])
 atomic(folder/'local_to_blob.json',mapping)
 atomic(folder/'dataset_manifest.json',{'plan_sha256':plan['plan_sha256'],'raw_files':len(plan['raw_entries']),'raw_bytes':plan['raw_bytes'],'views':views,'instructions':'instructions.jsonl','short_instruction_rule':'task.replace("_", " ")','dataset_root':'raw','raw_shards':'shards/raw-*.tar','original_manifest_identity':'blobs/<SHA256>'})
 shutil.copyfile(__file__,folder/'upload_release.py')
 (folder/'README.md').write_text('---\ntask_categories:\n- robotics\nlanguage:\n- en\n- zh\ntags:\n- robotwin\n- action-representation\n---\n\n# 动作表征基准：去重原始数据与实验索引\n\n原始HDF5只存一份，按约2 GiB无压缩tar分片；同一episode不因表征、训练阶段或指令模式重复上传。完整seen/unseen指令在instructions.jsonl；简化任务名由upload_release.instruction_for生成。不是把hdf5强行转换为其他格式。\n\nviews保留各训练输入视图；support/*.tar中的blobs按SHA256存原始manifest、norm、processor、配置与结果证据。修改RGB/文本协议不能把两个manifest身份合并。原始路径只作溯源；下载后运行upload_release.py restore --data-dir <下载目录> --destination <解包目录>重建可读manifest路径。\n\n正式评测、历史source准入与Legacy结果分别记录；catalog/final_results.json列出完整结果。训练预算30k/10k与旧20k source差异保留。数据和模型均沿用原始来源的许可约束，本索引不为原始资产另行赋予许可。\n')
 return folder,mapping

def stage_model(job,data_repo,mapping):
 folder=ROOT/'stage/models'/job['repo_id'].split('/')[1];folder.mkdir(parents=True,exist_ok=True);weight=job['weight'];validate_entry(weight);dest=folder/'model.pt'
 if not dest.exists():
  try:os.link(weight['path'],dest)
  except OSError:os.symlink(weight['path'],dest)
 if not dest.samefile(weight['path']):raise ValueError('Staged model does not match original')
 tr=job['training'];run=Path(tr['run_dir']);meta={'plan_sha256':read(ROOT/'upload_plan.json')['plan_sha256'],'original_run_id':tr['run_id'],'original_weight':weight['path'],'step':job['step'],'classification':tr['classification'],'training_protocol_sha256':tr['protocol_sha256'],'data_repo':data_repo,'data_id':tr['data_id'],'manifest_sha256':tr['manifest_sha256'],'norm_sha256':tr['norm_sha256'],'source_checkpoint':tr['source_checkpoint'],'init_checkpoint':tr['init_checkpoint'],'support_files':{p:h for p,h in mapping.items() if str(Path(p)).startswith(str(run)+'/')},'data_manifest_blob':mapping[tr['data_manifest']],'norm_blob':mapping[tr['norm']]}
 atomic(folder/'release.json',meta)
 label=tr['representation_label'];label='历史action-only对照' if 'raw' in tr['run_id'] else label
 (folder/'README.md').write_text(f'---\ntags:\n- robotics\n- action-representation\n- qwenpi-v4\n---\n\n# {label}：{job["repo_id"].split("/")[1]}\n\n原始checkpoint、严格v4 joint14/H32；实际步数{job["step"]}，来源类别{tr["classification"]}。\n\n完整PyTorch训练checkpoint保持原字节；不是Transformers AutoModel标准导出，须使用本benchmark加载器。数据、norm、processor及原始训练配置按SHA256引用共享数据仓库[{data_repo}](https://huggingface.co/datasets/{data_repo})；release.json包含精确映射。\n\nsource checkpoint：`{tr["source_checkpoint"]}`。原始run：`{tr["run_id"]}`。\n\n图像轨迹ARX历史source准入、离散动作外部tokenizer/词嵌入保护及旧20k source/输入差异均按catalog中的实际记录披露；不能将这些结果当成相同来源的单变量排名。\n')
 return folder

def ensure_remote(api,repo,repo_type,collection,folder):
 retry(lambda:api.create_repo(repo_id=repo,repo_type=repo_type,private=False,exist_ok=True))
 info=retry(lambda:api.repo_info(repo_id=repo,repo_type=repo_type))
 if info.private:raise ValueError(f'Refusing to change visibility of pre-existing private repo: {repo}')
 # A real small commit checks write permission before the SDK's indefinite inner retries.
 retry(lambda:api.upload_file(path_or_fileobj=str(folder/'README.md'),path_in_repo='README.md',repo_id=repo,repo_type=repo_type,commit_message='Add audited release description'))
 retry(lambda:api.add_collection_item(collection_slug=collection,item_id=repo,item_type=repo_type,exists_ok=True))

def upload_worker(args):
 api=make_api(args);check_account(api,args.owner)
 api.upload_large_folder(repo_id=args.repo,repo_type=args.repo_type,folder_path=str(args.folder),num_workers=args.workers,print_report_every=60,ignore_patterns=['blobs/**','*.partial','*.seal.json','**/*.partial','**/*.seal.json'])

def supervised_upload(args,repo,repo_type,folder):
 logfile=ROOT/'logs'/(repo.replace('/','--')+'.log');logfile.parent.mkdir(exist_ok=True)
 for attempt in range(args.attempts):
  event('upload_attempt',repo=repo,attempt=attempt+1,log=str(logfile));last_signature=None;last_change=time.time()
  command=[sys.executable,str(Path(__file__).resolve()),'_worker','--owner',args.owner,'--token-file',str(args.token_file),'--repo',repo,'--repo-type',repo_type,'--folder',str(folder),'--workers',str(args.workers)]
  with logfile.open('a') as log:
   log_start=logfile.stat().st_size
   child=subprocess.Popen(command,stdout=log,stderr=subprocess.STDOUT,env=os.environ.copy())
   try:
    while child.poll() is None:
     time.sleep(10)
     metas=list((folder/'.cache/huggingface').rglob('*.metadata')) if (folder/'.cache/huggingface').exists() else []
     signature=tuple((str(p),p.stat().st_size,p.stat().st_mtime_ns) for p in sorted(metas))
     if signature!=last_signature:last_signature=signature;last_change=time.time()
     with logfile.open('rb') as f:
      f.seek(max(log_start,logfile.stat().st_size-16000));tail=f.read().decode(errors='replace')
     if re.search(r'(400|401|402|403|404|413|422) Client Error|Repository storage limit reached|exceeded.*(?:quota|storage)|(?:quota|storage).*exceeded|Payment Required|Invalid user token',tail,re.I):
      raise PermissionError(f'Permanent Hub permission/storage error; see {logfile}')
     if time.time()-last_change>args.stall_seconds:raise TimeoutError(f'No persisted upload progress for {args.stall_seconds}s')
    if child.returncode==0:return
    raise ConnectionError(f'Upload worker exited {child.returncode}; see {logfile}')
   except PermissionError:
    if child.poll() is None:child.terminate();child.wait(timeout=30)
    raise
   except (ConnectionError,TimeoutError) as exc:
    if child.poll() is None:child.terminate();child.wait(timeout=30)
    event('upload_retry',repo=repo,error=str(exc))
    if attempt+1==args.attempts:raise
    time.sleep(min(300,2**attempt*10)+random.random())
   finally:
    if child.poll() is None:child.terminate();child.wait(timeout=30)

def verify_remote(api,repo,repo_type,folder,required=None):
 paths=required or published_paths(folder)
 for start in range(0,len(paths),100):
  subset=paths[start:start+100];infos=retry(lambda:api.get_paths_info(repo_id=repo,repo_type=repo_type,paths=subset))
  found={i.path:i for i in infos}
  for path in subset:
   if path not in found or found[path].size!=(folder/path).stat().st_size:raise ValueError(f'Remote file missing or wrong size: {repo}/{path}')
 return True

def run_release(args):
 import fcntl
 lock=(ROOT/'runner.lock').open('w');fcntl.flock(lock,fcntl.LOCK_EX|fcntl.LOCK_NB)
 api=make_api(args);check_account(api,args.owner);plan=build_plan(args.inventory,args.owner);statepath=ROOT/'state.json';state=read(statepath) if statepath.exists() else {'plan_sha256':plan['plan_sha256'],'completed':{},'hashes':{},'aliases':{}}
 if state['plan_sha256']!=plan['plan_sha256']:raise ValueError('State belongs to another plan')
 folder,mapping=stage_metadata(plan);collection=plan['collection']['slug'];datarepo=plan['dataset_repo']
 supplement_paths=stage_supplement(args.supplement,folder) if args.supplement else []
 ensure_remote(api,datarepo,'dataset',collection,folder)
 # Publish only small shared indexes first; raw tar payloads are added after model jobs.
 retry(lambda:api.upload_folder(repo_id=datarepo,repo_type='dataset',folder_path=str(folder),ignore_patterns=['blobs/**','shards/**','.cache/**','*.partial','**/*.partial','**/*.seal.json'],commit_message='Add deduplicated data views and audited provenance'))
 event('metadata_uploaded',repo=datarepo)
 if supplement_paths:
  verify_supplement(api,datarepo,folder,supplement_paths)
  state['latest_supplement']={'source':str(args.supplement),'files':len(supplement_paths),'verified_at':now()};atomic(statepath,state)
  event('supplement_uploaded',repo=datarepo,**state['latest_supplement'])
 for job in plan['models']:
  key=job['repo_id'];e=job['weight'];validate_entry(e)
  if key in state['completed']:
   previous=state['completed'][key];canonical=previous.get('canonical_repo',key)
   remote=retry(lambda:api.get_paths_info(repo_id=canonical,repo_type='model',paths=['model.pt']))
   if remote and remote[0].size==e['size']:
    lfs=getattr(remote[0],'lfs',None);remote_sha=(lfs.get('sha256') if isinstance(lfs,dict) else getattr(lfs,'sha256',None)) if lfs else None
    if remote_sha and remote_sha!=previous['sha256']:raise ValueError('Completed remote checkpoint hash changed')
    event('skip_completed_model',repo=key,remote_verified=True);continue
   del state['completed'][key];atomic(statepath,state)
  sig=fingerprint(e);digest=state['hashes'].get(sig)
  if not digest:
   event('hashing_model',repo=key,bytes=e['size']);digest=file_hash(e['path']);validate_entry(e);validate_checkpoint_claim(digest,job['recorded_sha256']);state['hashes'][sig]=digest;atomic(statepath,state)
  validate_checkpoint_claim(digest,job['recorded_sha256'])
  if digest in state['aliases']:
   state['completed'][key]={'status':'same_checkpoint_bytes','canonical_repo':state['aliases'][digest],'sha256':digest};atomic(statepath,state);event('deduplicated_model',repo=key,canonical=state['aliases'][digest]);continue
  model=stage_model(job,datarepo,mapping);release=read(model/'release.json');release['weight_sha256']=digest;atomic(model/'release.json',release)
  ensure_remote(api,key,'model',collection,model);supervised_upload(args,key,'model',model);verify_remote(api,key,'model',model,['model.pt','release.json','README.md'])
  info=retry(lambda:api.get_paths_info(repo_id=key,repo_type='model',paths=['model.pt']))[0]
  lfs=getattr(info,'lfs',None);remotehash=(lfs.get('sha256') if isinstance(lfs,dict) else getattr(lfs,'sha256',None)) if lfs else None
  if remotehash and remotehash!=digest:raise ValueError(f'Remote model SHA256 mismatch: {key}')
  state['aliases'][digest]=key;state['completed'][key]={'status':'uploaded','sha256':digest,'remote_sha256':remotehash,'verified_at':now()};atomic(statepath,state);event('model_uploaded',repo=key,sha256=digest)
 if state['completed'].get(datarepo,{}).get('status')=='uploaded':
  verify_remote(api,datarepo,'dataset',folder)
 else:
  shards=pack_shards(plan['raw_entries'],folder/'shards',plan['shard_bytes']);atomic(folder/'shards.json',[{**r,'path':'shards/'+Path(r['path']).name} for r in shards])
  supervised_upload(args,datarepo,'dataset',folder);verify_remote(api,datarepo,'dataset',folder)
  for row in shards:
   path='shards/'+Path(row['path']).name
   info=retry(lambda:api.get_paths_info(repo_id=datarepo,repo_type='dataset',paths=[path]))[0]
   lfs=getattr(info,'lfs',None);remote_sha=(lfs.get('sha256') if isinstance(lfs,dict) else getattr(lfs,'sha256',None)) if lfs else None
   if remote_sha and remote_sha!=row['sha256']:raise ValueError('Remote shard SHA256 mismatch: '+path)
  state['completed'][datarepo]={'status':'uploaded','verified_at':now(),'raw_files':len(plan['raw_entries']),'shards':len(shards)};atomic(statepath,state)
 event('release_complete',collection=plan['collection']['url'],completed=len(state['completed']))

def restore(data_dir,destination):
 data_dir=Path(data_dir);destination=Path(destination).resolve()
 if not (data_dir/'shards.json').exists() or not (data_dir/'support_shards.json').exists():raise ValueError('Dataset upload/download is not complete: missing shard indexes')
 raw=read(data_dir/'shards.json');support=read(data_dir/'support_shards.json');manifest=read(data_dir/'dataset_manifest.json')
 if sum(r['members'] for r in raw)!=manifest['raw_files']:raise ValueError('Dataset shard membership is not complete')
 for row in support+raw:
  rel=PurePosixPath(row['path'])
  if rel.is_absolute() or '..' in rel.parts:raise ValueError('Unsafe shard path')
  path=data_dir/row['path']
  if not path.exists() or file_hash(path)!=row['sha256']:raise ValueError('Dataset download is not complete or shard checksum differs: '+str(path))
 destination.mkdir(parents=True,exist_ok=True)
 for p in [data_dir/r['path'] for r in support+raw]:
  with tarfile.open(p) as tar:
   for member in tar:
    rel=PurePosixPath(member.name)
    if rel.is_absolute() or '..' in rel.parts or not member.isfile():raise ValueError('Unsafe archive member')
    out=destination/str(rel);out.parent.mkdir(parents=True,exist_ok=True)
    if out.exists() and out.stat().st_size==member.size:continue
    with tar.extractfile(member) as src,out.with_suffix(out.suffix+'.partial').open('wb') as f:shutil.copyfileobj(src,f,8*1024**2)
    os.replace(out.with_suffix(out.suffix+'.partial'),out)
 for path in (data_dir/'views').glob('*.json'):
  view=read(path)
  for ep in view['episodes']:
   for key in ('joint_hdf5','image_hdf5'):
    if ep.get(key):ep[key]=str(destination/ep[key])
  atomic(destination/'views'/path.name,view)
 shutil.copyfile(data_dir/'instructions.jsonl',destination/'instructions.jsonl')

def main():
 parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('command',choices=['plan','run','status','restore','_worker']);parser.add_argument('--inventory',type=Path,default=DEFAULT_INVENTORY);parser.add_argument('--owner',default='myendless');parser.add_argument('--token-file',type=Path,default=DEFAULT_TOKEN);parser.add_argument('--workers',type=int,default=2);parser.add_argument('--attempts',type=int,default=8);parser.add_argument('--stall-seconds',type=int,default=3600);parser.add_argument('--repo');parser.add_argument('--repo-type');parser.add_argument('--folder',type=Path);parser.add_argument('--data-dir',type=Path);parser.add_argument('--destination',type=Path);parser.add_argument('--proxy',help='HTTP(S) proxy, inherited by upload workers');parser.add_argument('--supplement',type=Path,help='Sealed additive metadata snapshot');args=parser.parse_args()
 configure_proxy(args.proxy)
 os.environ.setdefault('HF_XET_CACHE',str(ROOT/'cache/xet'));os.environ['HF_HUB_ENABLE_HF_TRANSFER']='0'
 if args.command=='plan':
  p=build_plan(args.inventory,args.owner);print(json.dumps({k:p[k] for k in ('owner','public','dataset_repo','raw_bytes','weight_bytes','plan_sha256')},ensure_ascii=False));print('model_jobs',len(p['models']),'raw_files',len(p['raw_entries']))
 elif args.command=='run':run_release(args)
 elif args.command=='_worker':upload_worker(args)
 elif args.command=='restore':restore(args.data_dir,args.destination)
 else:
  state=read(ROOT/'state.json') if (ROOT/'state.json').exists() else {};print(json.dumps({'collection':read(ROOT/'collection.json'),'completed':state.get('completed',{}),'events_tail':(ROOT/'events.jsonl').read_text().splitlines()[-5:] if (ROOT/'events.jsonl').exists() else []},ensure_ascii=False,indent=2))

if __name__=='__main__':main()