#!/usr/bin/env python3 """Generate and fail-closed validate the matched E4 ImageNet launch batch.""" from __future__ import annotations import argparse import copy import hashlib import json import math import re import sys from dataclasses import asdict, dataclass from pathlib import Path from typing import Any import yaml SCRIPT_PATH = Path(__file__).resolve() JOURNAL_ROOT = SCRIPT_PATH.parents[1] GMNET_ROOT = JOURNAL_ROOT.parent PROTOCOL_PATH = JOURNAL_ROOT / "configs/e4_alignment_protocol.yaml" BASE_TEMPLATE = Path("/nfs/ywang29/LongLive/deploy/jul11_vgp/j11_vgp01_base.yaml") BATCH_ROOT = GMNET_ROOT / "depoly/e4_alignment_20260716" RUN_ROOT = GMNET_ROOT / "runs/e4_alignment" CODE_MANIFEST_RELATIVE_PATH = "configs/code_manifests/e4_alignment_20260716.json" SMOKE_EVIDENCE_PATH = BATCH_ROOT / "smoke_evidence.json" APPROVAL_ROOT = BATCH_ROOT / "approvals" BASELINE_CONFIG_PATH = JOURNAL_ROOT / "configs/e0_baseline/imagenet_gmnet_s3.yaml" GENERATED_HEADER = ( "# Generated by journal_exp/scripts/generate_e4_alignment_deploy.py; " "do not edit.\n" ) TASK_IDS = ( "e4a_s3_stop_gradient_seed0", "e4a_s3_channel_derangement_seed0", ) INTERVENTIONS = ("stop_gradient", "channel_derangement") SHA256_PATTERN = re.compile(r"[0-9a-f]{64}") RESOURCE_KEYS = ( "gpu_type", "gpu_num", "gpu_memory", "cpu_num", "memory", "efa", "priority", "pytorchjob", "custom_node_labels", "volcano_queue", ) PROJECT_KEYS = ( "project_name", "project_support_alias", "team", "cost_team", "cost_feature", "cost_sub_feature", "docker_image", "mount", ) class ApprovalError(RuntimeError): """Raised when the E4 launch guard intentionally denies a task.""" @dataclass(frozen=True) class E4Task: task_id: str experiment: str model: str gate: str gate_intervention: str gate_intervention_seed: int seed: int config_path: str role: str status: str contrast: str question: str @property def output_dir(self) -> Path: return RUN_ROOT / self.task_id @property def deploy_path(self) -> Path: return BATCH_ROOT / f"{self.task_id}.yaml" @property def approval_path(self) -> Path: return APPROVAL_ROOT / f"{self.task_id}.json" @property def job_name(self) -> str: return "gmnet-" + self.task_id.replace("_", "-") def file_sha256(path: Path) -> str: digest = hashlib.sha256() with path.open("rb") as handle: for chunk in iter(lambda: handle.read(8 * 1024 * 1024), b""): digest.update(chunk) return digest.hexdigest() def stable_sha256(value: Any) -> str: payload = json.dumps( value, sort_keys=True, separators=(",", ":"), ensure_ascii=True ).encode("utf-8") return hashlib.sha256(payload).hexdigest() def require_sha256(value: Any, location: str) -> str: if not isinstance(value, str) or SHA256_PATTERN.fullmatch(value) is None: raise ValueError(f"invalid SHA-256 at {location}: {value!r}") return value def load_yaml(path: Path) -> dict[str, Any]: if not path.is_file(): raise FileNotFoundError(path) loaded = yaml.safe_load(path.read_text(encoding="utf-8")) if not isinstance(loaded, dict): raise ValueError(f"expected a YAML mapping: {path}") return loaded def load_json(path: Path) -> dict[str, Any]: if not path.is_file(): raise FileNotFoundError(path) loaded = json.loads(path.read_text(encoding="utf-8")) if not isinstance(loaded, dict): raise ValueError(f"expected a JSON object: {path}") return loaded def load_protocol() -> dict[str, Any]: return load_yaml(PROTOCOL_PATH) def load_resolved_config(path: Path) -> dict[str, Any]: if str(JOURNAL_ROOT) not in sys.path: sys.path.insert(0, str(JOURNAL_ROOT)) from gmnet.config import load_config return load_config(path) def require_value(config: dict[str, Any], dotted_key: str, expected: Any) -> None: value: Any = config for part in dotted_key.split("."): if not isinstance(value, dict) or part not in value: raise ValueError(f"missing config value {dotted_key}") value = value[part] if value != expected: raise ValueError( f"config mismatch for {dotted_key}: {value!r}, expected {expected!r}" ) def _assert_exact_config_delta(task: E4Task, config: dict[str, Any]) -> None: baseline = load_resolved_config(BASELINE_CONFIG_PATH) expected = copy.deepcopy(baseline) expected["experiment_id"] = ( "E4-ImageNet-S3-stop-gradient" if task.gate_intervention == "stop_gradient" else "E4-ImageNet-S3-channel-derangement" ) expected["protocol_id"] = "e4-imagenet-matched-alignment-v1" expected["model"]["gate_intervention"] = task.gate_intervention expected["model"]["gate_intervention_seed"] = task.gate_intervention_seed if config != expected: raise ValueError( f"{task.task_id} must differ from the paper S3 baseline only in " "experiment/protocol identity and the registered gate intervention" ) source = load_yaml(JOURNAL_ROOT / task.config_path) expected_source_keys = {"base", "experiment_id", "protocol_id", "model"} if set(source) != expected_source_keys: raise ValueError(f"unexpected source config keys for {task.task_id}") if source["base"] != "../e0_baseline/imagenet_gmnet_s3.yaml": raise ValueError(f"{task.task_id} must inherit the paper S3 baseline") if source["model"] != { "gate_intervention": task.gate_intervention, "gate_intervention_seed": task.gate_intervention_seed, }: raise ValueError(f"unexpected model overrides for {task.task_id}") def validate_task_config( protocol: dict[str, Any], task: E4Task, config: dict[str, Any] ) -> None: invariants = { "recipe_id": "paper-supplementary-table8-v1", "protocol_id": "e4-imagenet-matched-alignment-v1", "model.variant": "s3", "model.num_classes": 1000, "model.gate_type": "relu6_self", "model.gate_intervention": task.gate_intervention, "model.gate_intervention_seed": task.gate_intervention_seed, "model.drop_path_rate": 0.02, "model.f12_bn": False, "model.projection_bn": True, "model.second_dw_bn": False, "data.dataset": "imagenet", "data.num_classes": 1000, "data.expected_train_samples": protocol["data"]["expected_train_samples"], "data.expected_val_samples": protocol["data"]["expected_val_samples"], "data.expected_manifest_sha256": protocol["data"]["canonical_manifest_sha256"], "train.epochs": 300, "train.eval_interval": 300, "train.fail_on_nonfinite": True, "train.strict_resume": True, "train.official_validation_policy": "final_epoch_only", "train.save_best_checkpoint": False, } for key, expected in invariants.items(): require_value(config, key, expected) patterns = config.get("optimizer", {}).get("no_weight_decay_patterns") if not isinstance(patterns, list) or "raw_clip" not in patterns: raise ValueError(f"{task.task_id} must retain paper optimizer exclusions") _assert_exact_config_delta(task, config) def build_tasks(protocol: dict[str, Any] | None = None) -> list[E4Task]: protocol = load_protocol() if protocol is None else protocol records = protocol.get("tasks") if not isinstance(records, list): raise ValueError("E4 alignment protocol tasks must be a list") tasks: list[E4Task] = [] for record in records: if not isinstance(record, dict): raise ValueError("each E4 task must be a mapping") tasks.append( E4Task( task_id=str(record["task_id"]), experiment=str(record["experiment"]), model=str(record["model"]), gate=str(record["gate"]), gate_intervention=str(record["gate_intervention"]), gate_intervention_seed=int(record["gate_intervention_seed"]), seed=int(record["seed"]), config_path=str(record["config_path"]), role=str(record["role"]), status=str(record["status"]), contrast=str(record["contrast"]), question=str(record["question"]), ) ) validate_protocol(protocol, tasks) return tasks def validate_protocol(protocol: dict[str, Any], tasks: list[E4Task]) -> None: if protocol.get("schema_version") != 1: raise ValueError("E4 alignment protocol schema_version must be 1") if protocol.get("protocol_id") != "imagenet-e4-alignment-single-seed-20260716": raise ValueError("unexpected E4 alignment protocol_id") if Path(str(protocol.get("run_root"))) != RUN_ROOT: raise ValueError(f"E4 run_root must be {RUN_ROOT}") if Path(str(protocol.get("deploy_root"))) != BATCH_ROOT: raise ValueError(f"E4 deploy_root must be {BATCH_ROOT}") if protocol.get("code_manifest_path") != CODE_MANIFEST_RELATIVE_PATH: raise ValueError("unexpected E4 code manifest path") if Path(str(protocol.get("smoke_evidence_path"))) != SMOKE_EVIDENCE_PATH: raise ValueError("unexpected E4 smoke evidence path") if tuple(task.task_id for task in tasks) != TASK_IDS: raise ValueError("E4 task matrix or ordering drifted") if tuple(task.gate_intervention for task in tasks) != INTERVENTIONS: raise ValueError("E4 intervention matrix or ordering drifted") if len({task.task_id for task in tasks}) != len(tasks): raise ValueError("duplicate E4 task IDs") data = protocol.get("data", {}) data_expected = { "runtime_root": "/tmp/gmnet_data/imagenet-1k", "source_archive_uri": ( "s3://snap-research-cv-code/ywang29/datasets/imagenet-1k/" "imagenet-1k.tar" ), "expected_archive_bytes": 161381969920, "canonical_manifest_sha256": ( "bb70bc9f530db6bb24f70e648624b35281bfbc76a57775d589a2e0209dd98661" ), "expected_train_samples": 1281167, "expected_val_samples": 50000, } for key, expected in data_expected.items(): if data.get(key) != expected: raise ValueError(f"E4 data registration drifted: {key}") for key in ( "train_sample_index_sha256", "val_sample_index_sha256", "train_sampled_content_sha256", "val_sampled_content_sha256", ): require_sha256(data.get(key), f"protocol.data.{key}") policy = protocol.get("policy", {}) policy_expected = { "seed": 0, "seed_replication_in_scope": False, "model_variant": "s3", "baseline_recipe": "paper-supplementary-table8-v1", "baseline_top1": 78.746, "intervention_seed": 41041, "block_seed_stride": 10007, "gpus_per_job": 8, "epochs": 300, "eta_class": "greater_than_12h", "checkpoint_policy": "fixed_last", "resume": "auto", "post_eval": "strict_official", "approval_marker_required_for_every_task": True, "approval_requires_8gpu_strict_resume_smoke": True, "output_lock": "nonblocking_flock", "launchjob_submitted_by_generator": False, } for key, expected in policy_expected.items(): if policy.get(key) != expected: raise ValueError(f"E4 policy drifted: {key}") if protocol.get("relationship_to_prior_work", "").startswith("Post-hoc") is False: raise ValueError("E4 relationship to prior work must remain post-hoc") if not protocol.get("known_before_registration"): raise ValueError("E4 known-results registration is missing") restrictions = protocol.get("claim_restrictions") if not isinstance(restrictions, list) or len(restrictions) < 4: raise ValueError("E4 claim restrictions are incomplete") for task in tasks: exact = { "experiment": "E4", "model": "s3", "gate": "relu6_self", "gate_intervention_seed": 41041, "seed": 0, "role": "matched_alignment_retraining", "status": "ready_after_smoke", } for field, expected in exact.items(): if getattr(task, field) != expected: raise ValueError(f"E4 task drifted: {task.task_id}/{field}") if not task.contrast or not task.question: raise ValueError(f"E4 task rationale is incomplete: {task.task_id}") config_path = JOURNAL_ROOT / task.config_path validate_task_config(protocol, task, load_resolved_config(config_path)) def normalized_training_semantics(config: dict[str, Any]) -> dict[str, Any]: normalized = copy.deepcopy(config) normalized.pop("runtime", None) normalized.pop("experiment_id", None) protocol = normalized.get("protocol") if isinstance(protocol, dict): protocol.pop("code_sha256", None) if not protocol: normalized.pop("protocol") return normalized def read_code_manifest() -> dict[str, Any]: manifest = load_json(JOURNAL_ROOT / CODE_MANIFEST_RELATIVE_PATH) if manifest.get("schema_version") != 1: raise ValueError("E4 code manifest schema_version must be 1") require_sha256(manifest.get("code_sha256"), "code_manifest.code_sha256") files = manifest.get("files") if not isinstance(files, list) or not files: raise ValueError("E4 code manifest files are missing") paths = {item.get("path") for item in files if isinstance(item, dict)} required_paths = { "configs/e4_alignment_protocol.yaml", "configs/e4_alignment/imagenet_gmnet_s3_stop_gradient.yaml", "configs/e4_alignment/imagenet_gmnet_s3_channel_derangement.yaml", "configs/smoke/imagenet5_gmnet_s1_e4_stop_gradient.yaml", "configs/smoke/imagenet5_gmnet_s1_e4_channel_derangement.yaml", "scripts/audit_e4_alignment_smoke.py", "scripts/generate_e4_alignment_deploy.py", "scripts/run_e4_alignment.sh", } missing = sorted(required_paths - paths) if missing: raise ValueError(f"E4 code manifest scope is incomplete: {missing}") return manifest def verify_code_manifest() -> tuple[str, str]: if str(JOURNAL_ROOT) not in sys.path: sys.path.insert(0, str(JOURNAL_ROOT)) from scripts.code_fingerprint import build_manifest path = JOURNAL_ROOT / CODE_MANIFEST_RELATIVE_PATH expected = read_code_manifest() actual = build_manifest(JOURNAL_ROOT) if actual != expected: raise ValueError( "E4 code manifest mismatch: " f"expected {expected.get('code_sha256')}, " f"computed {actual.get('code_sha256')}" ) return str(expected["code_sha256"]), file_sha256(path) def verify_historical_baseline(protocol: dict[str, Any]) -> None: record = protocol.get("historical_baseline") if not isinstance(record, dict): raise ValueError("historical baseline registration is missing") required_registration = { "evidence_id": "legacy_relu6_s3_seed0", "acceptance": "accepted_historical_seed0_alias", "code_provenance": "retrospective_unverified", "run_dir": "/nfs/ywang29/GmNet/runs/e0_s3_seed0", "target_config": "configs/e0_baseline/imagenet_gmnet_s3.yaml", } for key, expected in required_registration.items(): if record.get(key) != expected: raise ValueError(f"historical baseline registration drifted: {key}") require_sha256( record.get("semantic_projection_sha256"), "historical_baseline.semantic_projection_sha256", ) run_dir = Path(record["run_dir"]) expected_files = record.get("expected") if not isinstance(expected_files, dict) or not expected_files: raise ValueError("historical baseline hashes are missing") for relative, expected_sha in expected_files.items(): require_sha256(expected_sha, f"historical_baseline.expected.{relative}") path = run_dir / relative if not path.is_file(): raise FileNotFoundError(f"missing historical baseline artifact: {path}") actual_sha = file_sha256(path) if actual_sha != expected_sha: raise ValueError( f"historical baseline hash mismatch for {relative}: {actual_sha}" ) official = record.get("official", {}) checks = load_json(run_dir / "official_eval/checks.json") results = load_json(run_dir / "official_eval/results.json") manifest = load_json(run_dir / "data_manifest.json") if checks.get("status") != "passed": raise ValueError("historical baseline official checks did not pass") if checks.get("checkpoint_sha256") != expected_files["checkpoint_last.pt"]: raise ValueError("historical baseline checkpoint identity drifted") if checks.get("artifacts_sha256") != official.get("artifacts_sha256"): raise ValueError("historical baseline artifact identity drifted") if results.get("status") != "complete" or results.get("partial_evaluation"): raise ValueError("historical baseline evaluation is incomplete") scalar_expected = { "run_name": "e0_s3_seed0", "seed": 0, "gate_type": "relu6_self", "checkpoint_epoch": 299, "training_epochs": 300, } for key, expected in scalar_expected.items(): if results.get(key) != expected: raise ValueError(f"historical baseline result drifted: {key}") if not math.isclose( float(results.get("metrics", {}).get("top1", float("nan"))), float(official.get("top1", float("nan"))), rel_tol=0.0, abs_tol=1e-9, ): raise ValueError("historical baseline Top-1 drifted") if results.get("metrics", {}).get("samples") != 50000: raise ValueError("historical baseline evaluated sample count drifted") hashes = results.get("hashes", {}) if hashes.get("config_sha256") != official.get("checkpoint_config_sha256"): raise ValueError("historical baseline checkpoint config identity drifted") if ( hashes.get("checkpoint_data_manifest_sha256") != protocol["data"]["canonical_manifest_sha256"] ): raise ValueError("historical baseline checkpoint data identity drifted") topology = results.get("topology", {}) for key in ("parameter_count", "state_tensor_count", "model_state_schema_sha256"): if topology.get(key) != official.get(key): raise ValueError(f"historical baseline topology drifted: {key}") completion_expected = { "epoch_complete": True, "expected_global_step": 187500, "expected_steps_per_epoch": 625, "global_step": 187500, "steps_in_epoch": 625, "training_complete": True, "world_size": 8, } completion = results.get("training_completion", {}) for key, expected in completion_expected.items(): if completion.get(key) != expected: raise ValueError(f"historical training completion drifted: {key}") data = protocol["data"] data_expected = { "manifest_sha256": data["canonical_manifest_sha256"], "num_classes": 1000, "samples": { "train": data["expected_train_samples"], "val": data["expected_val_samples"], }, "sample_index_sha256": { "train": data["train_sample_index_sha256"], "val": data["val_sample_index_sha256"], }, "sampled_content_sha256": { "train": data["train_sampled_content_sha256"], "val": data["val_sampled_content_sha256"], }, } for key, expected in data_expected.items(): if manifest.get(key) != expected: raise ValueError(f"historical data manifest drifted: {key}") resolved = load_yaml(run_dir / "config_resolved.yaml") target = load_resolved_config(JOURNAL_ROOT / record["target_config"]) legacy_semantics = normalized_training_semantics(resolved) target_semantics = normalized_training_semantics(target) if legacy_semantics != target_semantics: raise ValueError("historical/current baseline config semantics differ") if stable_sha256(legacy_semantics) != record["semantic_projection_sha256"]: raise ValueError("historical baseline semantic projection drifted") def verify_smoke_evidence( protocol: dict[str, Any], tasks: list[E4Task], code_sha256: str, manifest_sha256: str, ) -> tuple[dict[str, Any], str]: evidence = load_json(SMOKE_EVIDENCE_PATH) required = { "schema_version": 1, "protocol_id": protocol["protocol_id"], "status": "passed", "code_sha256": code_sha256, "code_manifest_path": CODE_MANIFEST_RELATIVE_PATH, "code_manifest_sha256": manifest_sha256, "world_size": 8, "strict_resume": True, } for key, expected in required.items(): if evidence.get(key) != expected: raise ApprovalError(f"E4 smoke evidence field drifted: {key}") smoke_tasks = evidence.get("tasks") if not isinstance(smoke_tasks, dict) or set(smoke_tasks) != set(TASK_IDS): raise ApprovalError("E4 smoke evidence task matrix or ordering drifted") for task in tasks: record = smoke_tasks.get(task.task_id) if not isinstance(record, dict): raise ApprovalError(f"missing E4 smoke task: {task.task_id}") task_required = { "gate_intervention": task.gate_intervention, "gate_intervention_seed": task.gate_intervention_seed, "resume_verified": True, "training_complete": True, } for key, expected in task_required.items(): if record.get(key) != expected: raise ApprovalError(f"E4 smoke evidence drifted: {task.task_id}/{key}") first = require_sha256( record.get("checkpoint_epoch0_sha256"), f"smoke.tasks.{task.task_id}.checkpoint_epoch0_sha256", ) final = require_sha256( record.get("checkpoint_last_sha256"), f"smoke.tasks.{task.task_id}.checkpoint_last_sha256", ) if first == final: raise ApprovalError( f"E4 smoke resume did not advance checkpoint: {task.task_id}" ) return evidence, file_sha256(SMOKE_EVIDENCE_PATH) def load_base_invariants() -> dict[str, Any]: source = load_yaml(BASE_TEMPLATE) required = (*RESOURCE_KEYS, *PROJECT_KEYS) missing = [key for key in required if key not in source] if missing: raise ValueError(f"base launch template missing: {', '.join(missing)}") if source.get("gpu_num") != "8" or source.get("gpu_type") != "nvidia-tesla-a100": raise ValueError("base launch template must request eight A100 GPUs") mounts = source.get("mount") if not isinstance(mounts, list): raise ValueError("base launch template mounts are invalid") mount_paths = {item.get("mount_path") for item in mounts if isinstance(item, dict)} if "/nfs" not in mount_paths or "/s3-code" not in mount_paths: raise ValueError("base launch template is missing required NFS/S3 mounts") return {key: copy.deepcopy(source[key]) for key in required} def _deny_completed_output(task: E4Task) -> None: checks_path = task.output_dir / "official_eval/checks.json" if not checks_path.is_file(): return try: checks = load_json(checks_path) except (json.JSONDecodeError, ValueError): return if checks.get("status") == "passed": raise ApprovalError( f"E4 guard denied {task.task_id}: output already passed official evaluation" ) def approval_payload( protocol: dict[str, Any], task: E4Task, code_sha256: str, manifest_sha256: str, smoke: dict[str, Any], smoke_sha256: str, ) -> dict[str, Any]: smoke_task = smoke["tasks"][task.task_id] return { "schema_version": 1, "protocol_id": protocol["protocol_id"], "task_id": task.task_id, "status": "approved", "approval_basis": "passed_8gpu_strict_resume_smoke", "config_path": task.config_path, "output_dir": str(task.output_dir), "gate_intervention": task.gate_intervention, "gate_intervention_seed": task.gate_intervention_seed, "code_sha256": code_sha256, "code_manifest_path": CODE_MANIFEST_RELATIVE_PATH, "code_manifest_sha256": manifest_sha256, "smoke_evidence_path": str(SMOKE_EVIDENCE_PATH), "smoke_evidence_sha256": smoke_sha256, "smoke_checkpoint_last_sha256": smoke_task["checkpoint_last_sha256"], } def verify_approval( protocol: dict[str, Any], task: E4Task, code_sha256: str, manifest_sha256: str, smoke: dict[str, Any], smoke_sha256: str, ) -> None: if not task.approval_path.is_file(): raise ApprovalError( f"E4 guard denied {task.task_id}: missing {task.approval_path}" ) marker = load_json(task.approval_path) expected = approval_payload( protocol, task, code_sha256, manifest_sha256, smoke, smoke_sha256, ) if marker != expected: drifted = sorted( key for key in set(marker) | set(expected) if marker.get(key) != expected.get(key) ) raise ApprovalError( f"E4 guard denied {task.task_id}: approval drifted ({','.join(drifted)})" ) def verify_task(task_id: str, require_approval: bool) -> None: protocol = load_protocol() tasks = build_tasks(protocol) task = next((item for item in tasks if item.task_id == task_id), None) if task is None: raise ValueError(f"unknown E4 alignment task: {task_id}") code_sha256, manifest_sha256 = verify_code_manifest() verify_historical_baseline(protocol) smoke, smoke_sha256 = verify_smoke_evidence( protocol, tasks, code_sha256, manifest_sha256 ) _deny_completed_output(task) if require_approval: verify_approval( protocol, task, code_sha256, manifest_sha256, smoke, smoke_sha256, ) print( f"Verified E4 alignment task {task.task_id}: code={code_sha256}, " f"smoke={smoke_sha256}, baseline={protocol['historical_baseline']['evidence_id']}" ) def build_launch_document( protocol: dict[str, Any], task: E4Task, invariants: dict[str, Any] ) -> dict[str, Any]: verify = ( "/tmp/gmnet_venv/bin/python " "scripts/generate_e4_alignment_deploy.py " f"--verify-task {task.task_id} --require-approval" ) pre_run = ( f"cd {JOURNAL_ROOT} && chmod +x ./scripts/*.sh && " "INSTALL_DEV=0 bash ./scripts/setup_env.sh && " f"{verify} && " "KEEP_ARCHIVE=0 bash ./scripts/stage_imagenet.sh full && " f"{verify}" ) assignments = " ".join( ( f"RUN_NAME={task.task_id}", f"CONFIG_PATH={task.config_path}", f"DATA_ROOT={protocol['data']['runtime_root']}", f"OUTPUT_DIR={task.output_dir}", f"SEED={task.seed}", "NPROC_PER_NODE=8", "RESUME=auto", "POST_EVAL=1", f"CODE_MANIFEST_PATH={CODE_MANIFEST_RELATIVE_PATH}", ) ) command = ( f"cd {JOURNAL_ROOT} && {verify} && {assignments} " "bash scripts/run_e4_alignment.sh" ) document: dict[str, Any] = { key: copy.deepcopy(invariants[key]) for key in RESOURCE_KEYS } document["script"] = { "pre_run_event": pre_run, "command": command, "jobs": [{"name": task.job_name}], } document.update({key: copy.deepcopy(invariants[key]) for key in PROJECT_KEYS}) return document def dump_yaml(value: Any) -> str: return GENERATED_HEADER + yaml.safe_dump( value, sort_keys=False, default_flow_style=False, width=1_000_000, ) def build_batch_manifest( protocol: dict[str, Any], tasks: list[E4Task], code_sha256: str, manifest_sha256: str, smoke_sha256: str, ) -> dict[str, Any]: records = [] for task in tasks: record = asdict(task) record.update( { "deploy_path": str(task.deploy_path), "approval_path": str(task.approval_path), "output_dir": str(task.output_dir), "job_name": task.job_name, "eta_class": ">12h", } ) records.append(record) return { "schema_version": 1, "protocol_id": protocol["protocol_id"], "protocol_source": str(PROTOCOL_PATH), "protocol_sha256": file_sha256(PROTOCOL_PATH), "generated_by": str(SCRIPT_PATH), "source_template": str(BASE_TEMPLATE), "source_template_sha256": file_sha256(BASE_TEMPLATE), "code_manifest_path": CODE_MANIFEST_RELATIVE_PATH, "code_manifest_sha256": manifest_sha256, "code_sha256": code_sha256, "smoke_evidence_path": str(SMOKE_EVIDENCE_PATH), "smoke_evidence_sha256": smoke_sha256, "historical_baseline": copy.deepcopy(protocol["historical_baseline"]), "relationship_to_prior_work": protocol["relationship_to_prior_work"], "known_before_registration": copy.deepcopy( protocol["known_before_registration"] ), "claim_restrictions": copy.deepcopy(protocol["claim_restrictions"]), "policy": copy.deepcopy(protocol["policy"]), "data": copy.deepcopy(protocol["data"]), "run_root": str(RUN_ROOT), "summary": { "task_count": len(tasks), "approved_count": len(tasks), "seed_count": 1, }, "tasks": records, } def expected_files() -> dict[Path, str]: protocol = load_protocol() tasks = build_tasks(protocol) code_sha256, manifest_sha256 = verify_code_manifest() verify_historical_baseline(protocol) smoke, smoke_sha256 = verify_smoke_evidence( protocol, tasks, code_sha256, manifest_sha256 ) invariants = load_base_invariants() files = { task.deploy_path: dump_yaml(build_launch_document(protocol, task, invariants)) for task in tasks } files[BATCH_ROOT / "batch_manifest.json"] = ( json.dumps( build_batch_manifest( protocol, tasks, code_sha256, manifest_sha256, smoke_sha256 ), indent=2, sort_keys=True, ) + "\n" ) for task in tasks: files[task.approval_path] = ( json.dumps( approval_payload( protocol, task, code_sha256, manifest_sha256, smoke, smoke_sha256, ), indent=2, sort_keys=True, ) + "\n" ) return files def write_files(files: dict[Path, str]) -> None: for path, content in files.items(): path.parent.mkdir(parents=True, exist_ok=True) if path.is_file() and path.read_text(encoding="utf-8") == content: continue temporary = path.with_name(f".{path.name}.tmp") temporary.write_text(content, encoding="utf-8") temporary.replace(path) expected = set(files) for path in BATCH_ROOT.glob("*.yaml"): if path in expected: continue if path.read_text(encoding="utf-8").startswith(GENERATED_HEADER): path.unlink() def check_files(files: dict[Path, str]) -> list[str]: errors = [] for path, expected in files.items(): if not path.is_file(): errors.append(f"missing: {path}") elif path.read_text(encoding="utf-8") != expected: errors.append(f"stale: {path}") for path in BATCH_ROOT.glob("*.yaml"): if path in files: continue if path.read_text(encoding="utf-8").startswith(GENERATED_HEADER): errors.append(f"stale generated file: {path}") return errors def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser(description=__doc__) action = parser.add_mutually_exclusive_group() action.add_argument("--check", action="store_true") action.add_argument("--verify-task") parser.add_argument("--require-approval", action="store_true") return parser.parse_args() def main() -> int: args = parse_args() try: if args.verify_task: verify_task(args.verify_task, args.require_approval) return 0 files = expected_files() tasks = build_tasks() if args.check: errors = check_files(files) if errors: print("\n".join(errors), file=sys.stderr) return 1 print( f"Validated {len(tasks)} E4 launch YAMLs, batch manifest, " "approvals, code, smoke, and historical baseline" ) return 0 write_files(files) print( f"Generated {len(tasks)} E4 launch YAMLs under {BATCH_ROOT}; " "no launchjob was submitted" ) return 0 except ApprovalError as error: print(str(error), file=sys.stderr) return 64 if __name__ == "__main__": raise SystemExit(main())