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
|