| |
| """Mirror B1K code and rollout results from Centre into this folder, re-runnable. |
| |
| Each source in SOURCES is rsynced (no --delete: files removed remotely are kept |
| locally and flagged in the inventory). Full-state trajectory HDF5 files are |
| ~3.6 GB each, so only those of runs marked `training_eligible` in the source's |
| reports/*.json (plus EXTRA_HDF5 globs) are copied; every other file is listed in |
| _sync/REMOTE_INVENTORY.tsv with its size, so nothing is silently missing. |
| |
| Every copied file is verified against a SHA-256 computed on Centre. Hashes are |
| cached by (size, mtime), so re-runs only hash new or changed files. |
| |
| Usage: |
| python3 sync/sync_centre.py # sync all sources |
| python3 sync/sync_centre.py --dry-run # show what would transfer |
| python3 sync/sync_centre.py --source task01_human_first_recovery |
| """ |
| import argparse |
| import hashlib |
| import json |
| import os |
| import shlex |
| import subprocess |
| import sys |
| from datetime import datetime, timezone |
| from pathlib import Path |
|
|
| ROOT = Path(__file__).resolve().parent.parent |
| HOST = "centre" |
|
|
| SOURCES = [ |
| { |
| "name": "task01_human_first_recovery", |
| "remote": "/media/david/HDD/gpt6_b1k/task01_human_first_recovery", |
| "dest": "task01_picking_up_trash/centre_human_first_recovery", |
| |
| |
| "exclude": ["/appdata/", "/datasets/human/rawdata/", "/campaigns/", ".pytest_cache/", "__pycache__/"], |
| "hdf5_eligible_from": "reports", |
| "extra_hdf5": [], |
| }, |
| { |
| "name": "task01_demo_continuation", |
| "remote": "/media/david/HDD/gpt6_b1k/task01_demo_continuation", |
| "dest": "task01_picking_up_trash/centre_demo_continuation", |
| "exclude": [], |
| "hdf5_eligible_from": None, |
| "extra_hdf5": [], |
| }, |
| { |
| "name": "task01_recovery_primitive_filtered_20260921", |
| "remote": "/media/david/HDD/task01_recovery_primitive_filtered_20260921", |
| "dest": "task01_picking_up_trash/datasets/task01_recovery_primitive_filtered_20260921", |
| "exclude": ["__pycache__/"], |
| "copy_all_hdf5": True, |
| }, |
| { |
| "name": "task01_vla_failure_recovery_20260918", |
| "remote": "/media/david/HDD/gpt6_b1k/task01_human_first_recovery/campaigns/vla_failure_recovery_20260918", |
| "dest": "task01_picking_up_trash/centre_human_first_recovery/campaigns/vla_failure_recovery_20260918", |
| "exclude": ["__pycache__/", ".pytest_cache/", "/state/", "/merge_test_20260919/"], |
| "copy_all_hdf5": True, |
| "snapshot_completed": True, |
| }, |
| ] |
|
|
|
|
| def ssh(cmd, stdin=None): |
| return subprocess.run(["ssh", "-o", "BatchMode=yes", HOST, cmd], input=stdin, |
| capture_output=True, check=True).stdout |
|
|
|
|
| def remote_inventory(src): |
| prune = " -o ".join(f"-path ./{e.strip('/')}" for e in src["exclude"] if e.startswith("/")) |
| names = " -o ".join(f"-name {e.strip('/')}" for e in src["exclude"] if not e.startswith("/")) |
| skip = " -o ".join(x for x in (prune, names) if x) |
| expr = f"\\( {skip} \\) -prune -o " if skip else "" |
| out = ssh(f"cd {shlex.quote(src['remote'])} && find . {expr}-type f -printf '%P\\t%s\\t%T@\\n'") |
| inv = {} |
| for line in out.decode().splitlines(): |
| path, size, mtime = line.split("\t") |
| inv[path] = (int(size), int(float(mtime))) |
| return inv |
|
|
|
|
| def eligible_hdf5(src, inv): |
| """HDF5 files inside runs that any reports/*.json marks training_eligible.""" |
| wanted = set() |
| if src["hdf5_eligible_from"]: |
| script = f""" |
| import json, glob |
| runs = set() |
| def walk(o): |
| if isinstance(o, dict): |
| if o.get('training_eligible') is True and isinstance(o.get('run'), str): |
| runs.add(o['run']) |
| for v in o.values(): walk(v) |
| elif isinstance(o, list): |
| for v in o: walk(v) |
| for f in glob.glob('{src['hdf5_eligible_from']}/**/*.json', recursive=True): |
| try: walk(json.load(open(f))) |
| except Exception: pass |
| print('\\n'.join(sorted(runs))) |
| """ |
| out = ssh(f"cd {shlex.quote(src['remote'])} && python3 -", stdin=script.encode()) |
| prefix = src["remote"].rstrip("/") + "/" |
| runs = [r[len(prefix):] if r.startswith(prefix) else r for r in out.decode().split()] |
| for path in inv: |
| if path.endswith(".hdf5") and any(path.startswith(r.rstrip("/") + "/") for r in runs): |
| wanted.add(path) |
| for pattern in src["extra_hdf5"]: |
| wanted.update(p for p in inv if Path(p).match(pattern)) |
| return wanted |
|
|
|
|
| def rsync(src, dest, extra, dry): |
| cmd = ["rsync", "-a", "--partial", "--info=stats1,progress2", "--no-inc-recursive"] |
| cmd += ["--dry-run"] if dry else [] |
| cmd += [f"--exclude={e}" for e in src["exclude"]] + extra |
| cmd += [f"{HOST}:{src['remote'].rstrip('/')}/", f"{dest}/"] |
| print("+", " ".join(shlex.quote(c) for c in cmd), flush=True) |
| subprocess.run(cmd, check=True) |
|
|
|
|
| def sha_local(path): |
| h = hashlib.sha256() |
| with open(path, "rb") as f: |
| for block in iter(lambda: f.read(1 << 22), b""): |
| h.update(block) |
| return h.hexdigest() |
|
|
|
|
| def sha_remote(src, paths): |
| if not paths: |
| return {} |
| out = ssh(f"cd {shlex.quote(src['remote'])} && xargs -0 sha256sum --", |
| stdin=b"\0".join(p.encode() for p in paths)) |
| result = {} |
| for line in out.decode().splitlines(): |
| digest, path = line.split(" ", 1) |
| result[path] = digest |
| return result |
|
|
|
|
| def summarize_runs(dest, meta): |
| """One row per top-level run directory, aggregated from its outcome.json files. |
| |
| `already_complete` counts starts whose restored initial state already satisfied |
| the BDDL goal; they are excluded from `continued_success`. |
| """ |
| rows = {} |
| for f in sorted((dest / "runs").glob("**/outcome.json")): |
| top = f.relative_to(dest / "runs").parts[0] |
| d = json.loads(f.read_text()) |
| r = rows.setdefault(top, {"episodes": 0, "success": 0, "already_complete": 0, |
| "errors": {}, "mtime": 0}) |
| r["episodes"] += 1 |
| already = bool((d.get("initial_task") or {}).get("success")) |
| r["already_complete"] += already |
| r["success"] += bool(d.get("success")) and not already |
| if not d.get("success"): |
| key = str(d.get("error") or d.get("status")) |
| r["errors"][key] = r["errors"].get(key, 0) + 1 |
| r["mtime"] = max(r["mtime"], int(f.stat().st_mtime)) |
| lines = ["run\tlast_outcome_utc\tepisodes\talready_complete\tcontinued_success\tattempted\tsuccess_rate\ttop_failure"] |
| for name, r in sorted(rows.items(), key=lambda kv: kv[1]["mtime"]): |
| attempted = r["episodes"] - r["already_complete"] |
| rate = f"{r['success'] / attempted:.3f}" if attempted else "" |
| top = max(r["errors"].items(), key=lambda kv: kv[1])[0] if r["errors"] else "" |
| when = datetime.fromtimestamp(r["mtime"], timezone.utc).strftime("%Y-%m-%dT%H:%MZ") |
| lines.append(f"{name}\t{when}\t{r['episodes']}\t{r['already_complete']}\t{r['success']}" |
| f"\t{attempted}\t{rate}\t{top}") |
| (meta / "RUNS_SUMMARY.tsv").write_text("\n".join(lines) + "\n") |
|
|
|
|
| def sync(src, dry): |
| if src.get("copy_all_hdf5"): |
| from sync_dataset_source import sync_dataset_source |
| return sync_dataset_source(src, ROOT, dry=dry) |
| dest = ROOT / src["dest"] |
| meta = dest / "_sync" |
| dest.mkdir(parents=True, exist_ok=True) |
| meta.mkdir(exist_ok=True) |
| started = datetime.now(timezone.utc).isoformat() |
|
|
| inv = remote_inventory(src) |
| hdf5 = eligible_hdf5(src, inv) |
| print(f"[{src['name']}] remote files: {len(inv)}, eligible hdf5 to copy: {len(hdf5)}", flush=True) |
|
|
| rsync(src, dest, ["--exclude=*.hdf5"], dry) |
| if hdf5: |
| listing = meta / "hdf5_selected.txt" |
| listing.write_text("".join(p + "\n" for p in sorted(hdf5))) |
| rsync(src, dest, [f"--files-from={listing}"], dry) |
| if dry: |
| return |
|
|
| |
| cache_path = meta / "hash_cache.json" |
| cache = json.loads(cache_path.read_text()) if cache_path.exists() else {} |
| local = {} |
| for p in dest.rglob("*"): |
| |
| if "/campaigns/" in src["exclude"] and p.is_relative_to(dest / "campaigns"): |
| continue |
| if p.is_file() and meta not in p.parents: |
| st = p.stat() |
| local[str(p.relative_to(dest))] = (st.st_size, int(st.st_mtime)) |
| todo = [p for p, (size, mtime) in local.items() |
| if cache.get(p, [None, None])[:2] != [size, mtime]] |
| print(f"[{src['name']}] hashing {len(todo)} new/changed files", flush=True) |
| mismatches = [] |
| remote_hashes = {} |
| for i in range(0, len(todo), 500): |
| remote_hashes.update(sha_remote(src, [p for p in todo[i:i + 500] if p in inv])) |
| for p in todo: |
| digest = sha_local(dest / p) |
| if p in inv and remote_hashes.get(p) != digest: |
| mismatches.append(p) |
| continue |
| cache[p] = [*local[p], digest] |
| cache = {p: v for p, v in cache.items() if p in local} |
| cache_path.write_text(json.dumps(cache, sort_keys=True)) |
| (meta / "SHA256SUMS").write_text("".join(f"{cache[p][2]} {p}\n" for p in sorted(cache))) |
|
|
| rows = ["path\tsize\tremote_mtime\tstatus"] |
| for p in sorted(set(inv) | set(local)): |
| if p == "CENTRE_MIRROR.md": |
| status = "local_note" |
| elif p not in inv: |
| status = "local_only(removed_on_remote_or_excluded)" |
| elif p in local: |
| status = "local" |
| else: |
| status = "remote_only(hdf5_not_eligible)" if p.endswith(".hdf5") else "remote_only" |
| size, mtime = inv.get(p, local.get(p)) |
| rows.append(f"{p}\t{size}\t{mtime}\t{status}") |
| (meta / "REMOTE_INVENTORY.tsv").write_text("\n".join(rows) + "\n") |
| if (dest / "runs").is_dir(): |
| summarize_runs(dest, meta) |
|
|
| heads = {} |
| for repo in ("code", "code_v2"): |
| if (dest / repo / ".git").exists(): |
| heads[repo] = subprocess.run( |
| ["git", "-C", str(dest / repo), "log", "-1", "--format=%H %cI %s"], |
| capture_output=True, text=True).stdout.strip() |
| remote_only = [p for p in inv if p not in local] |
| record = { |
| "source": src["name"], "remote": f"{HOST}:{src['remote']}", "dest": src["dest"], |
| "started_at": started, "finished_at": datetime.now(timezone.utc).isoformat(), |
| "remote_files": len(inv), "remote_bytes": sum(s for s, _ in inv.values()), |
| "local_files": len(local), "local_bytes": sum(s for s, _ in local.values()), |
| "hdf5_copied": len(hdf5), |
| "remote_only_files": len(remote_only), |
| "remote_only_bytes": sum(inv[p][0] for p in remote_only), |
| "newly_verified": len(todo) - len(mismatches), "sha256_mismatches": mismatches, |
| "git_heads": heads, |
| } |
| (meta / "LAST_SYNC.json").write_text(json.dumps(record, indent=2, ensure_ascii=False) + "\n") |
| with open(ROOT / "sync" / "SYNC_LOG.jsonl", "a") as f: |
| f.write(json.dumps(record, ensure_ascii=False) + "\n") |
| print(json.dumps(record, indent=2, ensure_ascii=False), flush=True) |
| if mismatches: |
| sys.exit(f"SHA-256 mismatch for {len(mismatches)} files; see LAST_SYNC.json") |
|
|
|
|
| if __name__ == "__main__": |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--dry-run", action="store_true") |
| ap.add_argument("--source", action="append", help="sync only this source name") |
| ap.add_argument("--summary-only", action="store_true", |
| help="only rebuild _sync/RUNS_SUMMARY.tsv from local files") |
| args = ap.parse_args() |
| for src in SOURCES: |
| if not args.source or src["name"] in args.source: |
| if args.summary_only: |
| dest = ROOT / src["dest"] |
| if (dest / "runs").is_dir(): |
| summarize_runs(dest, dest / "_sync") |
| else: |
| sync(src, args.dry_run) |
|
|
