#!/usr/bin/env python3 """Export TEBench into a self-contained, SWE-bench-style HuggingFace dataset. Reads the existing task spine and label table plus the local git repositories, and materializes one parquet file where every one of the 314 task instances carries its own ``source_patch`` (V-1 -> V-0.5, the production/non-test delta already applied for the agent) and ``test_patch`` (V-0.5 -> V0, the developer ground-truth test changes). Nothing under the existing TEBench tree is modified; all output lands in this ``hf_release/`` directory. """ import argparse import json import subprocess import sys from pathlib import Path import pandas as pd import pyarrow as pa import pyarrow.parquet as pq # Repo dir -> canonical upstream GitHub slug (for the ``repo`` field). REPO_SLUG = { "commons-cli": "apache/commons-cli", "commons-codec": "apache/commons-codec", "commons-collections": "apache/commons-collections", "commons-compress": "apache/commons-compress", "commons-csv": "apache/commons-csv", "commons-lang": "apache/commons-lang", "commons-math": "apache/commons-math", "gson": "google/gson", "jfreechart": "jfree/jfreechart", "jsoup": "jhy/jsoup", } # new_labels token -> canonical evolution type. LABEL_MAP = { "test_breaking": "breaking", "test_stale": "stale", "test_missing": "missing", } HERE = Path(__file__).resolve().parent TEBENCH = HERE.parent TESTUPDATE = TEBENCH.parent def git(repo: Path, *args: str) -> str: """Run a git command in ``repo`` and return stdout. Captured as bytes and decoded without newline translation so that CRLF line endings in patches (some repos store files with CRLF) are preserved verbatim; otherwise the emitted patch would no longer apply to the blob. """ out = subprocess.run( ["git", "-C", str(repo), "--no-pager", *args], capture_output=True, ) if out.returncode != 0: raise RuntimeError( f"git {' '.join(args)} failed in {repo}: {out.stderr.decode('utf-8', 'replace').strip()}") return out.stdout.decode("utf-8", "replace") def is_test_file(path: str) -> bool: return "/src/test/" in path or path.startswith("src/test/") def split_patch(repo: Path, base: str, head: str): """Return (source_patch, test_patch, n_src_files, n_test_files).""" names = [p for p in git(repo, "diff", "--name-only", base, head).splitlines() if p] test_files = [p for p in names if is_test_file(p)] src_files = [p for p in names if not is_test_file(p)] def diff(files): if not files: return "" # --binary --full-index keep binary hunks and full blob hashes so the # patch applies standalone with `git apply` (no repo objects needed). return git(repo, "diff", "--no-color", "--no-ext-diff", "--binary", "--full-index", base, head, "--", *files) return diff(src_files), diff(test_files), len(src_files), len(test_files) def to_list(cell) -> list: if cell is None or (isinstance(cell, float) and pd.isna(cell)): return [] return [x.strip() for x in str(cell).split("|") if x.strip()] def load_labels(labels_csv: Path) -> dict: """Map (project, short_hash) -> {labels, reasoning, new_test_methods, new_test_files}.""" df = pd.read_csv(labels_csv, dtype=str).fillna("") out = {} for _, r in df.iterrows(): key = (r["project"], r["v_0_commit"]) labels = [LABEL_MAP[t] for t in to_list(r.get("new_labels")) if t in LABEL_MAP] out[key] = { "labels": labels, "new_test_methods": r.get("new_test_methods", ""), "new_test_files": to_list(r.get("new_test_files")), } return out # Field names follow the paper's version notation (V-1 / V0). V-0.5 is not a # commit: it is V-1 with source_patch applied. SCHEMA = pa.schema([ ("instance_id", pa.string()), ("project", pa.string()), ("repo", pa.string()), ("v_minus_1_commit", pa.string()), # V-1: parent state, before the change ("v0_commit", pa.string()), # V0: full commit incl. GT test changes ("v0_date", pa.string()), ("v0_message", pa.string()), ("labels", pa.list_(pa.string())), # breaking / stale / missing ("changed_test_methods", pa.list_(pa.string())), ("new_test_files", pa.list_(pa.string())), ("new_test_methods", pa.string()), # JSON map {TestClass: [methods]} ("num_changed_files", pa.int64()), ("src_changed_lines", pa.int64()), ("test_changed_lines", pa.int64()), ("source_patch", pa.string()), # V-1 -> V-0.5 (non-test; the system input) ("test_patch", pa.string()), # V-0.5 -> V0 (gold test changes) ]) def main(): ap = argparse.ArgumentParser(description=__doc__) ap.add_argument("--spine", type=Path, default=TEBENCH / "data" / "filtered_commits_step2_full.csv") ap.add_argument("--labels", type=Path, default=TESTUPDATE / "classification_results_v2.csv") ap.add_argument("--repos", type=Path, default=TESTUPDATE / "TUDataset" / "defects4j-projects") ap.add_argument("--out", type=Path, default=HERE / "data" / "test.parquet") args = ap.parse_args() spine = pd.read_excel(args.spine, engine="openpyxl") labels = load_labels(args.labels) print(f"spine rows={len(spine)} label rows={len(labels)}") records, errors, missing_labels = [], [], 0 for i, row in enumerate(spine.itertuples(index=False), 1): project = row.Project short = str(row.CommitID) full = str(row.FullHash) repo = args.repos / project try: base = git(repo, "rev-parse", "--verify", f"{full}^").strip() msg = git(repo, "log", "-1", "--format=%B", full).strip() src_patch, test_patch, n_src, n_test = split_patch(repo, base, full) except Exception as e: # noqa: BLE001 errors.append(f"{project}/{short}: {e}") continue lab = labels.get((project, short)) if lab is None: missing_labels += 1 lab = {"labels": [], "new_test_methods": "", "new_test_files": []} records.append({ "instance_id": f"{project}__{short}", "project": project, "repo": REPO_SLUG.get(project, project), "v_minus_1_commit": base, "v0_commit": full, "v0_date": str(row.Date), "v0_message": msg, "labels": lab["labels"], "changed_test_methods": to_list(row.ChangedTestMethods), "new_test_files": lab["new_test_files"], "new_test_methods": lab["new_test_methods"], "num_changed_files": int(row.ChangedFiles), "src_changed_lines": int(row.SrcChangedLines), "test_changed_lines": int(row.TestChangedLines), "source_patch": src_patch, "test_patch": test_patch, }) if i % 50 == 0: print(f" ...{i}/{len(spine)}") args.out.parent.mkdir(parents=True, exist_ok=True) table = pa.Table.from_pylist(records, schema=SCHEMA) pq.write_table(table, args.out) # ---- validation summary ---- b = sum("breaking" in r["labels"] for r in records) s = sum("stale" in r["labels"] for r in records) m = sum("missing" in r["labels"] for r in records) empty_src = sum(not r["source_patch"] for r in records) empty_test = sum(not r["test_patch"] for r in records) print("\n==== summary ====") print(f"instances written : {len(records)}") print(f"errors : {len(errors)}") print(f"missing labels : {missing_labels}") print(f"labels B/S/M : {b}/{s}/{m} (paper: 172/207/199)") print(f"empty source_patch: {empty_src}") print(f"empty test_patch : {empty_test}") print(f"written to : {args.out}") if errors: print("\nfirst errors:") for e in errors[:10]: print(" ", e) if __name__ == "__main__": sys.exit(main())