| """SWE-DockerLess evaluation harness. |
| |
| No Docker, no network, no prebuilt images: every instance carries its own repo |
| snapshot inside the JSONL row, so the harness only needs Python, git and pytest. |
| |
| Usage |
| ----- |
| # sanity check: score the gold patches (expect 4/4 resolved) |
| python run_harness.py --dataset SWE-DockerLess.jsonl --gold |
| |
| # score a predictions file: one JSON object per line with |
| # {"instance_id": ..., "model_name_or_path": ..., "model_patch": ...} |
| python run_harness.py --dataset SWE-DockerLess.jsonl \ |
| --predictions predictions.jsonl --out report.json |
| |
| A prediction is "resolved" when every FAIL_TO_PASS test passes and every |
| PASS_TO_PASS test still passes, which is the SWE-bench rule. |
| """ |
|
|
| import argparse |
| import json |
| import os |
| import re |
| import shutil |
| import subprocess |
| import sys |
| import tempfile |
| import time |
| from pathlib import Path |
|
|
| GIT_FLAGS = [ |
| "-c", "core.autocrlf=false", |
| "-c", "core.safecrlf=false", |
| "-c", "user.name=harness", |
| "-c", "user.email=harness@example.invalid", |
| "-c", "commit.gpgsign=false", |
| ] |
|
|
| RESULT_RE = re.compile( |
| r"^(tests/[^\s:]+::[^\s]+)\s+(PASSED|FAILED|ERROR|SKIPPED|XFAIL|XPASS)" |
| ) |
|
|
|
|
| def run(cmd, cwd, check=True): |
| env = os.environ.copy() |
| env.setdefault("GIT_AUTHOR_NAME", "harness") |
| env.setdefault("GIT_AUTHOR_EMAIL", "harness@example.invalid") |
| env.setdefault("GIT_COMMITTER_NAME", "harness") |
| env.setdefault("GIT_COMMITTER_EMAIL", "harness@example.invalid") |
| proc = subprocess.run( |
| cmd, cwd=str(cwd), capture_output=True, text=True, encoding="utf-8", env=env |
| ) |
| if check and proc.returncode != 0: |
| raise RuntimeError( |
| "command failed (%d): %s\n%s\n%s" |
| % (proc.returncode, " ".join(cmd), proc.stdout[-4000:], proc.stderr[-4000:]) |
| ) |
| return proc |
|
|
|
|
| def git(args, cwd, check=True): |
| return run(["git"] + GIT_FLAGS + args, cwd, check=check) |
|
|
|
|
| def write_snapshot(files, dest): |
| for rel, content in files.items(): |
| path = dest / rel |
| path.parent.mkdir(parents=True, exist_ok=True) |
| with open(path, "w", encoding="utf-8", newline="\n") as handle: |
| handle.write(content) |
|
|
|
|
| def apply_patch(patch_text, work, tmp, label): |
| """Apply a unified diff; return (ok, message).""" |
| if not patch_text or not patch_text.strip(): |
| return False, "empty patch" |
| patch_file = Path(tmp) / (label + ".patch") |
| patch_file.write_text(patch_text, encoding="utf-8", newline="\n") |
| first = git(["apply", "--check", str(patch_file)], work, check=False) |
| if first.returncode == 0: |
| git(["apply", str(patch_file)], work) |
| return True, "applied" |
| second = git(["apply", "--check", "--recount", "-C1", str(patch_file)], work, check=False) |
| if second.returncode == 0: |
| git(["apply", "--recount", "-C1", str(patch_file)], work) |
| return True, "applied (recount)" |
| return False, (first.stderr or first.stdout).strip().splitlines()[0:3] |
|
|
|
|
| def run_tests(work, test_files, cmd_template): |
| cmd = [sys.executable, "-m", "pytest", "-v", "--tb=no", "-p", "no:cacheprovider"] |
| cmd += list(test_files) |
| proc = run(cmd, work, check=False) |
| outcomes = {} |
| for raw in proc.stdout.splitlines(): |
| match = RESULT_RE.match(raw.strip()) |
| if match: |
| outcomes[match.group(1)] = match.group(2) |
| return outcomes, proc |
|
|
|
|
| def evaluate(row, model_patch): |
| test_files = row["dockerless"]["test_files"] |
| f2p = json.loads(row["FAIL_TO_PASS"]) |
| p2p = json.loads(row["PASS_TO_PASS"]) |
|
|
| with tempfile.TemporaryDirectory(prefix="swedl-eval-") as tmp: |
| work = Path(tmp) / "work" |
| work.mkdir() |
| write_snapshot(row["dockerless"]["files"], work) |
| git(["init", "-q", "-b", "main"], work) |
| git(["add", "-A"], work) |
| git(["commit", "-q", "-m", row["base_commit"]], work) |
|
|
| ok, message = apply_patch(row["test_patch"], work, tmp, "test") |
| if not ok: |
| return { |
| "instance_id": row["instance_id"], |
| "resolved": False, |
| "reason": "test_patch failed to apply: %s" % (message,), |
| "f2p_passed": 0, |
| "f2p_total": len(f2p), |
| "p2p_passed": 0, |
| "p2p_total": len(p2p), |
| } |
|
|
| ok, message = apply_patch(model_patch, work, tmp, "model") |
| if not ok: |
| return { |
| "instance_id": row["instance_id"], |
| "resolved": False, |
| "reason": "model patch failed to apply: %s" % (message,), |
| "f2p_passed": 0, |
| "f2p_total": len(f2p), |
| "p2p_passed": 0, |
| "p2p_total": len(p2p), |
| } |
|
|
| outcomes, proc = run_tests(work, test_files, row["dockerless"]["test_cmd"]) |
|
|
| if not outcomes: |
| return { |
| "instance_id": row["instance_id"], |
| "resolved": False, |
| "reason": "no tests collected (collection error?)", |
| "f2p_passed": 0, |
| "f2p_total": len(f2p), |
| "p2p_passed": 0, |
| "p2p_total": len(p2p), |
| } |
|
|
| f2p_pass = [t for t in f2p if outcomes.get(t) == "PASSED"] |
| p2p_pass = [t for t in p2p if outcomes.get(t) == "PASSED"] |
| resolved = len(f2p_pass) == len(f2p) and len(p2p_pass) == len(p2p) |
| failing = sorted(t for t in f2p + p2p if outcomes.get(t) != "PASSED") |
| return { |
| "instance_id": row["instance_id"], |
| "resolved": resolved, |
| "reason": "ok" if resolved else "unmet tests: %d" % (len(failing),), |
| "f2p_passed": len(f2p_pass), |
| "f2p_total": len(f2p), |
| "p2p_passed": len(p2p_pass), |
| "p2p_total": len(p2p), |
| "failing": failing[:12], |
| } |
|
|
|
|
| def load_predictions(path): |
| predictions = {} |
| with open(path, encoding="utf-8") as handle: |
| for line in handle: |
| line = line.strip() |
| if not line: |
| continue |
| record = json.loads(line) |
| predictions[record["instance_id"]] = ( |
| record.get("model_patch") or record.get("patch") or "" |
| ) |
| return predictions |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--dataset", default="SWE-DockerLess.jsonl") |
| parser.add_argument("--predictions", help="JSONL of {instance_id, model_patch}") |
| parser.add_argument("--gold", action="store_true", help="score the gold patches") |
| parser.add_argument("--out", help="write a JSON report here") |
| args = parser.parse_args() |
|
|
| rows = [json.loads(line) for line in open(args.dataset, encoding="utf-8") if line.strip()] |
|
|
| if args.gold: |
| predictions = {row["instance_id"]: row["patch"] for row in rows} |
| elif args.predictions: |
| predictions = load_predictions(args.predictions) |
| else: |
| parser.error("pass --gold or --predictions") |
|
|
| started = time.time() |
| results = [] |
| print("%-22s %-9s %-7s %-7s %s" % ("instance", "resolved", "F2P", "P2P", "note")) |
| for row in rows: |
| result = evaluate(row, predictions.get(row["instance_id"], "")) |
| results.append(result) |
| print( |
| "%-22s %-9s %d/%-5d %d/%-5d %s" |
| % ( |
| result["instance_id"], |
| "yes" if result["resolved"] else "no", |
| result["f2p_passed"], |
| result["f2p_total"], |
| result["p2p_passed"], |
| result["p2p_total"], |
| result["reason"], |
| ) |
| ) |
|
|
| resolved = sum(1 for result in results if result["resolved"]) |
| elapsed = time.time() - started |
| summary = { |
| "dataset": str(Path(args.dataset).name), |
| "instances": len(rows), |
| "resolved": resolved, |
| "resolve_rate": round(resolved / len(rows), 4) if rows else 0.0, |
| "seconds": round(elapsed, 2), |
| "results": results, |
| } |
| print( |
| "\nresolved %d/%d (%.1f%%) in %.1fs" |
| % (resolved, len(rows), 100.0 * summary["resolve_rate"], elapsed) |
| ) |
| if args.out: |
| Path(args.out).write_text(json.dumps(summary, indent=2), encoding="utf-8") |
| print("report -> %s" % args.out) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
