| """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 |
| |
| 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() |
|
|
