Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20260928T141133Z-catalog-cache-fix/diffusion/dataset/server_1/maintenance/ca21c3874df84b79/catalog.py

@@ -0,0 +1,143 @@
+"""Current paper catalogs derived only from the immutable baseline and latest chain."""
+from __future__ import annotations
+import base64,csv,datetime,hashlib,io,json,os,re,shlex,subprocess,tempfile
+from pathlib import Path
+from typing import Any
+PROJECT='pbisc-diffusion'
+ID=re.compile(r'[0-9]{8}T[0-9]{6}Z-[a-z0-9-]+\Z')
+NAMES=('CURRENT_MODEL_INDEX.csv','CURRENT_INFERENCE_LOCATIONS.csv','CURRENT_CATALOG.json')
+HF_PREFIX='paper-releases/pbisc-diffusion/'
+
+def read(path: Path) -> Any:
+ if path.is_symlink():raise ValueError('catalog_symlink_refused')
+ return json.loads(path.read_text())
+def sha(data: bytes) -> str:return hashlib.sha256(data).hexdigest()
+def atomic(path: Path,data: bytes) -> None:
+ if path.is_symlink():raise ValueError('catalog_symlink_refused')
+ with tempfile.NamedTemporaryFile(dir=path.parent,prefix='.catalog-',delete=False) as f:
+  tmp=Path(f.name);f.write(data);f.flush();os.fsync(f.fileno())
+ try:os.replace(tmp,path)
+ finally:tmp.unlink(missing_ok=True)
+def encoded(value: Any) -> bytes:return (json.dumps(value,indent=2,sort_keys=True,ensure_ascii=False)+'\n').encode()
+def csv_bytes(rows: list[dict[str,Any]], first: list[str]) -> bytes:
+ fields=first+sorted({k for row in rows for k in row}-set(first))
+ stream=io.StringIO(newline='');w=csv.DictWriter(stream,fieldnames=fields);w.writeheader()
+ for row in rows:w.writerow({k:json.dumps(v,sort_keys=True) if isinstance(v,(dict,list)) else v for k,v in row.items()})
+ return stream.getvalue().encode()
+def chain(root: Path,pointer: dict[str,Any]|None) -> list[tuple[Path,dict[str,Any]]]:
+ result=[];seen=set()
+ while pointer is not None:
+  identifier=pointer.get('id')
+  if pointer.get('project_id',PROJECT)!=PROJECT or not isinstance(identifier,str) or not ID.fullmatch(identifier) or identifier in seen:raise ValueError('invalid_catalog_history')
+  seen.add(identifier);folder=root/'maintenance/updates'/identifier
+  if folder.is_symlink():raise ValueError('catalog_symlink_refused')
+  path=folder/'UPDATE_VERIFIED.json';proof=read(path)
+  if sha(path.read_bytes())!=pointer.get('verified_receipt_sha256'):raise ValueError('catalog_proof_digest_mismatch')
+  if proof.get('status')!='PASS' or proof.get('project_id')!=PROJECT or proof.get('update_id')!=identifier:raise ValueError('catalog_wrong_project_or_state')
+  manifest=folder/'manifest.json'
+  if proof.get('schema')!='pbisc.diffusion.update-verified.v1' or not proof.get('manifest_sha256'):raise ValueError('catalog_unbound_proof')
+  if manifest.is_symlink() or sha(manifest.read_bytes())!=proof['manifest_sha256']:raise ValueError('catalog_manifest_digest_mismatch')
+  result.append((folder,proof));pointer=proof.get('parent_latest')
+ return list(reversed(result))
+def checked_metadata(folder: Path,proof: dict[str,Any],name: str,required: bool=True) -> dict[str,Any]:
+ path=folder/name
+ matches=[r for r in proof['assets'] if r.get('category')=='update_metadata' and r.get('source')==str(path)]
+ if not matches:
+  if required:raise ValueError('catalog_metadata_not_verified')
+  return {}
+ if len(matches)!=1 or path.is_symlink() or sha(path.read_bytes())!=matches[0]['sha256']:raise ValueError('catalog_metadata_digest_mismatch')
+ return read(path)
+def build(root: Path) -> tuple[dict[str,bytes],dict[str,Any]]:
+ reference=root/'maintenance/BASELINE_REFERENCE.json'
+ if reference.exists():
+  for name,digest in read(reference)['immutable_files'].items():
+   path=root/name
+   if Path(name).is_absolute() or '..' in Path(name).parts or path.is_symlink() or sha(path.read_bytes())!=digest:raise ValueError('frozen_baseline_changed')
+ latest=read(root/'LATEST.json') if (root/'LATEST.json').exists() else None
+ verified=chain(root,latest)
+ with (root/'MODEL_INDEX.csv').open(newline='') as f:models={(x['host'],x['source']):dict(x,project_id=PROJECT,catalog_version='paper-20260928') for x in csv.DictReader(f)}
+ locations={}
+ for filename in ['inference-locations.json','legacy-inference-locations.json']:
+  for row in read(root/filename)['entries']:
+   locations[row['host'],row['path']]=dict(row,project_id=PROJECT,catalog_version='paper-20260928',source_catalog=filename,sha256_basis='existing_receipt_not_fresh_output_hash')
+ for folder,proof in verified:
+  request=checked_metadata(folder,proof,'request.json',False)
+  details={(x['host'],x['source']):x for x in request.get('assets',[])}
+  for row in proof['assets']:
+   if row.get('category')!='checkpoint':continue
+   key=(row['host'],row['source']);old=models.get(key,{})
+   extra=details.get(key,{})
+   m=dict(old,host=row['host'],source=row['source'],sha256=row['sha256'],bytes=row['bytes'],category='checkpoint',state=row.get('state',''),bundle_path=row['bundle_path'],hf_repo=row['repo_id'],hf_path=row['remote_path'],hf_revision=row['hf_revision'],project_id=PROJECT,catalog_version=proof['update_id'])
+   for key2 in ['cohort','protocol','mode','parent_sha256']:m[key2]=extra.get(key2,m.get(key2,''))
+   m['hf_release_tag']='';m['hf_url']=f"https://huggingface.co/{row['repo_id']}/resolve/{row['hf_revision']}/{row['remote_path']}";models[key]=m
+  doc=checked_metadata(folder,proof,'inference_locations.json')
+  if doc.get('project_id')!=PROJECT or doc.get('update_id')!=proof['update_id']:raise ValueError('catalog_locator_identity_mismatch')
+  for row in doc['locations']:
+   key=row['host'],row['path'];entry=dict(locations.get(key,{}));entry.update(row)
+   entry.update(project_id=PROJECT,catalog_version=proof['update_id'],source_catalog=f'updates/{proof["update_id"]}/inference_locations.json',status=row['state'],sha256_basis=row.get('sha256_basis','existing_receipt_not_fresh_output_hash'))
+   locations[key]=entry
+ outputs={NAMES[0]:csv_bytes(sorted(models.values(),key=lambda x:(x.get('cohort',''),x['host'],x['source'])),['project_id','catalog_version','category','cohort','protocol','mode','state','host','source','sha256','hf_repo','hf_path','hf_revision','hf_url']),NAMES[1]:csv_bytes(sorted(locations.values(),key=lambda x:(x.get('cohort',''),x['host'],x['path'])),['project_id','catalog_version','cohort','experiment','host','path','status','sha256_basis','output_sha256','checkpoint_sha256','condition_sha256','generation_log','receipt'])}
+ meta={'schema':'pbisc-diffusion.current-catalog.v1','project_id':PROJECT,'generated_at':datetime.datetime.now(datetime.timezone.utc).isoformat(),'latest_id':latest.get('id') if latest else None,'baseline':'paper-20260928','models':len(models),'inference_locations':len(locations),'applied_updates':[proof['update_id'] for _,proof in verified],'files':{name:{'sha256':sha(data),'bytes':len(data)} for name,data in outputs.items()},'evidence_boundary':'Location states and output hashes come from recorded receipts/observations, not a new inference run or fresh hashing of large generated outputs.'}
+ outputs[NAMES[2]]=encoded(meta);return outputs,meta
+
+def mirror(outputs: dict[str,bytes],latest_id: str|None) -> None:
+ code='''import base64,hashlib,json,os,sys,tempfile
+from pathlib import Path
+r=Path('/home/sj_server_2/PBISC/paper-release-20260928');d=json.load(sys.stdin)
+assert d['project_id']=='pbisc-diffusion' and r.is_dir() and not r.is_symlink()
+p=r/'LATEST.json';current=json.loads(p.read_text()) if p.exists() else None
+assert (current.get('id') if current else None)==d['latest_id']
+allowed=['CURRENT_MODEL_INDEX.csv','CURRENT_INFERENCE_LOCATIONS.csv','CURRENT_CATALOG.json'];data={}
+assert sorted(d['files'])==sorted(allowed)
+for n,x in d['files'].items():
+ assert not (r/n).is_symlink();b=base64.b64decode(x['data']);assert hashlib.sha256(b).hexdigest()==x['sha256'];data[n]=b
+for n in allowed:
+ with tempfile.NamedTemporaryFile(dir=r,prefix='.catalog-',delete=False) as f:
+  f.write(data[n]);f.flush();os.fsync(f.fileno());tmp=f.name
+ os.replace(tmp,r/n)
+print(json.dumps({'files':len(data),'latest_id':d['latest_id']}))'''
+ request={'project_id':PROJECT,'latest_id':latest_id,'files':{n:{'data':base64.b64encode(b).decode(),'sha256':sha(b)} for n,b in outputs.items()}}
+ result=subprocess.run(['ssh','-o','BatchMode=yes','-o','ConnectTimeout=10','spark-0110',shlex.join(['python3','-B','-c',code])],input=json.dumps(request),text=True,capture_output=True)
+ if result.returncode:raise ValueError('catalog_remote_sync_failed')
+ reply=json.loads(result.stdout)
+ if reply.get('files')!=3 or reply.get('latest_id')!=latest_id:raise ValueError('catalog_remote_verification_failed')
+def publish_views(outputs: dict[str,bytes],latest: dict[str,Any]|None) -> str:
+ os.environ['HF_HUB_DISABLE_XET']='1';os.environ['HF_HUB_ENABLE_HF_TRANSFER']='0'
+ from huggingface_hub import HfApi,CommitOperationAdd,hf_hub_download,constants
+ constants.HF_HUB_ENABLE_HF_TRANSFER=False
+ api=HfApi(token=True);info=api.repo_info('junidude14/PBISC-data',repo_type='dataset',files_metadata=True)
+ if info.private is not True:raise ValueError('catalog_dataset_not_private')
+ current={x.rfilename:x for x in info.siblings}
+ if HF_PREFIX+'LATEST.json' in current:
+  p=hf_hub_download('junidude14/PBISC-data',HF_PREFIX+'LATEST.json',repo_type='dataset',revision=info.sha,token=True)
+  # HF's pinned download cache uses snapshot-to-blob symlinks. This is an SDK
+  # download, not a project source path; project reads retain the strict guard.
+  if json.loads(Path(p).read_text())!=latest:raise ValueError('catalog_hf_latest_changed')
+ elif latest is not None:raise ValueError('catalog_hf_latest_missing')
+ operations=[CommitOperationAdd(path_in_repo=HF_PREFIX+n,path_or_fileobj=io.BytesIO(b)) for n,b in outputs.items()]
+ result=api.create_commit('junidude14/PBISC-data',repo_type='dataset',parent_commit=info.sha,operations=operations,commit_message='Refresh PBISC-diffusion current model and inference catalogs',num_threads=2)
+ verified=api.repo_info('junidude14/PBISC-data',repo_type='dataset',revision=result.oid,files_metadata=True)
+ entries={x.rfilename:x for x in verified.siblings}
+ for name,data in outputs.items():
+  item=entries.get(HF_PREFIX+name)
+  if item is None or item.size!=len(data):raise ValueError('catalog_hf_size_mismatch')
+  if item.lfs:
+   if item.lfs.sha256!=sha(data):raise ValueError('catalog_hf_digest_mismatch')
+  elif item.blob_id!=hashlib.sha1(f'blob {len(data)}\0'.encode()+data).hexdigest():raise ValueError('catalog_hf_digest_mismatch')
+ return result.oid
+
+def refresh(root: Path,*,sync: bool=True) -> None:
+ outputs,meta=build(root)
+ # All source/proof checks finish before any live catalog is replaced.
+ for name in NAMES:atomic(root/name,outputs[name])
+ if sync:
+  latest=read(root/'LATEST.json') if (root/'LATEST.json').exists() else None
+  mirror(outputs,meta['latest_id']);revision=publish_views(outputs,latest)
+  atomic(root/'maintenance/CATALOG_SYNC.json',encoded({'project_id':PROJECT,'status':'PASS','latest_id':meta['latest_id'],'dataset_revision':revision,'files':meta['files']}))
+
+if __name__=='__main__':
+ import fcntl
+ root=Path(__file__).resolve().parent.parent
+ with (root/'maintenance/.writer.lock').open('a') as lock:
+  fcntl.flock(lock,fcntl.LOCK_EX|fcntl.LOCK_NB);refresh(root)
+ print('PBISC-diffusion current catalogs verified and synchronized')

paper-releases/pbisc-diffusion/updates/20260928T141133Z-catalog-cache-fix/diffusion/dataset/server_1/maintenance/eaf90a878c5f3647/test_catalog.py

@@ -0,0 +1,71 @@
+import csv,hashlib,importlib.util,json,tempfile,unittest
+from pathlib import Path
+
+PATH=Path(__file__).with_name('catalog.py')
+
+class CatalogTests(unittest.TestCase):
+ def setUp(self):
+  self.tmp=tempfile.TemporaryDirectory();self.root=Path(self.tmp.name)
+  self.addCleanup(self.tmp.cleanup)
+  with (self.root/'MODEL_INDEX.csv').open('w') as f:
+   f.write('host,source,sha256,category,hf_path\nserver_1,/m/base.pt,'+'a'*64+',checkpoint,old/base.pt\n')
+  for name,rows in [('inference-locations.json',[{'host':'server_1','path':'/m/out.npz','status':'completed_receipt_present'}]),('legacy-inference-locations.json',[{'host':'server_2','path':'/m/old.npz','status':'present_without_receipt'}])]:
+   (self.root/name).write_text(json.dumps({'entries':rows}))
+ def module(self):
+  self.assertTrue(PATH.is_file(),'catalog implementation is missing')
+  spec=importlib.util.spec_from_file_location('catalog_test_module',PATH);m=importlib.util.module_from_spec(spec);spec.loader.exec_module(m);return m
+ def add_update(self,identifier,*,parent=None,foreign=False):
+  folder=self.root/'maintenance/updates'/identifier;folder.mkdir(parents=True)
+  locations={'project_id':'pbisc-diffusion','update_id':identifier,'locations':[{'host':'server_1','path':'/m/new.npz','state':'running','presence':'present'}]}
+  p=folder/'inference_locations.json';p.write_text(json.dumps(locations))
+  assets=[{'host':'server_1','source':'/m/base.pt','category':'checkpoint','state':'final','sha256':'b'*64,'bytes':50,'repo_id':'junidude14/PBISC','remote_path':'updates/new/base.pt','bundle_path':'updates/new/base.pt','hf_revision':'c'*40}, {'host':'server_1','source':str(p),'category':'update_metadata','sha256':hashlib.sha256(p.read_bytes()).hexdigest()}]
+  manifest=folder/'manifest.json';manifest.write_text(json.dumps({'project_id':'pbisc-diffusion','update_id':identifier,'assets':assets}))
+  proof={'schema':'pbisc.diffusion.update-verified.v1','manifest_sha256':hashlib.sha256(manifest.read_bytes()).hexdigest(),'status':'PASS','project_id':'other-paper' if foreign else 'pbisc-diffusion','update_id':identifier,'parent_latest':parent,'assets':assets}
+  p=folder/'UPDATE_VERIFIED.json';p.write_text(json.dumps(proof));return {'id':identifier,'project_id':'pbisc-diffusion','verified_receipt_sha256':hashlib.sha256(p.read_bytes()).hexdigest(),'parent':parent}
+ def test_baseline_projection_preserves_frozen_sources(self):
+  before=(self.root/'MODEL_INDEX.csv').read_bytes();self.module().refresh(self.root,sync=False)
+  d=json.loads((self.root/'CURRENT_CATALOG.json').read_text());self.assertEqual(d['models'],1);self.assertEqual(d['inference_locations'],2);self.assertEqual((self.root/'MODEL_INDEX.csv').read_bytes(),before)
+ def test_only_reachable_verified_update_changes_latest_model_and_adds_locator(self):
+  self.add_update('20260928T010000Z-orphan')
+  pointer=self.add_update('20260928T020000Z-current');(self.root/'LATEST.json').write_text(json.dumps(pointer))
+  self.module().refresh(self.root,sync=False)
+  with (self.root/'CURRENT_MODEL_INDEX.csv').open() as f:rows=list(csv.DictReader(f))
+  self.assertEqual(len(rows),1);self.assertEqual(rows[0]['sha256'],'b'*64)
+  d=json.loads((self.root/'CURRENT_CATALOG.json').read_text());self.assertEqual(d['applied_updates'],[pointer['id']]);self.assertEqual(d['inference_locations'],3)
+  with (self.root/'CURRENT_INFERENCE_LOCATIONS.csv').open() as f:rows=list(csv.DictReader(f))
+  self.assertEqual(next(x for x in rows if x['path']=='/m/new.npz')['status'],'running')
+ def test_orphan_pass_is_not_promoted(self):
+  self.add_update('20260928T010000Z-orphan');self.module().refresh(self.root,sync=False)
+  d=json.loads((self.root/'CURRENT_CATALOG.json').read_text());self.assertEqual(d['applied_updates'],[]);self.assertEqual(d['inference_locations'],2)
+ def test_foreign_or_tampered_proof_refused_before_replacing_catalogs(self):
+  m=self.module();m.refresh(self.root,sync=False);before=(self.root/'CURRENT_CATALOG.json').read_bytes()
+  p=self.add_update('20260928T030000Z-foreign',foreign=True);(self.root/'LATEST.json').write_text(json.dumps(p))
+  with self.assertRaises(ValueError):m.refresh(self.root,sync=False)
+  self.assertEqual((self.root/'CURRENT_CATALOG.json').read_bytes(),before)
+ def test_hf_managed_cache_symlink_is_readable_without_relaxing_source_guard(self):
+  from types import SimpleNamespace
+  from unittest.mock import patch
+  import huggingface_hub
+  m=self.module();latest={'id':'20260928T020000Z-current','project_id':'pbisc-diffusion'}
+  blob=self.root/'blob';blob.write_text(json.dumps(latest));cache=self.root/'download-cache.json';cache.symlink_to(blob)
+  outputs={name:b'catalog content\n' for name in m.NAMES}
+  class Api:
+   def repo_info(self,*args,**kw):
+    if kw.get('revision')=='b'*40:
+     siblings=[SimpleNamespace(rfilename=m.HF_PREFIX+n,size=len(b),lfs=None,blob_id=hashlib.sha1(f'blob {len(b)}\0'.encode()+b).hexdigest()) for n,b in outputs.items()]
+    else:siblings=[SimpleNamespace(rfilename=m.HF_PREFIX+'LATEST.json')]
+    return SimpleNamespace(private=True,sha='a'*40,siblings=siblings)
+   def create_commit(self,*args,**kw):return SimpleNamespace(oid='b'*40)
+  with patch.object(huggingface_hub,'HfApi',return_value=Api()),patch.object(huggingface_hub,'hf_hub_download',return_value=str(cache)):
+   self.assertEqual(m.publish_views(outputs,latest),'b'*40)
+  with self.assertRaises(ValueError):m.read(cache)
+ def test_tampered_manifest_refused(self):
+  p=self.add_update('20260928T020000Z-current');(self.root/'LATEST.json').write_text(json.dumps(p))
+  (self.root/'maintenance/updates'/p['id']/'manifest.json').write_text('{}')
+  with self.assertRaises(ValueError):self.module().refresh(self.root,sync=False)
+ def test_tampered_locator_refused(self):
+  p=self.add_update('20260928T020000Z-current');(self.root/'LATEST.json').write_text(json.dumps(p))
+  (self.root/'maintenance/updates'/p['id']/'inference_locations.json').write_text('{}')
+  with self.assertRaises(ValueError):self.module().refresh(self.root,sync=False)
+
+if __name__=='__main__':unittest.main()

paper-releases/pbisc-diffusion/updates/20260928T141133Z-catalog-cache-fix/diffusion/metadata/inference_locations.json

@@ -0,0 +1,5 @@
+{
+  "locations": [],
+  "project_id": "pbisc-diffusion",
+  "update_id": "20260928T141133Z-catalog-cache-fix"
+}

paper-releases/pbisc-diffusion/updates/20260928T141133Z-catalog-cache-fix/diffusion/metadata/request.json

@@ -0,0 +1,19 @@
+{
+  "assets": [
+    {
+      "host": "server_1",
+      "kind": "maintenance",
+      "source": "/home/sj_server_1/PBISC/paper-release-20260928/maintenance/catalog.py",
+      "state": "completed"
+    },
+    {
+      "host": "server_1",
+      "kind": "maintenance",
+      "source": "/home/sj_server_1/PBISC/paper-release-20260928/maintenance/test_catalog.py",
+      "state": "completed"
+    }
+  ],
+  "inference_locations": [],
+  "project_id": "pbisc-diffusion",
+  "summary": "Fix current-catalog publication for Hugging Face managed cache symlinks while retaining local source symlink rejection. Completes the catalog refresh deferred by 20260928T140457Z-maintenance-bootstrap. No scientific artifact changes."
+}