File size: 8,565 Bytes
700c7f4
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
"""Command-line interface: pdl-bench-eval <command> [options]."""
from __future__ import annotations

import argparse
import json
import sys
from pathlib import Path

from . import EVALUATOR_ID, __version__


def _root(args) -> Path:
    from .bundles import fetch

    if args.dataset_dir:
        return Path(args.dataset_dir)
    return fetch(revision=args.revision)


def _calibration() -> dict:
    from importlib import resources

    return json.loads(resources.files("pdl_bench_eval").joinpath("calibration.json").read_text())["tasks"]


def _emit(record: dict, out: str | None):
    text = json.dumps(record, indent=2, ensure_ascii=False)
    if out:
        Path(out).write_text(text + "\n")
    print(text)


def cmd_fetch(args):
    root = _root(args)
    print(root)


def cmd_grade_repo(args):
    from .bundles import find_task
    from .docker_env import DockerEnv
    from .repo_grader import grade_repository_task

    root = _root(args)
    task = find_task(root, args.task)
    if task.kind != "tests":
        sys.exit(f"{args.task} is rubric-scored; use grade-sweqna")
    env = DockerEnv.ensure(root, task.image_kind)
    patch_text = Path(args.patch).read_text()
    record = grade_repository_task(task, patch_text, env=env, work_root=Path(args.work_dir),
                                   policy_id=args.policy, calibration=_calibration(),
                                   per_test_timeout=None if args.no_per_test_timeout else 60,
                                   keep_work=args.keep_work)
    _emit(record, args.out)


def cmd_grade_sweqna(args):
    from .bundles import find_task
    from .docker_env import DockerEnv
    from .judges import parse_members
    from .sweqna_grader import grade_sweqna_task

    root = _root(args)
    task = find_task(root, args.task)
    if task.kind != "judge":
        sys.exit(f"{args.task} is test-scored; use grade-repo")
    env = DockerEnv.ensure(root, task.image_kind)
    members = parse_members(args.judges.split(",")) if args.judges else None
    kwargs = {"answer_text": Path(args.answer).read_text()} if args.answer else {"patch_text": Path(args.patch).read_text()}
    record = grade_sweqna_task(task, env=env, work_root=Path(args.work_dir), members=members,
                               policy_id=args.policy, keep_work=args.keep_work, **kwargs)
    _emit(record, args.out)


def cmd_grade_qa(args):
    from .bundles import qa_row
    from .judges import parse_member
    from .qa_grader import grade_qa

    root = _root(args)
    row = qa_row(root, args.task)
    record = grade_qa(row, Path(args.response).read_text(),
                      match_member=parse_member(args.match_judge) if args.match_judge else None,
                      rubric_member=parse_member(args.rubric_judge) if args.rubric_judge else None,
                      reasoning=args.reasoning)
    _emit(record, args.out)


def cmd_calibrate(args):
    """Replay gold and baseline for every executable task; print per-task totals and rewards."""
    from .bundles import load_task
    from .docker_env import DockerEnv
    from .repo_grader import grade_repository_task

    root = _root(args)
    results = {}
    for task_dir in sorted((root / "tasks").iterdir()):
        task = load_task(task_dir)
        if task.kind != "tests" or not (task_dir / "gold.diff").exists():
            continue
        env = DockerEnv.ensure(root, task.image_kind)
        gold = grade_repository_task(task, (task_dir / "gold.diff").read_text(), env=env, work_root=Path(args.work_dir),
                                     policy_id=args.policy, calibration=None)
        results[task.task_id] = {"gold": gold}
        print(f"{task.task_id:36} gold outcome={gold['outcome']} reward={gold['reward']} "
              f"hidden={gold['hidden_tests_passed']}/{gold['hidden_tests_total']}", flush=True)
    _emit(results, args.out)


def cmd_harbor_export(args):
    from .harbor_export import export

    root = _root(args)
    print(json.dumps(export(root, Path(args.out_dir), eval_ref=args.eval_ref)))


def cmd_summarize(args):
    """Aggregate grade records into the published pass-rate statistic.

    pass rate = passes / valid attempts, where a pass is reward > 0.95 (repository and
    SWEQnA tasks) or the Q&A pass flag, and valid attempts exclude void_* outcomes.
    """
    records = []
    for path in args.records:
        p = Path(path)
        files = sorted(p.glob("*.json")) if p.is_dir() else [p]
        for f in files:
            data = json.loads(f.read_text())
            records.extend(data if isinstance(data, list) else [data])
    by_task = {}
    for r in records:
        t = by_task.setdefault(r.get("task_id"), {"attempts": 0, "valid": 0, "passes": 0, "void": 0})
        t["attempts"] += 1
        if str(r.get("outcome", "")).startswith("void"):
            t["void"] += 1
            continue
        t["valid"] += 1
        t["passes"] += 1 if r.get("passed") else 0
    total_valid = sum(t["valid"] for t in by_task.values())
    total_pass = sum(t["passes"] for t in by_task.values())
    summary = {"tasks": by_task, "valid_attempts": total_valid, "passes": total_pass,
               "pass_rate": round(total_pass / total_valid, 4) if total_valid else None}
    _emit(summary, args.out)


def main(argv=None):
    ap = argparse.ArgumentParser(prog="pdl-bench-eval", description=f"{EVALUATOR_ID}: reference evaluator for PDL-Bench")
    ap.add_argument("--version", action="version", version=__version__)
    sub = ap.add_subparsers(dest="command", required=True)

    def common(p):
        p.add_argument("--dataset-dir", help="local snapshot of the dataset (default: fetch from the Hub)")
        p.add_argument("--revision", help="dataset revision to fetch (commit, tag or branch)")
        p.add_argument("--out", help="write the JSON record here as well as printing it")

    p = sub.add_parser("fetch", help="download the dataset files the graders need"); common(p); p.set_defaults(fn=cmd_fetch)

    p = sub.add_parser("grade-repo", help="grade a patch against an executable repository task"); common(p)
    p.add_argument("--task", required=True); p.add_argument("--patch", required=True, help="unified diff file")
    p.add_argument("--policy", default="scoring_v0.2"); p.add_argument("--work-dir", default=".pdl-bench-work")
    p.add_argument("--no-per-test-timeout", action="store_true"); p.add_argument("--keep-work", action="store_true")
    p.set_defaults(fn=cmd_grade_repo)

    p = sub.add_parser("grade-sweqna", help="grade a written answer for a SWEQnA task"); common(p)
    p.add_argument("--task", required=True)
    g = p.add_mutually_exclusive_group(required=True)
    g.add_argument("--answer", help="answers/answer.md content file"); g.add_argument("--patch", help="unified diff adding answers/answer.md")
    p.add_argument("--judges", help="comma-separated provider:model[@base_url]; default: the reference panel")
    p.add_argument("--policy", default="scoring_llm_v0.3"); p.add_argument("--work-dir", default=".pdl-bench-work")
    p.add_argument("--keep-work", action="store_true"); p.set_defaults(fn=cmd_grade_sweqna)

    p = sub.add_parser("grade-qa", help="grade a response to a single-turn Q&A task"); common(p)
    p.add_argument("--task", required=True, help="task ID, e.g. PDS030"); p.add_argument("--response", required=True, help="model response text file")
    p.add_argument("--match-judge", help="provider:model for the answer comparator (default: reference)")
    p.add_argument("--rubric-judge", help="provider:model for the rubric judge (default: reference)")
    p.add_argument("--reasoning", help="reasoning effort for OpenAI-style judges (default: reference)")
    p.set_defaults(fn=cmd_grade_qa)

    p = sub.add_parser("calibrate", help="replay every executable task's gold patch"); common(p)
    p.add_argument("--policy", default="scoring_v0.2"); p.add_argument("--work-dir", default=".pdl-bench-work")
    p.set_defaults(fn=cmd_calibrate)

    p = sub.add_parser("harbor-export", help="emit the repository tasks as a Harbor dataset"); common(p)
    p.add_argument("--out-dir", required=True); p.add_argument("--eval-ref", default="main", help="git ref of pdl-bench-eval the SWEQnA verifier installs")
    p.set_defaults(fn=cmd_harbor_export)

    p = sub.add_parser("summarize", help="pass rate over grade records (files or directories)")
    p.add_argument("records", nargs="+"); p.add_argument("--out"); p.set_defaults(fn=cmd_summarize)

    args = ap.parse_args(argv)
    args.fn(args)


if __name__ == "__main__":
    main()