| """Prepare evaluator-owned base/gold/candidate source trees and test materials.""" |
| import argparse |
| import json |
| from pathlib import Path |
| import shutil |
| import subprocess |
| from common import ROOT, contained, load_task, run, sha256 |
| from prepare_workspace import prepare |
| from fetch_sources import fetch |
|
|
|
|
| def apply_patch(repository, path): |
| run("git", "-C", str(repository), "apply", "--check", str(path)) |
| run("git", "-C", str(repository), "apply", str(path)) |
|
|
|
|
| def stage(task, output, cache_root, world, candidates=None): |
| output = Path(output).resolve() |
| if output.exists(): |
| raise ValueError(f"Output already exists: {output}") |
| if output.is_relative_to(ROOT) or ROOT.is_relative_to(output): |
| raise ValueError("Evaluator directory must remain outside the release") |
| task_root = contained(ROOT / "instances", task["instance_id"]) |
| contract = json.loads((task_root / task["evaluation"]["path"]).read_text()) |
| if contract["kind"] != "command_contract": |
| raise ValueError("Native contracts require their task-specific adapters; this entry point handles command contracts") |
| candidates = candidates or {} |
| keys = {r["key"] for r in task["repositories"]} |
| if set(candidates) - keys: |
| raise ValueError("Candidate patch references an unknown repository") |
| if world != "candidate" and candidates: |
| raise ValueError("Candidate patches require --world candidate") |
| for ref in task["artifacts"]: |
| path = contained(task_root, ref["path"]) |
| if sha256(path) != ref["sha256"]: |
| raise ValueError(f"Artifact changed: {path}") |
| patch_variants = {} |
| compatibility = task_root / "evaluation/test-preparation.json" |
| if compatibility.is_file(): |
| configuration = json.loads(compatibility.read_text()) |
| if configuration["schema_version"] != 1 or configuration["instance_id"] != task["instance_id"]: |
| raise ValueError("Test preparation contract does not match the task") |
| refs = {ref["path"]: ref for ref in task["artifacts"]} |
| for variant in configuration["patch_variants"]: |
| repo = next((r for r in task["repositories"] if r["key"] == variant["repository"]), None) |
| if not repo or variant["original"] not in repo["test_patches"]: |
| raise ValueError("Compatibility variant is not a declared test patch") |
| key = (repo["key"], variant["original"]["path"]) |
| if key in patch_variants: |
| raise ValueError("Duplicate test compatibility declaration") |
| for alternative in variant["alternatives"]: |
| if refs.get(alternative["path"]) != alternative: |
| raise ValueError("Compatibility test artifact differs") |
| patch_variants[key] = variant["alternatives"] |
| applied_test_variants = [] |
| prepare(task, cache_root, output / "sources") |
| caches = fetch(task, cache_root) |
| files_root = output / "files" |
| files_root.mkdir() |
| mounts = [] |
| for entry in contract["commands"]: |
| if entry.get("evaluation_config"): |
| config = contained(files_root, entry["repository"] + ".evaluation.config.mjs") |
| config.write_text(entry["evaluation_config"]) |
| for repo in task["repositories"]: |
| source = contained(output / "sources", repo["workspace_path"]) |
| |
| |
| run("git", "-C", str(source), "fetch", "--depth=1", "--no-tags", str(caches[repo["key"]]), repo["base_commit"]) |
| run("git", "-C", str(source), "checkout", "-B", "main", repo["base_commit"]) |
| if run("git", "-C", str(source), "rev-parse", "HEAD", capture=True).strip() != repo["base_commit"]: |
| raise ValueError("Evaluator base revision differs from pinned source") |
| if world == "gold": |
| apply_patch(source, contained(task_root, repo["gold_patch"]["path"])) |
| elif world == "candidate" and repo["key"] in candidates: |
| apply_patch(source, Path(candidates[repo["key"]]).resolve()) |
| for ref in repo["test_patches"]: |
| choices = [ref, *patch_variants.get((repo["key"], ref["path"]), [])] |
| selected = None |
| for choice in choices: |
| path = contained(task_root, choice["path"]) |
| checked = subprocess.run(["git", "-C", str(source), "apply", "--check", str(path)], |
| stdout=subprocess.PIPE, stderr=subprocess.PIPE) |
| if checked.returncode == 0: |
| apply_patch(source, path) |
| selected = choice |
| break |
| if selected is None: |
| raise ValueError(f"Frozen test patch and its declared compatibility variants do not apply: {ref['path']}") |
| applied_test_variants.append({"repository": repo["key"], "original": ref["path"], "applied": selected["path"]}) |
| mounts.append({"source": str(source), "target": repo["container_path"], "read_only": False}) |
| for ref in contract["test_files"]: |
| source = contained(task_root, ref["path"]) |
| if ref.get("original_container_path"): |
| target = contained(output / "image-probes", ref["path"]) |
| target.parent.mkdir(parents=True, exist_ok=True) |
| shutil.copyfile(source, target) |
| target.chmod(0o755) |
| mounts.append({"source": str(target), "target": ref["original_container_path"], "read_only": True}) |
| else: |
| name = ref.get("original_path") |
| if not name: |
| raise ValueError(f"No container layout supplied for {ref['path']}") |
| target = contained(files_root, name) |
| target.parent.mkdir(parents=True, exist_ok=True) |
| shutil.copyfile(source, target) |
| if target.suffix == ".sh": |
| target.chmod(0o755) |
| mounts.append({"source": str(files_root), "target": "/crossrepo-patches", "read_only": True}) |
| contract["evaluation_world"] = {"base": "all_buggy", "gold": "all_fixed", "candidate": "candidate"}[world] |
| (output / "contract.json").write_text(json.dumps(contract, indent=2) + "\n") |
| (output / "mounts.json").write_text(json.dumps(mounts, indent=2) + "\n") |
| (output / "preparation.json").write_text(json.dumps({"instance_id": task["instance_id"], "world": world, |
| "contract_sha256": sha256(output / "contract.json"), "test_patch_applications": applied_test_variants, "source_histories": "Shallow pinned base objects imported only in evaluator sources; reference/test patches applied only here. Agent sources retain independent histories."}, indent=2) + "\n") |
| return output |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--instance-id", required=True) |
| parser.add_argument("--output-dir", type=Path, required=True) |
| parser.add_argument("--source-cache", type=Path) |
| parser.add_argument("--world", choices=["base", "gold", "candidate"], default="base") |
| parser.add_argument("--candidate-patches", type=Path, help="JSON object mapping repository keys to patch paths; relative paths use the JSON file's directory") |
| args = parser.parse_args() |
| candidates = None |
| if args.candidate_patches: |
| values = json.loads(args.candidate_patches.read_text()) |
| candidates = {key: str((args.candidate_patches.resolve().parent / value).resolve()) for key, value in values.items()} |
| task = load_task(args.instance_id) |
| stage(task, args.output_dir, |
| args.source_cache or ROOT / ".cache/source-repos" / task["instance_id"], args.world, candidates) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
