release v3: add judge_generate.py (scope check, Judge regeneration, manifest verification)

adapter/r2e_local/judge_generate.py

@@ -0,0 +1,252 @@
+"""Judge generation stage: execute the candidate's pipeline patch, Judge-owned.
+
+Binds the scored task set to execution of the submitted inputs:
+
+  1. Scope check. Every hunk of the candidate diff must target a path in the
+     editable set; binary hunks, any other path, and a configuration that sets
+     `skip_validation` or `limit` are candidate-invalid (exit 3, no task set).
+  2. Apply. A fresh copy of the pinned Repo2RLEnv tree receives the patch
+     (`git apply --check` first, then `git apply`).
+  3. Run. The patched pipeline runs over the DEV repositories with the fixed
+     configuration through the same LocalSandbox driver Work uses, from a
+     subprocess with no network. Only the DEV corpus, bootstrap.json files and
+     this adapter are needed on the filesystem.
+  4. Emit. `<out>/tasks/<owner__name>/<task_id>/...`, `<out>/generation.json`
+     (per-repository PipelineResult), `<out>/scope_check.json`.
+
+Judge then re-verifies its frozen assets against the dataset manifest
+(verify_manifest below) before admission, training and grading.
+
+Usage:
+  python -m r2e_local.judge_generate --patch candidate.diff --config candidate_options.json \
+      --r2e-src <pinned Repo2RLEnv checkout> --corpus corpus.tsv --mirrors <repos root> \
+      --sandboxes <sandbox root> --bootstrap <bootstrap root> --out <dir> \
+      [--llm-endpoint http://127.0.0.1:8000/v1 --llm hosted_vllm/Qwen/Qwen3.5-4B] [--parallel 4]
+  python -m r2e_local.judge_generate verify-manifest --release <dir> --manifest manifest.json
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import re
+import shutil
+import subprocess
+import sys
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+EDITABLE_FILES = {
+    "src/repo2rlenv/pipelines/commit_runtime.py",
+    "src/repo2rlenv/pipelines/pr_runtime.py",
+    "src/repo2rlenv/spec/options.py",
+}
+# pr_runtime.py: only these functions may change; enforced by symbol diff below.
+EDITABLE_PR_RUNTIME_FUNCS = {
+    "split_patch_and_test_patch", "_strip_info_leak", "_reflow_pr_body", "_count_new_test_funcs",
+    "_diff_loc_changed", "_difficulty_bucket", "_files_in_patch", "_linked_issue_number",
+}
+FROZEN_IN_COMMIT_RUNTIME = {"_start_validation_sandbox"}
+FROZEN_OPTIONS = {"skip_validation": False, "limit": 100000}
+
+_DIFF_FILE = re.compile(r"^diff --git a/(\S+) b/(\S+)$", re.M)
+_HUNK_HEADER = re.compile(r"^@@ .* @@\s*(?:(?:async )?def (\w+)|class (\w+))?", re.M)
+
+
+def sha256(p: Path) -> str:
+    h = hashlib.sha256()
+    with p.open("rb") as f:
+        for chunk in iter(lambda: f.read(1 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def _defs_of(src: str) -> dict[str, tuple[int, int]]:
+    """Top-level def/class name -> (start_line, end_line) using indentation."""
+    lines = src.splitlines()
+    out: dict[str, tuple[int, int]] = {}
+    current: str | None = None
+    start = 0
+    for i, line in enumerate(lines):
+        m = re.match(r"^(?:async\s+)?(?:def|class)\s+(\w+)", line)
+        if m:
+            if current is not None:
+                out[current] = (start, i)
+            current, start = m.group(1), i
+        elif current is not None and line and not line[0].isspace() and not line.startswith(("#", ")", "]", "}")):
+            out[current] = (start, i)
+            current = None
+    if current is not None:
+        out[current] = (start, len(lines))
+    return out
+
+
+def changed_symbols(before: str, after: str) -> set[str]:
+    """Top-level symbols whose text differs, plus '<module>' for changes outside any def/class."""
+    db, da = _defs_of(before), _defs_of(after)
+    lb, la = before.splitlines(), after.splitlines()
+    changed: set[str] = set()
+    for name in set(db) | set(da):
+        tb = "\n".join(lb[db[name][0]:db[name][1]]) if name in db else None
+        ta = "\n".join(la[da[name][0]:da[name][1]]) if name in da else None
+        if tb != ta:
+            changed.add(name)
+    def module_text(lines, defs):
+        keep = [True] * len(lines)
+        for s, e in defs.values():
+            for i in range(s, e):
+                keep[i] = False
+        return "\n".join(l for l, k in zip(lines, keep) if k)
+    if module_text(lb, db) != module_text(la, da):
+        changed.add("<module>")
+    return changed
+
+
+def scope_check(patch_text: str, r2e_src: Path, config: dict) -> dict:
+    problems: list[str] = []
+    files = [m.group(2) for m in _DIFF_FILE.finditer(patch_text)]
+    if not files:
+        problems.append("no file hunks in patch")
+    for f in files:
+        if f not in EDITABLE_FILES:
+            problems.append(f"path outside editable set: {f}")
+    if "GIT binary patch" in patch_text or "Binary files" in patch_text:
+        problems.append("binary hunk")
+    for k, v in FROZEN_OPTIONS.items():
+        if k in config and config[k] != v:
+            problems.append(f"frozen option {k} set to {config[k]!r}")
+    # Symbol-level check for pr_runtime.py and the frozen sandbox hook.
+    if not problems and files:
+        tmp = Path(shutil.copytree(r2e_src, r2e_src.parent / (r2e_src.name + ".scopecheck"), dirs_exist_ok=True))
+        try:
+            (tmp / "candidate.diff").write_text(patch_text)
+            r = subprocess.run(["git", "apply", "--check", "candidate.diff"], cwd=tmp, capture_output=True, text=True)
+            if r.returncode != 0:
+                problems.append("patch does not apply: " + r.stderr.strip()[-300:])
+            else:
+                subprocess.run(["git", "apply", "candidate.diff"], cwd=tmp, check=True, capture_output=True)
+                for f in files:
+                    before = (r2e_src / f).read_text()
+                    after = (tmp / f).read_text()
+                    syms = changed_symbols(before, after)
+                    if f.endswith("pr_runtime.py"):
+                        bad = syms - EDITABLE_PR_RUNTIME_FUNCS
+                        if bad:
+                            problems.append(f"pr_runtime.py: non-editable symbols changed: {sorted(bad)}")
+                    if f.endswith("commit_runtime.py") and syms & FROZEN_IN_COMMIT_RUNTIME:
+                        problems.append("commit_runtime.py: frozen _start_validation_sandbox changed")
+        finally:
+            shutil.rmtree(tmp, ignore_errors=True)
+    return {"ok": not problems, "files": files, "problems": problems}
+
+
+def run_generation(args) -> int:
+    out = Path(args.out)
+    out.mkdir(parents=True, exist_ok=True)
+    patch_text = Path(args.patch).read_text()
+    config = json.loads(Path(args.config).read_text()) if args.config else {}
+    check = scope_check(patch_text, Path(args.r2e_src), config)
+    (out / "scope_check.json").write_text(json.dumps(check, indent=2))
+    if not check["ok"]:
+        print(json.dumps({"status": "candidate_invalid", "problems": check["problems"]}))
+        return 3
+
+    # Fresh patched tree, installed into the Judge interpreter in place.
+    tree = out / "repo2rlenv_patched"
+    if tree.exists():
+        shutil.rmtree(tree)
+    shutil.copytree(Path(args.r2e_src), tree, ignore=shutil.ignore_patterns(".git", "__pycache__"))
+    (tree / "candidate.diff").write_text(patch_text)
+    subprocess.run(["git", "init", "-q"], cwd=tree, check=True)
+    subprocess.run(["git", "apply", "candidate.diff"], cwd=tree, check=True, capture_output=True)
+
+    corpus = [l.split("\t") for l in Path(args.corpus).read_text().splitlines() if l.strip()]
+    dev = [(repo, sha) for split, repo, sha in corpus if split == "dev"]
+    opts = {**{k: v for k, v in config.items() if k not in FROZEN_OPTIONS}, **FROZEN_OPTIONS}
+    opt_flags = [f"--opt {k}={json.dumps(v) if not isinstance(v, (bool, int, float, str)) else v}" for k, v in opts.items()]
+    adapter_dir = Path(__file__).resolve().parent.parent
+
+    def one(item):
+        repo, sha = item
+        key = repo.replace("/", "__")
+        cmd = [
+            sys.executable, "-m", "r2e_local.driver", "--repo", repo, "--sha", sha,
+            "--mirror", str(Path(args.mirrors) / key), "--sandbox", str(Path(args.sandboxes) / key),
+            "--bootstrap", str(Path(args.bootstrap) / key / "bootstrap.json"),
+            "--out", str(out / "tasks" / key),
+        ]
+        if args.llm:
+            cmd += ["--llm", args.llm]
+            if args.llm_endpoint:
+                cmd += ["--llm-endpoint", args.llm_endpoint]
+            if args.llm_key_env:
+                cmd += ["--llm-key-env", args.llm_key_env]
+        for f in opt_flags:
+            cmd += f.split(" ", 1)
+        env = {"PYTHONPATH": f"{tree / 'src'}:{adapter_dir}", "PATH": "/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin", "HOME": str(out / ".home")}
+        (out / ".home").mkdir(exist_ok=True)
+        r = subprocess.run(cmd, capture_output=True, text=True, env=env, timeout=args.repo_timeout)
+        res_path = out / "tasks" / key / "result.json"
+        res = json.loads(res_path.read_text()) if res_path.exists() else {"repo": repo, "error": r.stderr[-800:]}
+        res["returncode"] = r.returncode
+        return res
+
+    with ThreadPoolExecutor(max_workers=args.parallel) as ex:
+        results = list(ex.map(one, dev))
+    summary = {
+        "repos": len(dev),
+        "emitted": sum(r.get("emitted", 0) for r in results),
+        "failed_repos": [r["repo"] for r in results if r.get("returncode", 0) != 0],
+        "options": opts,
+        "patch_sha256": hashlib.sha256(patch_text.encode()).hexdigest(),
+        "per_repo": results,
+    }
+    (out / "generation.json").write_text(json.dumps(summary, indent=2))
+    print(json.dumps({k: summary[k] for k in ("repos", "emitted", "failed_repos")}))
+    return 0
+
+
+def verify_manifest(args) -> int:
+    rel = Path(args.release)
+    manifest = json.loads(Path(args.manifest).read_text())
+    bad = []
+    for relpath, digest in manifest["files"].items():
+        p = rel / relpath
+        if not p.is_file() or sha256(p) != digest:
+            bad.append(relpath)
+    print(json.dumps({"verified": len(manifest["files"]) - len(bad), "mismatched": bad[:50], "ok": not bad}))
+    return 0 if not bad else 4
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser()
+    sub = ap.add_subparsers(dest="cmd")
+    g = sub.add_parser("generate")
+    g.add_argument("--patch", required=True)
+    g.add_argument("--config", default=None)
+    g.add_argument("--r2e-src", required=True)
+    g.add_argument("--corpus", required=True)
+    g.add_argument("--mirrors", required=True)
+    g.add_argument("--sandboxes", required=True)
+    g.add_argument("--bootstrap", required=True)
+    g.add_argument("--out", required=True)
+    g.add_argument("--llm", default=None)
+    g.add_argument("--llm-endpoint", default=None)
+    g.add_argument("--llm-key-env", default=None)
+    g.add_argument("--parallel", type=int, default=4)
+    g.add_argument("--repo-timeout", type=int, default=7200)
+    v = sub.add_parser("verify-manifest")
+    v.add_argument("--release", required=True)
+    v.add_argument("--manifest", required=True)
+    args = ap.parse_args(argv)
+    if args.cmd == "generate":
+        return run_generation(args)
+    if args.cmd == "verify-manifest":
+        return verify_manifest(args)
+    ap.print_help()
+    return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())