scripts/audit_mhumaneval_archive.py

#!/usr/bin/env python3
"""Stream-audit a pinned mHumanEval GitHub archive without extracting it."""

from __future__ import annotations

import argparse
import csv
import hashlib
import io
import json
import tarfile
from collections import Counter, defaultdict
from pathlib import Path, PurePosixPath


PAPER_PROGRAMMING_LANGUAGES = [
    "Python",
    "Bash",
    "C++",
    "C#",
    "D",
    "Go",
    "Haskell",
    "Java",
    "JavaScript",
    "Julia",
    "Kotlin",
    "Lua",
    "Perl",
    "PHP",
    "R",
    "Racket",
    "Ruby",
    "Rust",
    "Scala",
    "Swift",
    "TypeScript",
    "MATLAB",
    "Visual Basic",
    "Fortran",
    "COBOL",
]

PROGRAMMING_LANGUAGE_LABELS = {
    "bash": "Bash",
    "cpp": "C++",
    "cs": "C#",
    "d": "D",
    "go": "Go",
    "go_test.go": "Go",
    "hs": "Haskell",
    "java": "Java",
    "js": "JavaScript",
    "jl": "Julia",
    "kt": "Kotlin",
    "lua": "Lua",
    "matlab": "MATLAB",
    "php": "PHP",
    "pl": "Perl",
    "python": "Python",
    "r": "R",
    "rb": "Ruby",
    "rkt": "Racket",
    "rs": "Rust",
    "scala": "Scala",
    "swift": "Swift",
    "ts": "TypeScript",
    "vb": "Visual Basic",
    "fortran": "Fortran",
    "cobol": "COBOL",
}

PAYLOAD_SURFACES = {
    "mHuamnEval-Expert",
    "mHumanEval",
    "mHumanEval-B500",
    "mHumanEval-R500",
    "mHumanEval-T500",
    "mHumanEval-max",
    "mHumanEval-mini",
    "mHumanEval-{NL}",
    "mHumanEval-{PL}",
}


def sha256_file(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as handle:
        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
            digest.update(chunk)
    return digest.hexdigest()


def canonical_language(raw: object) -> str:
    label = str(raw).strip()
    return PROGRAMMING_LANGUAGE_LABELS.get(label.casefold(), label or "UNKNOWN")


def is_license_name(path: PurePosixPath) -> bool:
    stem = path.name.casefold().split(".", 1)[0]
    return stem in {"license", "licence", "copying", "notice"}


def safe_member_name(name: str) -> bool:
    path = PurePosixPath(name)
    return not path.is_absolute() and ".." not in path.parts


def record_stats(records: list[dict[str, object]]) -> dict[str, object]:
    raw_pls = {str(record.get("pl", "UNKNOWN")) for record in records}
    languages = {canonical_language(value) for value in raw_pls}
    nls = {str(record.get("nl", "UNKNOWN")) for record in records}
    task_ids = {str(record["task_id"]) for record in records if "task_id" in record}
    solution_hashes = {
        hashlib.sha256(
            str(record.get("canonical_solution", record.get("canonical_solutions", ""))).encode()
        ).hexdigest()
        for record in records
    }
    return {
        "raw_pls": raw_pls,
        "languages": languages,
        "nls": nls,
        "task_ids": task_ids,
        "solution_hashes": solution_hashes,
    }


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("archive", type=Path)
    parser.add_argument("--revision", required=True)
    parser.add_argument("--compact", action="store_true")
    args = parser.parse_args()

    archive_sha256 = sha256_file(args.archive)
    compressed_bytes = args.archive.stat().st_size
    member_types: Counter[str] = Counter()
    extension_counts: Counter[str] = Counter()
    top_level_files: Counter[str] = Counter()
    top_level_bytes: Counter[str] = Counter()
    top_level_content_hashes: dict[str, set[str]] = defaultdict(set)
    archive_root_names: set[str] = set()
    payload_leaf_hashes: dict[tuple[str, str], dict[str, str]] = defaultdict(dict)
    seen_names: Counter[str] = Counter()
    unsafe_names: list[str] = []
    largest_members: list[tuple[int, str]] = []
    license_files: list[dict[str, object]] = []
    total_regular_bytes = 0

    payload = defaultdict(
        lambda: {
            "files": 0,
            "rows": 0,
            "nls": set(),
            "task_ids": set(),
            "solution_hashes": set(),
            "raw_pls": set(),
            "file_rows": [],
            "serializations": set(),
            "encodings": set(),
        }
    )
    parsed_rows_by_stem: dict[str, dict[str, int]] = defaultdict(dict)
    parse_errors: list[dict[str, str]] = []
    ignored_payload_json: list[str] = []

    with tarfile.open(args.archive, mode="r|gz") as archive:
        for member in archive:
            seen_names[member.name] += 1
            if PurePosixPath(member.name).parts:
                archive_root_names.add(PurePosixPath(member.name).parts[0])
            if not safe_member_name(member.name):
                unsafe_names.append(member.name)
            if member.isdir():
                member_types["directory"] += 1
                continue
            if member.isfile():
                member_types["regular_file"] += 1
            elif member.issym():
                member_types["symlink"] += 1
                continue
            elif member.islnk():
                member_types["hardlink"] += 1
                continue
            else:
                member_types["other"] += 1
                continue

            handle = archive.extractfile(member)
            if handle is None:
                parse_errors.append({"path": member.name, "error": "unreadable regular member"})
                continue
            content = handle.read()
            content_hash = hashlib.sha256(content).hexdigest()
            total_regular_bytes += member.size
            largest_members.append((member.size, member.name))

            path = PurePosixPath(member.name)
            parts = path.parts
            top_level = parts[1] if len(parts) > 1 else ""
            top_level_files[top_level] += 1
            top_level_bytes[top_level] += member.size
            top_level_content_hashes[top_level].add(content_hash)
            suffix = path.suffix.casefold() or "<none>"
            extension_counts[suffix] += 1

            if is_license_name(path):
                first_line = content.decode("utf-8", errors="replace").splitlines()[0:1]
                license_files.append(
                    {
                        "path": member.name,
                        "size_bytes": member.size,
                        "sha256": content_hash,
                        "first_line": first_line[0] if first_line else "",
                    }
                )

            if top_level not in PAYLOAD_SURFACES or suffix not in {".json", ".csv"}:
                continue
            if any(part.startswith(".") for part in parts[1:]):
                if suffix == ".json":
                    ignored_payload_json.append(member.name)
                continue

            payload_leaf_hashes[(top_level, suffix[1:])][path.name] = content_hash

            try:
                if suffix == ".json":
                    try:
                        records = json.loads(content)
                        serialization = "json_array"
                    except json.JSONDecodeError:
                        records = [json.loads(line) for line in content.splitlines() if line.strip()]
                        serialization = "json_lines"
                    if not isinstance(records, list) or any(
                        not isinstance(record, dict) for record in records
                    ):
                        raise ValueError("payload JSON is not a list of objects")
                    encoding = "utf-8"
                else:
                    try:
                        text = content.decode("utf-8-sig")
                        encoding = "utf-8-sig"
                    except UnicodeDecodeError:
                        try:
                            text = content.decode("cp1252")
                            encoding = "cp1252_fallback"
                        except UnicodeDecodeError:
                            # The mini CSV contains undefined Windows-1252 bytes;
                            # Latin-1 preserves them one-to-one for structural audit.
                            text = content.decode("latin-1")
                            encoding = "latin-1_fallback"
                    records = list(csv.DictReader(io.StringIO(text)))
                    serialization = "csv"
            except (csv.Error, UnicodeDecodeError, ValueError, json.JSONDecodeError) as exc:
                parse_errors.append({"path": member.name, "error": str(exc)})
                continue

            stats = record_stats(records)
            if len(stats["languages"]) != 1:
                parse_errors.append(
                    {
                        "path": member.name,
                        "error": f"mixed or missing PL labels: {sorted(stats['raw_pls'])}",
                    }
                )
                language = ";".join(sorted(stats["languages"]))
            else:
                language = next(iter(stats["languages"]))

            group = payload[(top_level, suffix[1:], language)]
            group["files"] += 1
            group["rows"] += len(records)
            group["nls"].update(stats["nls"])
            group["task_ids"].update(stats["task_ids"])
            group["solution_hashes"].update(stats["solution_hashes"])
            group["raw_pls"].update(stats["raw_pls"])
            group["file_rows"].append(len(records))
            group["serializations"].add(serialization)
            group["encodings"].add(encoding)
            parsed_rows_by_stem[str(path.with_suffix(""))][suffix[1:]] = len(records)

    surface_census = []
    for (surface, file_format, language), group in sorted(payload.items()):
        file_rows = group["file_rows"]
        surface_census.append(
            {
                "surface": surface,
                "format": file_format,
                "programming_language": language,
                "raw_pl_labels": sorted(group["raw_pls"]),
                "files": group["files"],
                "rows": group["rows"],
                "natural_languages": len(group["nls"] - {"UNKNOWN"}),
                "unique_task_ids": len(group["task_ids"]),
                "unique_canonical_solutions": len(group["solution_hashes"]),
                "min_rows_per_file": min(file_rows),
                "max_rows_per_file": max(file_rows),
                "serializations": sorted(group["serializations"]),
                "encodings": sorted(group["encodings"]),
            }
        )

    max_by_format = {
        file_format: {
            row["programming_language"]: row
            for row in surface_census
            if row["surface"] == "mHumanEval-max" and row["format"] == file_format
        }
        for file_format in ("json", "csv")
    }
    observed_max_languages = set(max_by_format["json"]) | set(max_by_format["csv"])
    main_natural_languages = set(
        payload.get(("mHumanEval", "json", "Python"), {}).get("nls", set())
    ) - {"UNKNOWN"}
    max_natural_languages: set[str] = set()
    for (surface, _file_format, _language), group in payload.items():
        if surface == "mHumanEval-max":
            max_natural_languages.update(group["nls"])
    max_natural_languages.discard("UNKNOWN")
    max_language_census = []
    for language in PAPER_PROGRAMMING_LANGUAGES:
        json_observed = max_by_format["json"].get(language)
        csv_observed = max_by_format["csv"].get(language)
        logical_rows = max(
            json_observed["rows"] if json_observed else 0,
            csv_observed["rows"] if csv_observed else 0,
        )
        logical_nls = max(
            json_observed["natural_languages"] if json_observed else 0,
            csv_observed["natural_languages"] if csv_observed else 0,
        )
        logical_tasks = max(
            json_observed["unique_task_ids"] if json_observed else 0,
            csv_observed["unique_task_ids"] if csv_observed else 0,
        )
        logical_solutions = max(
            json_observed["unique_canonical_solutions"] if json_observed else 0,
            csv_observed["unique_canonical_solutions"] if csv_observed else 0,
        )
        max_language_census.append(
            {
                "programming_language": language,
                "paper_claimed": True,
                "present": language in observed_max_languages,
                "json_files": json_observed["files"] if json_observed else 0,
                "json_rows": json_observed["rows"] if json_observed else 0,
                "csv_files": csv_observed["files"] if csv_observed else 0,
                "csv_rows": csv_observed["rows"] if csv_observed else 0,
                "logical_available_rows": logical_rows,
                "natural_languages": logical_nls,
                "unique_task_ids": logical_tasks,
                "unique_canonical_solutions": logical_solutions,
                "min_rows_per_file": min(
                    [
                        row["min_rows_per_file"]
                        for row in (json_observed, csv_observed)
                        if row is not None
                    ],
                    default=0,
                ),
                "max_rows_per_file": max(
                    [
                        row["max_rows_per_file"]
                        for row in (json_observed, csv_observed)
                        if row is not None
                    ],
                    default=0,
                ),
                "claimed_full_grid_rows": 204 * 164,
                "row_shortfall": 204 * 164 - logical_rows,
                "completeness": (
                    "absent"
                    if logical_rows == 0
                    else "complete"
                    if logical_rows == 204 * 164
                    else "partial"
                ),
            }
        )

    surface_summary = []
    for surface in sorted({row["surface"] for row in surface_census}):
        for file_format in ("json", "csv"):
            groups = [
                row
                for row in surface_census
                if row["surface"] == surface and row["format"] == file_format
            ]
            if not groups:
                continue
            surface_summary.append(
                {
                    "surface": surface,
                    "format": file_format,
                    "programming_languages": sorted(
                        row["programming_language"] for row in groups
                    ),
                    "files": sum(row["files"] for row in groups),
                    "rows": sum(row["rows"] for row in groups),
                    "maximum_natural_languages_in_group": max(
                        row["natural_languages"] for row in groups
                    ),
                    "serializations": sorted(
                        {
                            value
                            for row in groups
                            for value in row["serializations"]
                        }
                    ),
                    "encodings": sorted(
                        {value for row in groups for value in row["encodings"]}
                    ),
                }
            )

    paired = [value for value in parsed_rows_by_stem.values() if {"json", "csv"} <= value.keys()]
    pair_mismatches = [value for value in paired if value["json"] != value["csv"]]
    unpaired = [
        {"stem": stem, "formats": sorted(values)}
        for stem, values in parsed_rows_by_stem.items()
        if set(values) != {"json", "csv"}
    ]

    mirror_comparison = []
    for file_format in ("json", "csv"):
        baseline = payload_leaf_hashes[("mHumanEval-max", file_format)]
        for mirror in ("mHumanEval-{NL}", "mHumanEval-{PL}"):
            candidate = payload_leaf_hashes[(mirror, file_format)]
            common = baseline.keys() & candidate.keys()
            mirror_comparison.append(
                {
                    "baseline": "mHumanEval-max",
                    "mirror": mirror,
                    "format": file_format,
                    "baseline_files": len(baseline),
                    "mirror_files": len(candidate),
                    "missing_from_mirror": sorted(baseline.keys() - candidate.keys()),
                    "extra_in_mirror": sorted(candidate.keys() - baseline.keys()),
                    "content_hash_mismatches": sorted(
                        name for name in common if baseline[name] != candidate[name]
                    ),
                }
            )

    result = {
        "schema_version": "1.0.0",
        "source": {
            "name": "mHumanEval-Benchmark",
            "repository_url": "https://github.com/mraihan-gmu/mHumanEval-Benchmark",
            "artifact_revision": args.revision,
            "paper_url": "https://aclanthology.org/2025.naacl-long.570/",
        },
        "archive": {
            "path": str(args.archive),
            "sha256": archive_sha256,
            "compressed_size_bytes": compressed_bytes,
            "root_names": sorted(archive_root_names),
            "stream_completed": True,
            "total_members": sum(member_types.values()),
            "member_types": dict(sorted(member_types.items())),
            "regular_payload_size_bytes": total_regular_bytes,
            "compression_ratio": compressed_bytes / total_regular_bytes,
            "duplicate_member_names": sorted(
                name for name, count in seen_names.items() if count > 1
            ),
            "unsafe_member_names": unsafe_names,
            "extension_counts": dict(sorted(extension_counts.items())),
            "largest_members": [
                {"path": name, "size_bytes": size}
                for size, name in sorted(largest_members, reverse=True)[:10]
            ],
            "top_level": [
                {
                    "name": name,
                    "files": top_level_files[name],
                    "size_bytes": top_level_bytes[name],
                    "unique_content_sha256": len(top_level_content_hashes[name]),
                }
                for name in sorted(top_level_files)
            ],
        },
        "licenses": {
            "declared_repository_license": "Apache-2.0",
            "license_files": license_files,
            "notice_files": sum(
                1 for item in license_files if PurePosixPath(str(item["path"])).name.casefold().startswith("notice")
            ),
            "inherited_humaneval_scope_requires_review": True,
        },
        "paper_claims": {
            "natural_languages": 204,
            "programming_languages": 25,
            "python_rows": 33456,
            "full_grid_rows": 836400,
            "new_programming_languages": ["MATLAB", "Visual Basic", "Fortran", "COBOL"],
        },
        "payload_audit": {
            "observed_max_programming_languages": sorted(observed_max_languages),
            "observed_max_programming_language_count": len(observed_max_languages),
            "main_natural_languages": len(main_natural_languages),
            "max_natural_languages": len(max_natural_languages),
            "main_natural_languages_absent_from_max": sorted(
                main_natural_languages - max_natural_languages
            ),
            "max_natural_languages_absent_from_main": sorted(
                max_natural_languages - main_natural_languages
            ),
            "paper_claimed_but_absent_from_max": sorted(
                set(PAPER_PROGRAMMING_LANGUAGES) - observed_max_languages
            ),
            "max_json_total_rows": sum(
                row["rows"] for row in max_by_format["json"].values()
            ),
            "max_json_total_files": sum(
                row["files"] for row in max_by_format["json"].values()
            ),
            "max_csv_total_rows": sum(
                row["rows"] for row in max_by_format["csv"].values()
            ),
            "max_csv_total_files": sum(
                row["files"] for row in max_by_format["csv"].values()
            ),
            "max_logical_available_rows": sum(
                row["logical_available_rows"] for row in max_language_census
            ),
            "max_logical_row_shortfall_from_paper": 836400
            - sum(row["logical_available_rows"] for row in max_language_census),
            "max_language_census": max_language_census,
            "surface_summary": surface_summary,
            "parsed_json_csv_pairs": len(paired),
            "json_csv_row_count_mismatches": len(pair_mismatches),
            "unpaired_payload_files": unpaired,
            "mirror_comparison": mirror_comparison,
            "ignored_hidden_payload_json": ignored_payload_json,
            "parse_errors": parse_errors,
        },
    }
    if not args.compact:
        result["payload_audit"]["surface_census"] = surface_census
    json.dump(result, fp=__import__("sys").stdout, indent=2, sort_keys=False)
    print()


if __name__ == "__main__":
    main()