File size: 9,052 Bytes
eeaa10a
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
"""Evaluate one actor on many cases: run_case.py per case (up to --jobs at once), then the environment check of
every run, then one table.

python scripts/run_batch.py --cases cases/02*/case.yaml --n-runs 1 \
    --actor-agent codex --actor-model deepseek-chat \
    --env-model claude-sonnet-5-5 --judge-model claude-opus-5-5 \
    --actor-timeout-s 10800 --checkpoints case --jobs 2 --out runs --env-check-scratch /tmp/twinlab_env_check

Output: the usual run dirs under <out>/<case_id>/, plus <out>/batches/<timestamp>/ with one log per case and
attempt and batch_summary.json. Invalid runs are rerun up to MAX_ATTEMPTS times; see run_one.
"""
import argparse
import json
import subprocess
import sys
import time
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path

ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT))   # run from a checkout without installing
from twinlab.actors import AGENTS                 # noqa: E402
from twinlab.case import CHECKPOINT_MODES, Case   # noqa: E402
from twinlab.env_check import check_env           # noqa: E402
from twinlab.scale import round1                  # noqa: E402

ACTOR_EFFORTS = ["low", "medium", "high", "xhigh", "max"]   # same list as run_case.py (claude --effort levels)
ROOT_LINE = "[run_case] "   # run_case.py prints its output dir on this line (after the [case] line)
MAX_ATTEMPTS = 3            # run_case.py calls per case while runs are judged invalid; then the missing runs score 0


def run_attempt(case: Case, a, n_runs: int, log: Path) -> dict:
    """One run_case.py call with n_runs runs, then the environment check of each run."""
    cmd = [sys.executable, "-u", str(ROOT / "scripts/run_case.py"), "--case", str(case.path),
           "--n-runs", str(n_runs), "--actor-agent", a.actor_agent, "--actor-model", a.actor_model,
           "--env-model", a.env_model, "--judge-model", a.judge_model, "--actor-timeout-s", str(a.actor_timeout_s),
           "--checkpoints", a.checkpoints, "--out", str(a.out),
           *(["--actor-effort", a.actor_effort] if a.actor_effort is not None else [])]
    print(f"[batch] start {case.id} (log {log})", flush=True)
    with open(log, "w") as f:
        rc = subprocess.run(cmd, stdout=f, stderr=subprocess.STDOUT, cwd=ROOT).returncode
    roots = [line[len(ROOT_LINE):] for line in log.read_text().splitlines() if line.startswith(ROOT_LINE)]
    assert len(roots) <= 1, f"{log}: several output dirs {roots}"
    root = Path(roots[0]) if roots else None
    att = {"rc": rc, "root": str(root), "log": str(log)}
    if root is None:
        print(f"[batch] {case.id} FAILED before any run (rc={rc}); see {log}", flush=True)
        return att
    checks = {}
    for run_dir in sorted(root.glob("run_*")):
        if (run_dir / "env_session.jsonl").is_file():
            rep = check_env(run_dir, a.env_check_scratch / case.id / root.name / run_dir.name,
                            run_dir / "env_session.jsonl")
            checks[run_dir.name] = {"problems": len(rep["problems"]), "to_read": len(rep["to_read"])}
    summary = json.loads((root / "summary.json").read_text()) if (root / "summary.json").is_file() else {}
    att.update(unfinished=summary.get("unfinished"), env_check=checks,
               results=[json.loads(p.read_text()) for p in sorted(root.glob("run_*/result.json"))])
    return att


def run_one(case: Case, a, logs: Path) -> dict:
    """a.n_runs valid runs of a case. Runs judged invalid (environment flag or contamination) are rerun, up to
    MAX_ATTEMPTS run_case.py calls in all; a slot still without a valid run after that scores 0 (derived_100 0,
    pass false) and keeps its place in the mean (user 2026-11-18). A stopped run (rc != 0 or unfinished) ends the
    attempts: it is resumed by hand, never rerun."""
    valid, invalid, attempts = [], [], []
    for k in range(1, MAX_ATTEMPTS + 1):
        missing = a.n_runs - len(valid)
        log = logs / (f"{case.id}.log" if k == 1 else f"{case.id}.attempt{k}.log")
        att = run_attempt(case, a, missing, log)
        attempts.append({x: att.get(x) for x in ("rc", "root", "log", "unfinished", "env_check")})
        for r in att.get("results", []):
            (valid if r["valid"] else invalid).append({"root": att["root"], "run": r["run"], "score": r["score"]})
        if att["rc"] != 0 or att.get("unfinished") or att["root"] == "None":
            break
        if len(valid) == a.n_runs:
            break
        print(f"[batch] {case.id}: attempt {k} left {a.n_runs - len(valid)} of {a.n_runs} runs without a valid "
              f"result" + ("; rerunning" if k < MAX_ATTEMPTS else f"; {MAX_ATTEMPTS} attempts used, scored 0"),
              flush=True)
    last = attempts[-1]
    stopped = last["rc"] != 0 or bool(last["unfinished"]) or last["root"] == "None"
    row = {"case": case.id, "rc": last["rc"], "root": last["root"], "log": last["log"], "unfinished": last["unfinished"],
           "attempts": attempts, "n_runs": a.n_runs, "n_valid": len(valid),
           "n_invalid_runs": len(invalid), "invalid_runs": [f"{x['root']}/{x['run']}" for x in invalid]}
    if stopped:   # not final: the stopped run is resumed by hand
        row.update({"n_scored_0": None, "pass@1": None, "mean_score": None, "mean_cost_used": None})
    else:
        n0 = a.n_runs - len(valid)
        row.update({"n_scored_0": n0,
                    "pass@1": sum(v["score"]["pass"] for v in valid) / a.n_runs,
                    "mean_score": round1(sum(v["score"]["derived_100"] for v in valid) / a.n_runs),
                    "mean_cost_used": (sum(v["score"]["cost_used"] for v in valid) / len(valid)) if valid else None})
    print(f"[batch] done {case.id}: attempts={len(attempts)} pass@1={row['pass@1']} mean_score={row['mean_score']} "
          f"valid={len(valid)}/{a.n_runs} invalid_runs={len(invalid)} scored_0={row['n_scored_0']}", flush=True)
    return row


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--cases", required=True, nargs="+", type=Path, help="case.yaml paths (shell globs are fine)")
    ap.add_argument("--n-runs", required=True, type=int)
    ap.add_argument("--actor-agent", required=True, choices=sorted(AGENTS))
    ap.add_argument("--actor-model", required=True)
    ap.add_argument("--actor-effort", choices=ACTOR_EFFORTS,
                    help="omit for the CLI default of this model (machine.yaml actor_default_effort)")
    ap.add_argument("--env-model", required=True)
    ap.add_argument("--judge-model", required=True)
    ap.add_argument("--actor-timeout-s", required=True, type=int)
    ap.add_argument("--checkpoints", required=True, choices=CHECKPOINT_MODES)
    ap.add_argument("--jobs", required=True, type=int, help="cases evaluated at the same time")
    ap.add_argument("--out", required=True, type=Path)
    ap.add_argument("--env-check-scratch", required=True, type=Path, help="dir outside runs/ and cases/")
    a = ap.parse_args()
    a.out = a.out.resolve()
    cases = [Case(p, a.checkpoints) for p in a.cases]   # every case must load before anything runs
    batch = a.out / "batches" / time.strftime("%Y%m%d-%H%M%S")
    (batch / "logs").mkdir(parents=True)
    (batch / "batch_config.json").write_text(json.dumps({**vars(a), "cases": [str(c.path) for c in cases]},
                                                        indent=1, default=str))
    print(f"[batch] {len(cases)} cases, {a.jobs} at a time -> {batch}", flush=True)
    with ThreadPoolExecutor(max_workers=a.jobs) as pool:
        rows = list(pool.map(lambda c: run_one(c, a, batch / "logs"), cases))
    (batch / "batch_summary.json").write_text(json.dumps(rows, indent=1))
    print(f"\n{'case':40s} {'rc':>3s} {'valid':>7s} {'tries':>5s} {'pass@1':>7s} {'score':>7s} {'cost':>7s}")
    for r in rows:
        print(f"{r['case']:40s} {r['rc']:3d} {str(r['n_valid']) + '/' + str(r['n_runs']):>7s} "
              f"{len(r['attempts']):5d} {str(r['pass@1']):>7s} {str(r['mean_score']):>7s} "
              f"{str(r['mean_cost_used']):>7s}")
    done = [r for r in rows if r["mean_score"] is not None]
    if len(done) == len(rows):   # every case final: invalid-after-retries slots are in as 0, the divisor is all cases
        print(f"[batch] mean score over {len(rows)} cases: {round1(sum(r['mean_score'] for r in rows) / len(rows))}")
    print(f"[batch] summary: {batch / 'batch_summary.json'}")
    # a stopped run (gateway outage, harness assert, timeout) is reported and the batch exits non-zero, so the caller
    # sees it (stop on errors with the log, resume by hand; no automatic resume)
    stopped = [r for r in rows if r["rc"] != 0 or r.get("unfinished")]
    if stopped:
        print(f"\n[batch] {len(stopped)} case(s) did not finish:", flush=True)
        for r in stopped:
            print(f"  {r['case']}: rc={r['rc']} unfinished={r.get('unfinished')} log={r['log']} root={r['root']}")
            print(f"    resume: python scripts/resume_run.py --run-dir {r['root']}/<run>")
        sys.exit(1)


if __name__ == "__main__":
    main()