#!/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 "" 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()