File size: 6,207 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
"""The package's local copy of the tasks: ``data/tasks.jsonl`` plus the bundles it indexes.

``build`` writes a benchmark's data directory from a dataset snapshot; ``load``
reads one back and refuses to run on a file whose hash differs from the
index, before anything is spent.
"""
from __future__ import annotations

import datetime as dt
import hashlib
import json
import shutil
from pathlib import Path

import pandas as pd

from ..bundles import TaskBundle, load_task, sha256_file

BENCH_CONFIG = {"software-delivery": "software_delivery", "cyber-operations": "cyber_operations"}
BUNDLE_FILES = ("manifest.yaml", "repository.zip", "hidden_tests.zip", "gold.diff")
EVALUATOR_IMAGES = ("swe", "sweqna")


def family_of(task: TaskBundle) -> str:
    return "qna" if task.kind == "judge" else "executable"


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

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


def build(dataset_root: Path, benchmark: str, out_dir: Path, source_revision: str | None = None) -> dict:
    dataset_root, out_dir = Path(dataset_root), Path(out_dir)
    config = BENCH_CONFIG[benchmark]
    frame = pd.read_parquet(dataset_root / f"benchmark_dataset_{config}.parquet")
    calibration = _calibration()
    if out_dir.exists():
        shutil.rmtree(out_dir)
    (out_dir / "tasks").mkdir(parents=True)
    rows = []
    for _, row in frame.sort_values("ID").iterrows():
        task = load_task(dataset_root / "tasks" / row["ID"])
        dest = out_dir / "tasks" / task.task_id
        dest.mkdir()
        files = {}
        for name in BUNDLE_FILES:
            src = task.task_dir / name
            if src.exists():
                shutil.copy2(src, dest / name)
                files[name] = sha256_file(src)
        if "gold.diff" not in files:
            # QnA bundles carry their reference patch inside additional_task_files.zip
            import zipfile
            with zipfile.ZipFile(task.task_dir / "additional_task_files.zip") as z:
                member = next((n for n in z.namelist() if n.endswith("gold.diff")), None)
                if member:
                    (dest / "gold.diff").write_bytes(z.read(member))
                    files["gold.diff"] = sha256_file(dest / "gold.diff")
        rows.append({
            "id": task.task_id,
            "benchmark": benchmark,
            "family": family_of(task),
            "task_version": task.manifest.get("task_version"),
            "prompt": task.issue_text,
            "patch_policy": task.patch_policy,
            "manifest_profile": (task.manifest.get("resources") or {}).get("profile"),
            "manifest_scoring_policy": task.evaluation.get("scoring_policy"),
            "image_kind": task.image_kind,
            "calibrated_hidden_total": (calibration.get(task.task_id) or {}).get("hidden_total"),
            "files": files,
        })
    for kind in EVALUATOR_IMAGES:
        src = dataset_root / "environments" / kind / "Dockerfile"
        (out_dir / "environments" / kind).mkdir(parents=True)
        shutil.copy2(src, out_dir / "environments" / kind / "Dockerfile")
    tasks_path = out_dir / "tasks.jsonl"
    tasks_path.write_text("".join(json.dumps(r, ensure_ascii=False) + "\n" for r in rows))
    manifest = {
        "benchmark": benchmark,
        "tasks": len(rows),
        "families": {f: sum(1 for r in rows if r["family"] == f) for f in ("executable", "qna")},
        "bundle_files": sum(len(r["files"]) for r in rows),
        "snapshot_date": dt.date.today().isoformat(),
        "tasks_sha256": sha256_file(tasks_path),
        "source_repository": "Poindexter-Labs/PDL-Bench",
        "source_revision": source_revision,
        "source_subset": config,
        "protocol_notes": [
            "Executable tasks pin python_standard_1m_v0.1 in their manifests; the published report ran them under python_standard_2m_v0.1 as an operator override, and the preset does the same.",
            "QnA tasks pin scoring_llm_v0.2 in their manifests; the published report graded them under scoring_llm_v0.3 as an operator override, and the preset does the same.",
        ],
    }
    (out_dir / "manifest.json").write_text(json.dumps(manifest, indent=2) + "\n")
    return manifest


def load(data_dir: Path, benchmark: str) -> list:
    """Rows of tasks.jsonl with their verified bundles attached (``row["bundle"]``) and a task hash."""
    data_dir = Path(data_dir).resolve()
    path = data_dir / "tasks.jsonl"
    if not path.is_file():
        raise FileNotFoundError(f"{path} is missing; point --data at the package's data directory")
    rows, ids = [], set()
    for line in path.read_text().split("\n"):
        if not line.strip():
            continue
        row = json.loads(line)
        if row.get("benchmark") != benchmark:
            raise ValueError(f"tasks.jsonl is for benchmark {row.get('benchmark')!r}, the preset is {benchmark!r}")
        if not isinstance(row.get("id"), str) or row["id"] in ids:
            raise ValueError("each task needs a unique id")
        ids.add(row["id"])
        task_dir = data_dir / "tasks" / row["id"]
        for name, expected in row["files"].items():
            actual = sha256_file(task_dir / name) if (task_dir / name).is_file() else None
            if actual != expected:
                raise ValueError(f"bundle file hash mismatch: {row['id']}/{name}")
        bundle = load_task(task_dir)
        if bundle.task_id != row["id"] or family_of(bundle) != row["family"]:
            raise ValueError(f"bundle for {row['id']} does not match its index row")
        declared = (bundle.manifest.get("repository") or {}).get("sha256")
        if declared and declared != row["files"].get("repository.zip"):
            raise ValueError(f"{row['id']}: repository.zip does not match the manifest's sha256")
        row["task_hash"] = hashlib.sha256(json.dumps({k: v for k, v in row.items() if k != "bundle"},
                                                     sort_keys=True).encode()).hexdigest()
        row["bundle"] = bundle
        rows.append(row)
    if not rows:
        raise ValueError("tasks.jsonl is empty")
    return rows