| |
| """Build a portable Harbor task + rootless Apptainer runtime release. |
| |
| This packager is intentionally distinct from the Gate-1-clean SWEGym/R2EGym |
| packagers. It supports datasets without reference solutions, but records that |
| limitation explicitly and never labels such a release Gate-1-clean. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import io |
| import json |
| import os |
| import shutil |
| import subprocess |
| import tarfile |
| import tempfile |
| from pathlib import Path, PurePosixPath |
| from stat import S_ISLNK, S_ISREG |
| from typing import Any |
|
|
| import pyarrow as pa |
| import pyarrow.parquet as pq |
| import zstandard as zstd |
|
|
|
|
| CORE_FILES = ("task.toml", "instruction.md", "environment/Dockerfile", "tests/test.sh") |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--release-id", required=True) |
| parser.add_argument("--release-label", required=True) |
| parser.add_argument("--hf-repo", required=True) |
| parser.add_argument("--tasks", required=True, type=Path) |
| parser.add_argument("--source-parquet", required=True, type=Path) |
| parser.add_argument("--upstream-repo", required=True) |
| parser.add_argument("--upstream-revision", required=True) |
| parser.add_argument("--upstream-subdirectory") |
| parser.add_argument("--sif-cache", required=True, type=Path) |
| parser.add_argument("--output", required=True, type=Path) |
| parser.add_argument("--license", default="other") |
| parser.add_argument("--expected-source-tasks", required=True, type=int) |
| parser.add_argument("--expected-compatible-tasks", required=True, type=int) |
| parser.add_argument("--allow-offline-test-patch", action="store_true") |
| parser.add_argument("--runtime-evidence", action="append", default=[]) |
| parser.add_argument("--validation-note", required=True) |
| parser.add_argument("--harbor-root", type=Path) |
| parser.add_argument("--overfit-count", type=int, default=64) |
| parser.add_argument("--diagnostic-count", type=int, default=64) |
| parser.add_argument("--release-date", default="2026-09-24") |
| return parser.parse_args() |
|
|
|
|
| def sha256_bytes(value: bytes) -> str: |
| return hashlib.sha256(value).hexdigest() |
|
|
|
|
| def sha256_file(path: Path) -> str: |
| digest = hashlib.sha256() |
| with path.open("rb") as stream: |
| for block in iter(lambda: stream.read(8 * 1024 * 1024), b""): |
| digest.update(block) |
| return digest.hexdigest() |
|
|
|
|
| def sha256_text(value: str) -> str: |
| return sha256_bytes(value.encode()) |
|
|
|
|
| def docker_build_context_hash(context: Path, dockerfile: Path) -> str: |
| """Mirror Harbor's stable 64-bit BLAKE2 build-context cache key.""" |
| entries: list[Path] = [] |
| for root, dirs, files in context.walk(top_down=True, follow_symlinks=False): |
| dirs.sort() |
| entries.extend(root / name for name in sorted(files)) |
| digest = hashlib.blake2b(digest_size=8) |
| digest.update(dockerfile.name.encode()) |
| digest.update(dockerfile.read_bytes()) |
| for path in entries: |
| stat = path.lstat() |
| digest.update(str(path.relative_to(context)).encode()) |
| digest.update(stat.st_mode.to_bytes(4, "little")) |
| digest.update(stat.st_size.to_bytes(8, "little")) |
| if S_ISLNK(stat.st_mode): |
| digest.update(os.readlink(path).encode()) |
| elif S_ISREG(stat.st_mode): |
| digest.update(path.read_bytes()) |
| return digest.hexdigest() |
|
|
|
|
| def write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None: |
| path.write_text("".join(json.dumps(row, sort_keys=True) + "\n" for row in rows)) |
|
|
|
|
| def normalized_member_name(name: str) -> str: |
| parts = [part for part in PurePosixPath(name).parts if part not in ("", ".")] |
| if parts and parts[0] == "tasks": |
| parts = parts[1:] |
| return PurePosixPath(*parts).as_posix() |
|
|
|
|
| def archive_inventory(payload: bytes) -> dict[str, str]: |
| files: dict[str, str] = {} |
| with tarfile.open(fileobj=io.BytesIO(payload), mode="r:*") as archive: |
| for member in archive.getmembers(): |
| if not member.isfile(): |
| continue |
| name = normalized_member_name(member.name) |
| if not name: |
| continue |
| stream = archive.extractfile(member) |
| if stream is None: |
| raise RuntimeError(f"cannot extract {member.name}") |
| files[name] = sha256_bytes(stream.read()) |
| return files |
|
|
|
|
| def local_inventory(task: Path) -> dict[str, str]: |
| root = task.resolve() |
| return { |
| path.relative_to(root).as_posix(): sha256_file(path) |
| for path in sorted(root.rglob("*")) |
| if path.is_file() |
| } |
|
|
|
|
| def source_rows(path: Path) -> dict[str, tuple[bytes, dict[str, str]]]: |
| parquet = pq.ParquetFile(path) |
| rows: dict[str, tuple[bytes, dict[str, str]]] = {} |
| for row_group in range(parquet.num_row_groups): |
| table = parquet.read_row_group(row_group, columns=["path", "task_binary"]) |
| for row in table.to_pylist(): |
| task_id = str(row["path"]) |
| if task_id in rows: |
| raise RuntimeError(f"duplicate source task: {task_id}") |
| payload = bytes(row["task_binary"]) |
| rows[task_id] = (payload, archive_inventory(payload)) |
| return rows |
|
|
|
|
| def add_tar_entry(archive: tarfile.TarFile, path: Path, arcname: str) -> None: |
| info = archive.gettarinfo(str(path), arcname=arcname) |
| info.uid = info.gid = 0 |
| info.uname = info.gname = "" |
| info.mtime = 0 |
| if path.is_file(): |
| with path.open("rb") as stream: |
| archive.addfile(info, stream) |
| else: |
| archive.addfile(info) |
|
|
|
|
| def deterministic_task_tar(task: Path) -> bytes: |
| root = task.resolve() |
| payload = io.BytesIO() |
| with tarfile.open(fileobj=payload, mode="w", format=tarfile.PAX_FORMAT) as archive: |
| for path in sorted(root.rglob("*")): |
| add_tar_entry(archive, path, path.relative_to(root).as_posix()) |
| return payload.getvalue() |
|
|
|
|
| def write_tasks_archive(tasks: Path, task_ids: list[str], output: Path) -> None: |
| compressor = zstd.ZstdCompressor(level=19, threads=0) |
| with output.open("wb") as raw: |
| with compressor.stream_writer(raw, closefd=False) as compressed: |
| with tarfile.open(fileobj=compressed, mode="w|", format=tarfile.PAX_FORMAT) as archive: |
| for task_id in task_ids: |
| root = (tasks / task_id).resolve() |
| add_tar_entry(archive, root, f"tasks/{task_id}") |
| for path in sorted(root.rglob("*")): |
| add_tar_entry( |
| archive, |
| path, |
| f"tasks/{task_id}/{path.relative_to(root).as_posix()}", |
| ) |
|
|
|
|
| def stable_order(task_ids: list[str], seed: str) -> list[str]: |
| return sorted( |
| task_ids, |
| key=lambda task: (sha256_text(f"{seed}\0{task}"), task), |
| ) |
|
|
|
|
| def copy_large_file(source: Path, target: Path) -> None: |
| try: |
| os.link(source, target) |
| except OSError: |
| shutil.copy2(source, target) |
|
|
|
|
| def runtime_provenance(harbor_root: Path | None, output: Path) -> dict[str, Any] | None: |
| if harbor_root is None: |
| return None |
| root = harbor_root.resolve() |
| revision = subprocess.run( |
| ["git", "rev-parse", "HEAD"], cwd=root, check=True, capture_output=True, text=True |
| ).stdout.strip() |
| patch = subprocess.run( |
| ["git", "diff", "--binary"], cwd=root, check=True, capture_output=True |
| ).stdout |
| patch_path = output / "harbor-runtime.patch" |
| patch_path.write_bytes(patch) |
| return { |
| "repository": "harbor", |
| "revision": revision, |
| "dirty_patch": patch_path.name, |
| "dirty_patch_sha256": sha256_bytes(patch), |
| "dirty_patch_bytes": len(patch), |
| } |
|
|
|
|
| def write_materializer(path: Path) -> None: |
| path.write_text( |
| '''#!/usr/bin/env python3 |
| """Materialize Harbor task and SIF-cache views from this release.""" |
| import argparse |
| import json |
| import os |
| import subprocess |
| import tempfile |
| from pathlib import Path |
| |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--release", type=Path, default=Path(__file__).resolve().parents[1]) |
| parser.add_argument("--runtime-root", type=Path, required=True) |
| args = parser.parse_args() |
| release = args.release.resolve() |
| runtime = args.runtime_root.resolve() |
| if runtime.exists(): |
| raise SystemExit(f"refusing to overwrite {runtime}") |
| runtime.parent.mkdir(parents=True, exist_ok=True) |
| with tempfile.TemporaryDirectory(prefix="harbor-runtime-", dir=runtime.parent) as temporary: |
| stage = Path(temporary) / "runtime" |
| stage.mkdir() |
| subprocess.run( |
| ["tar", "--use-compress-program=zstd", "-xf", str(release / "tasks.tar.zst"), "-C", str(stage)], |
| check=True, |
| ) |
| sif_cache = stage / "sif-cache" |
| sif_cache.mkdir() |
| for line in (release / "manifests" / "task-sif-routing.jsonl").read_text().splitlines(): |
| row = json.loads(line) |
| (sif_cache / f"{row['task_id']}.sif").symlink_to(release / row["sif_image"]) |
| os.replace(stage, runtime) |
| print(f"materialized runtime at {runtime}") |
| ''' |
| ) |
|
|
|
|
| def write_readme( |
| path: Path, |
| args: argparse.Namespace, |
| task_count: int, |
| excluded_count: int, |
| image_count: int, |
| image_bytes: int, |
| patch_count: int, |
| ) -> None: |
| source_location = args.upstream_repo |
| if args.upstream_subdirectory: |
| source_location += f"/{args.upstream_subdirectory}" |
| patch_text = ( |
| f" The release records **{patch_count:,}** offline-only `tests/test.sh` patches that " |
| "neutralize redundant runtime package-download commands; verifier test logic is unchanged." |
| if patch_count |
| else " Task contents are byte-identical to the selected upstream task archives." |
| ) |
| path.write_text( |
| "---\n" |
| f"license: {args.license}\n" |
| "task_categories:\n- reinforcement-learning\n" |
| "language:\n- en\n" |
| "tags:\n- harbor\n- apptainer\n- offline\n- agentic-coding\n" |
| "configs:\n- config_name: default\n data_files:\n - split: train\n path: tasks.parquet\n" |
| "---\n\n" |
| f"# {args.release_label}: rootless Apptainer runtime release\n\n" |
| f"This release contains **{task_count:,}** runnable Harbor tasks from " |
| f"`{source_location}@{args.upstream_revision}` and bundles the exact aarch64 SIF images " |
| "used on Jupiter with rootless Apptainer 1.4.5." |
| f"{patch_text}\n\n" |
| f"{excluded_count:,} source tasks are excluded for missing required task/verifier files. " |
| "The source does **not** provide reference solutions, so this is a production-runtime-tested " |
| "release rather than an all-task oracle-certified Gate-1 release. The validation summary " |
| "preserves that distinction.\n\n" |
| "## Contents\n\n" |
| "- `tasks.parquet`: deterministic Harbor task payloads.\n" |
| "- `tasks.tar.zst`: materialized task directories.\n" |
| f"- `sif-images/`: {image_count} content-addressed aarch64 image(s), " |
| f"{image_bytes / (1024**3):.2f} GiB total.\n" |
| "- `manifests/`: compatible tasks, routing, exclusions, splits, and patches.\n" |
| "- `validation/summary.json`: exact validation scope and limitations.\n" |
| "- `scripts/materialize_release.py`: fresh runtime materializer.\n" |
| "- `SHA256SUMS`: checksums for every published file.\n\n" |
| "## Use with Harbor\n\n" |
| "```bash\n" |
| f"hf download {args.hf_repo} --repo-type dataset --local-dir release\n" |
| "cd release && sha256sum -c SHA256SUMS\n" |
| "python scripts/materialize_release.py --runtime-root runtime\n" |
| "harbor run -p runtime/tasks -e apptainer --environment-kwarg sif_cache=$PWD/runtime/sif-cache ...\n" |
| "```\n\n" |
| "The images are **aarch64**, not x86_64. See `dataset_manifest.json` and `provenance/` " |
| "for immutable source and Harbor-runtime details.\n" |
| ) |
|
|
|
|
| def main() -> int: |
| args = parse_args() |
| tasks = args.tasks.resolve() |
| source_parquet = args.source_parquet.resolve() |
| sif_cache = args.sif_cache.resolve() |
| output = args.output.resolve() |
| if output.exists(): |
| raise SystemExit(f"refusing to overwrite {output}") |
|
|
| upstream = source_rows(source_parquet) |
| if len(upstream) != args.expected_source_tasks: |
| raise SystemExit( |
| f"source task count mismatch: expected {args.expected_source_tasks}, found {len(upstream)}" |
| ) |
| local_ids = {path.name for path in tasks.iterdir() if path.is_dir()} |
| extra_local = sorted(local_ids - upstream.keys()) |
| if extra_local: |
| raise SystemExit(f"local tasks absent upstream: {extra_local[:10]}") |
|
|
| decisions: list[dict[str, Any]] = [] |
| patches: list[dict[str, Any]] = [] |
| compatible: list[dict[str, Any]] = [] |
| sif_by_source: dict[Path, dict[str, Any]] = {} |
| for task_id in sorted(upstream): |
| task = (tasks / task_id).resolve() |
| missing = [name for name in CORE_FILES if not (task / name).is_file()] |
| if missing: |
| decisions.append( |
| {"task_id": task_id, "decision": "excluded", "reason": "missing_core_files", "missing": missing} |
| ) |
| continue |
| current = local_inventory(task) |
| original = upstream[task_id][1] |
| all_paths = sorted(set(current) | set(original)) |
| changes = [name for name in all_paths if current.get(name) != original.get(name)] |
| if changes: |
| allowed = args.allow_offline_test_patch and changes == ["tests/test.sh"] |
| marker_present = "patched-offline:" in (task / "tests/test.sh").read_text(errors="replace") |
| if not allowed or not marker_present: |
| raise RuntimeError(f"unexpected local changes for {task_id}: {changes}") |
| patches.append( |
| { |
| "task_id": task_id, |
| "path": "tests/test.sh", |
| "operation": "neutralize_redundant_network_install_commands", |
| "source_sha256": original.get("tests/test.sh"), |
| "release_sha256": current.get("tests/test.sh"), |
| } |
| ) |
| dockerfile = task / "environment" / "Dockerfile" |
| docker_sha = sha256_file(dockerfile) |
| context_hash = docker_build_context_hash(dockerfile.parent, dockerfile) |
| sif_source = sif_cache / f"build_{context_hash}.sif" |
| if not sif_source.is_file(): |
| raise FileNotFoundError(f"missing SIF for {task_id}: {sif_source}") |
| if sif_source not in sif_by_source: |
| sif_sha = sha256_file(sif_source) |
| sif_by_source[sif_source] = { |
| "source": str(sif_source), |
| "sha256": sif_sha, |
| "size": sif_source.stat().st_size, |
| "path": f"sif-images/{sif_sha[:16]}--{sif_source.name}", |
| } |
| tree_text = "".join(f"{name}\0{digest}\n" for name, digest in sorted(current.items())) |
| compatible.append( |
| { |
| "task_id": task_id, |
| "task_tree_sha256": sha256_text(tree_text), |
| "dockerfile_sha256": docker_sha, |
| "docker_build_context_hash": context_hash, |
| "sif_image": sif_by_source[sif_source]["path"], |
| "sif_sha256": sif_by_source[sif_source]["sha256"], |
| } |
| ) |
| decisions.append({"task_id": task_id, "decision": "accepted", "reason": "runtime_compatible"}) |
|
|
| if len(compatible) != args.expected_compatible_tasks: |
| raise SystemExit( |
| f"compatible task count mismatch: expected {args.expected_compatible_tasks}, found {len(compatible)}" |
| ) |
| task_ids = [row["task_id"] for row in compatible] |
| task_id_text = "".join(f"{task_id}\n" for task_id in task_ids) |
| overfit_ids = stable_order(task_ids, f"{args.release_id}-overfit-v1")[: args.overfit_count] |
| overfit = set(overfit_ids) |
| diagnostic_ids = stable_order( |
| [task_id for task_id in task_ids if task_id not in overfit], |
| f"{args.release_id}-diagnostic-v1", |
| )[: args.diagnostic_count] |
| diagnostic = set(diagnostic_ids) |
|
|
| try: |
| for name in ("sif-images", "manifests", "provenance", "scripts", "validation"): |
| (output / name).mkdir(parents=True, exist_ok=True) |
| for source, row in sif_by_source.items(): |
| copy_large_file(source, output / row["path"]) |
|
|
| for row in compatible: |
| row["in_overfit_train"] = row["task_id"] in overfit |
| row["in_diagnostic_validation"] = row["task_id"] in diagnostic |
| write_jsonl(output / "manifests" / "compatible.jsonl", compatible) |
| write_jsonl( |
| output / "manifests" / "task-sif-routing.jsonl", |
| [{key: row[key] for key in ("task_id", "sif_image", "sif_sha256")} for row in compatible], |
| ) |
| write_jsonl(output / "manifests" / "source-task-decisions.jsonl", decisions) |
| write_jsonl(output / "manifests" / "offline-patches.jsonl", patches) |
| write_jsonl( |
| output / "manifests" / "overfit-train.jsonl", |
| [{"task_id": task_id, "rank": rank} for rank, task_id in enumerate(overfit_ids, 1)], |
| ) |
| write_jsonl( |
| output / "manifests" / "diagnostic-validation.jsonl", |
| [{"task_id": task_id, "rank": rank} for rank, task_id in enumerate(diagnostic_ids, 1)], |
| ) |
| (output / "manifests" / "task-ids.txt").write_text(task_id_text) |
| write_jsonl(output / "manifests" / "sif-images.jsonl", list(sif_by_source.values())) |
|
|
| schema = pa.schema( |
| [ |
| ("path", pa.string()), |
| ("task_binary", pa.binary()), |
| ("task_id", pa.string()), |
| ("instruction", pa.string()), |
| ("sif_image", pa.string()), |
| ("in_overfit_train", pa.bool_()), |
| ("in_diagnostic_validation", pa.bool_()), |
| ] |
| ) |
| route_by_task = {row["task_id"]: row for row in compatible} |
| with pq.ParquetWriter(output / "tasks.parquet", schema, compression="zstd", use_dictionary=False) as writer: |
| for offset in range(0, len(task_ids), 32): |
| rows = [] |
| for task_id in task_ids[offset : offset + 32]: |
| task = (tasks / task_id).resolve() |
| rows.append( |
| { |
| "path": task_id, |
| "task_binary": deterministic_task_tar(task), |
| "task_id": task_id, |
| "instruction": (task / "instruction.md").read_text(errors="replace"), |
| "sif_image": route_by_task[task_id]["sif_image"], |
| "in_overfit_train": task_id in overfit, |
| "in_diagnostic_validation": task_id in diagnostic, |
| } |
| ) |
| writer.write_table(pa.Table.from_pylist(rows, schema=schema)) |
| write_tasks_archive(tasks, task_ids, output / "tasks.tar.zst") |
|
|
| provenance = { |
| "schema_version": 1, |
| "upstream_repo": args.upstream_repo, |
| "upstream_revision": args.upstream_revision, |
| "upstream_subdirectory": args.upstream_subdirectory, |
| "source_parquet_sha256": sha256_file(source_parquet), |
| "source_task_count": len(upstream), |
| "release_task_count": len(task_ids), |
| "release_task_ids_sha256": sha256_text(task_id_text), |
| "local_source": str(tasks), |
| } |
| (output / "provenance" / "source.json").write_text( |
| json.dumps(provenance, indent=2, sort_keys=True) + "\n" |
| ) |
| harbor = runtime_provenance(args.harbor_root, output / "provenance") |
| validation = { |
| "schema_version": 1, |
| "profile": "jupiter-apptainer-1.4.5-aarch64-rootless-offline-v1", |
| "status": "production_runtime_tested_gate1_provisional", |
| "task_count": len(task_ids), |
| "static_source_comparison": "pass", |
| "missing_core_exclusions": len(upstream) - len(task_ids), |
| "oracle_available": False, |
| "oracle_attempts": 0, |
| "negative_control_scope": "not_complete_all_tasks", |
| "runtime_evidence": args.runtime_evidence, |
| "note": args.validation_note, |
| } |
| (output / "validation" / "summary.json").write_text( |
| json.dumps(validation, indent=2, sort_keys=True) + "\n" |
| ) |
| manifest = { |
| "schema_version": 1, |
| "id": args.release_id, |
| "release_label": args.release_label, |
| "release_date": args.release_date, |
| "status": validation["status"], |
| "publication": {"hf_repo": args.hf_repo, "revision": None}, |
| "license": args.license, |
| "task_format": "harbor", |
| "task_count": len(task_ids), |
| "source_task_count": len(upstream), |
| "excluded_task_count": len(upstream) - len(task_ids), |
| "offline_patch_count": len(patches), |
| "architectures": ["aarch64"], |
| "sif_image_count": len(sif_by_source), |
| "sif_image_bytes": sum(row["size"] for row in sif_by_source.values()), |
| "task_ids_sha256": sha256_text(task_id_text), |
| "upstream": provenance, |
| "harbor_runtime": harbor, |
| "validation": validation, |
| "splits": { |
| "compatible": len(task_ids), |
| "overfit_train": len(overfit_ids), |
| "diagnostic_validation": len(diagnostic_ids), |
| }, |
| } |
| (output / "dataset_manifest.json").write_text( |
| json.dumps(manifest, indent=2, sort_keys=True) + "\n" |
| ) |
| write_materializer(output / "scripts" / "materialize_release.py") |
| shutil.copy2(Path(__file__), output / "scripts" / Path(__file__).name) |
| if args.license == "apache-2.0" and args.harbor_root: |
| shutil.copy2(args.harbor_root.resolve() / "LICENSE", output / "LICENSE") |
| write_readme( |
| output / "README.md", |
| args, |
| len(task_ids), |
| len(upstream) - len(task_ids), |
| len(sif_by_source), |
| manifest["sif_image_bytes"], |
| len(patches), |
| ) |
| checksums = [] |
| for path in sorted(item for item in output.rglob("*") if item.is_file()): |
| if path.name == "SHA256SUMS": |
| continue |
| checksums.append(f"{sha256_file(path)} {path.relative_to(output).as_posix()}\n") |
| (output / "SHA256SUMS").write_text("".join(checksums)) |
| except Exception: |
| shutil.rmtree(output, ignore_errors=True) |
| raise |
|
|
| print(json.dumps(manifest, indent=2, sort_keys=True)) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
