Datasets:
File size: 10,164 Bytes
0e239c6 | 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 | """Validate task indexes, artifact bytes and the release checksum inventory."""
import argparse
import csv
import json
import re
from pathlib import Path
import sys
from common import ROOT, contained, sha256
from source_construction import object_id
def validate(root):
root = Path(root).resolve()
rows = [json.loads(line) for line in (root / "data/instances.jsonl").read_text().splitlines()]
with (root / "release171.tsv").open() as stream:
index = list(csv.DictReader(stream, delimiter="\t"))
assert len(rows) == len(index) == 171, "Expected exactly 171 tasks"
ids = [row["instance_id"] for row in rows]
assert len(set(ids)) == 171, "Duplicate task IDs"
assert ids == [row["instance_id"] for row in index], "TSV order differs"
assert set(ids) == {p.name for p in (root / "instances").iterdir() if p.is_dir()}, "Directory set differs"
with (root / "data/instance-id-map.tsv").open() as stream:
aliases = list(csv.DictReader(stream, delimiter="\t"))
assert len(aliases) == 171 and ids == [row["instance_id"] for row in aliases], "ID mapping differs"
originals = [row["original_instance_id"] for row in aliases]
assert len(set(originals)) == 171, "Original IDs must be unique"
for row in aliases:
assert row["original_instance_id"] not in ids or row["original_instance_id"] == row["instance_id"], "Ambiguous legacy ID"
mapping = {row["instance_id"]: row for row in aliases}
labels = {row['instance_id']:row for row in map(json.loads, (root / 'data/crossswe-bench.jsonl').read_text().splitlines())}
assert set(labels) == set(ids), 'Annotation IDs differ'
artifact_count = 0
for ordinal, (task, item) in enumerate(zip(rows, index), 1):
instance_id = task["instance_id"]
directory = contained(root / "instances", instance_id)
assert task["ordinal"] == ordinal == int(item["ordinal"]), instance_id
assert json.loads((directory / "task.json").read_text()) == task, instance_id
assert item["task_path"] == f"instances/{instance_id}/task.json", instance_id
assert json.loads((directory / "repos.json").read_text()) == task["repositories"], instance_id
assert task["repositories"], instance_id
identity = mapping[instance_id]
naming = task["naming"]
assert task["original_instance_id"] == identity["original_instance_id"] == item["original_instance_id"], instance_id
assert naming["category"] == identity["category"], instance_id
assert item["language"] == labels[instance_id]["language"] and item["task"] == labels[instance_id]["task"], instance_id
assert identity["ordinal"] == str(ordinal), instance_id
for field in ("primary_repository", "primary_pr_url"):
assert naming[field] == identity[field], instance_id
assert naming["primary_pr_number"] == int(identity["primary_pr_number"]), instance_id
assert re.fullmatch(r"[a-z]+-[a-z0-9]+(?:-[a-z0-9]+)*-[1-9][0-9]*", instance_id), instance_id
assert instance_id.startswith(naming["category"] + "-") and instance_id.endswith("-" + str(naming["primary_pr_number"])), instance_id
assert naming["primary_repository"] in {r["repo"] for r in task["repositories"]}, instance_id
provenance = json.loads((directory / task["provenance"]["path"]).read_text())
matches = [pr for pr in provenance["pull_requests"] if pr.get("repo", "").lower() == naming["primary_repository"].lower()]
assert any(pr.get("url", "").removesuffix(".patch") == naming["primary_pr_url"] for pr in matches), instance_id
refs = {ref["path"]: ref for ref in task["artifacts"]}
assert len(refs) == len(task["artifacts"]), f"Duplicate paths: {instance_id}"
actual = {str(p.relative_to(directory)) for p in directory.rglob("*") if p.is_file() and p != directory / "task.json"}
assert actual == set(refs), f"Unindexed or missing files: {instance_id}: {actual ^ set(refs)}"
for ref in refs.values():
path = contained(directory, ref["path"])
assert path.is_file() and path.stat().st_size == ref["bytes"], str(path)
assert sha256(path) == ref["sha256"], f"Hash mismatch: {path}"
artifact_count += 1
assert (directory / task["problem_statement"]["path"]).read_text().strip(), instance_id
for repo in task["repositories"]:
assert repo["gold_patch"]["path"] in refs, instance_id
assert repo["url"].startswith("https://github.com/"), instance_id
assert repo["base_commit"] and repo["fixed_commit"], instance_id
# Source and dependency records carry nested artifact references.
def verify_reference(ref):
assert ref["path"] in refs, f"Unindexed reference: {instance_id}: {ref['path']}"
for field in ("sha256", "bytes"):
if field in ref:
assert refs[ref["path"]][field] == ref[field], f"Reference differs: {instance_id}: {ref['path']}"
by_key = {r["key"]: r for r in task["repositories"]}
assert len(by_key) == len(task["repositories"]), instance_id
dependencies = json.loads((directory / "environment/source-dependencies.json").read_text())
assert dependencies["instance_id"] == instance_id
assert [r["repository"] for r in dependencies["repositories"]] == list(by_key), instance_id
for dependency in dependencies["repositories"]:
repo = by_key[dependency["repository"]]
assert dependency["source_commit"] == repo["base_commit"], instance_id
for ref in dependency["files"]:
verify_reference(ref)
assert ref["source_commit"] == repo["base_commit"], instance_id
assert ref["repository"] == repo["key"], instance_id
if ref.get("source_construction"):
verify_reference(ref["source_construction"])
for repo in task["repositories"]:
policy = repo["source_policy"]
if policy.get("construction_recipe"):
verify_reference(policy["construction_recipe"])
recipe = json.loads(contained(directory, policy["construction_recipe"]["path"]).read_text())
assert recipe["schema_version"] == 1 and recipe["kind"] == "git-tree-transform-v1", instance_id
assert recipe["expected_commit"] == repo["base_commit"], instance_id
verify_reference(recipe["commit_object"])
commit = contained(directory, recipe["commit_object"]["path"]).read_bytes()
assert object_id("commit", commit) == repo["base_commit"], instance_id
header = commit.split(b"\n\n", 1)[0].splitlines()
assert b"tree " + recipe["expected_tree"].encode() in header, instance_id
parents = [line[7:].decode() for line in header if line.startswith(b"parent ")]
assert parents == recipe.get("parents", []), instance_id
assert parents in ([], [recipe["upstream_base_commit"]]), instance_id
for operation in recipe["operations"]:
if operation["kind"] == "reverse_patch":
verify_reference(operation["patch"])
for link in policy.get("workspace_links", []):
provider = by_key[link["target_repository"]]
assert provider["key"] != repo["key"], instance_id
assert provider["container_path"] == link["original_target"], instance_id
assert object_id("blob", link["original_target"].encode()) == link["expected_blob"], instance_id
compatibility = directory / "evaluation/test-preparation.json"
if compatibility.is_file():
configuration = json.loads(compatibility.read_text())
assert configuration["schema_version"] == 1 and configuration["instance_id"] == instance_id
for variant in configuration["patch_variants"]:
assert variant["original"] in by_key[variant["repository"]]["test_patches"], instance_id
verify_reference(variant["original"])
for alternative in variant["alternatives"]:
verify_reference(alternative)
contract = json.loads((directory / task["evaluation"]["path"]).read_text())
assert contract["instance_id"] == instance_id
for ref in contract["test_files"]:
assert refs[ref["path"]]["sha256"] == ref["sha256"], instance_id
assert any(r["test_patches"] for r in task["repositories"]) or contract["test_files"], f"Missing tests: {instance_id}"
checks = root / "CHECKSUMS.sha256"
if checks.exists():
inventory = {}
for line in checks.read_text().splitlines():
digest, relative = line.split(" ", 1)
assert relative not in inventory, relative
inventory[relative] = digest
assert sha256(contained(root, relative)) == digest, relative
actual = {str(p.relative_to(root)) for p in root.rglob("*") if p.is_file()
and not any(x in p.relative_to(root).parts for x in [".git", ".cache", "workspaces", "results", "__pycache__"])
and p.name != "CHECKSUMS.sha256"}
assert actual == set(inventory), f"Checksum inventory differs: {actual ^ set(inventory)}"
return {"tasks": len(rows), "repositories": sum(len(t["repositories"]) for t in rows), "artifacts": artifact_count}
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--root", type=Path, default=ROOT)
parser.add_argument("--list", action="store_true")
args = parser.parse_args()
if args.list:
for row in map(json.loads, (args.root / "data/instances.jsonl").read_text().splitlines()):
print(row["instance_id"])
else:
try:
print(json.dumps(validate(args.root), sort_keys=True))
except (AssertionError, ValueError, OSError, KeyError) as error:
print(f"Invalid release: {error}", file=sys.stderr)
sys.exit(1)
if __name__ == "__main__":
main()
|