| |
| """Structural and scientific-contract audit for the staged dataset release.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import hashlib |
| import json |
| import re |
| from pathlib import Path |
|
|
| import yaml |
|
|
|
|
| RAI_FIELDS = ( |
| "rai:dataLimitations", |
| "rai:dataBiases", |
| "rai:personalSensitiveInformation", |
| "rai:dataUseCases", |
| "rai:dataSocialImpact", |
| "rai:hasSyntheticData", |
| "prov:wasDerivedFrom", |
| "prov:wasGeneratedBy", |
| ) |
| TYPE_MAP = { |
| "string": "sc:Text", |
| "int64": "sc:Integer", |
| "float64": "sc:Float", |
| "bool": "sc:Boolean", |
| } |
| BLOCKED_CONFIGS = {"infrastructure_evidence_status", "future_route_schema"} |
| SOURCE_REVISION = "932f6f4f62c3402adf38231ed83ea9ca17cc227c" |
| CODE_REVISION = "eb8a2f3a681a3d596d5acf454f6ce2fc5a6f677d" |
| LICENSE_ID = "cc-by-4.0" |
| LICENSE_SPDX = "CC-BY-4.0" |
| LICENSE_URL = "https://creativecommons.org/licenses/by/4.0/" |
| NONPUBLIC_REPOSITORY_URL = re.compile( |
| r"https://github\.com/[^\s\"']+/[^/\s\"']*(?:paper|manuscript)[^/\s\"']*", |
| re.IGNORECASE, |
| ) |
|
|
|
|
| def sha256(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 card_metadata(root: Path) -> dict: |
| text = (root / "README.md").read_text(encoding="utf-8") |
| if not text.startswith("---\n"): |
| raise ValueError("README.md must begin with YAML frontmatter") |
| return yaml.safe_load(text.split("---", 2)[1]) or {} |
|
|
|
|
| def main() -> int: |
| parser = argparse.ArgumentParser() |
| parser.add_argument("root", nargs="?", default=".") |
| parser.add_argument("--json-out") |
| parser.add_argument( |
| "--skip-byte-checksums", |
| action="store_true", |
| help="verify checksum coverage and format without hashing local bytes", |
| ) |
| parser.add_argument( |
| "--release-gate", |
| action="store_true", |
| help="also fail on acknowledged publication blockers", |
| ) |
| args = parser.parse_args() |
| root = Path(args.root).resolve() |
| errors: list[dict] = [] |
| blockers: list[dict] = [] |
| warnings: list[dict] = [] |
|
|
| def error(code: str, detail) -> None: |
| errors.append({"code": code, "detail": detail}) |
|
|
| def blocker(code: str, detail) -> None: |
| blockers.append({"code": code, "detail": detail}) |
|
|
| metadata = card_metadata(root) |
| if metadata.get("license") != LICENSE_ID: |
| error("card.license", {"expected": LICENSE_ID, "actual": metadata.get("license")}) |
| configs = metadata.get("configs") or [] |
| names = [item.get("config_name") for item in configs] |
| if len(names) != len(set(names)): |
| error("card.duplicate_configuration", names) |
| defaults = [item for item in configs if item.get("default") is True] |
| if len(defaults) != 1: |
| error("card.default_configuration", f"expected one default, got {len(defaults)}") |
| if set(names) & BLOCKED_CONFIGS: |
| error( |
| "card.blocked_configuration_exposed", |
| sorted(set(names) & BLOCKED_CONFIGS), |
| ) |
|
|
| manifest = json.loads((root / "metadata/release_manifest.json").read_text()) |
| schema = json.loads((root / "metadata/schema.json").read_text()) |
| croissant = json.loads((root / "metadata/croissant.json").read_text()) |
| manifest_by = {item["name"]: item for item in manifest.get("configs", [])} |
| schema_by = {item["name"]: item for item in schema.get("record_sets", [])} |
| if set(names) != set(manifest_by): |
| error("manifest.configuration_set", sorted(set(names) ^ set(manifest_by))) |
| if set(names) != set(schema_by): |
| error("schema.configuration_set", sorted(set(names) ^ set(schema_by))) |
| if any(not str(item.get("path", "")).startswith("data/processed/") for item in manifest_by.values()): |
| error("layers.processed_configuration_root", "every loadable configuration must live under data/processed/") |
| if manifest.get("canonical_source_revision") != SOURCE_REVISION: |
| error("provenance.source_revision", manifest.get("canonical_source_revision")) |
| if manifest.get("code_revision") != CODE_REVISION: |
| error("provenance.code_revision", manifest.get("code_revision")) |
| if manifest.get("license") != LICENSE_SPDX: |
| error("release.license", manifest.get("license")) |
| if manifest.get("license_url") != LICENSE_URL: |
| error("release.license_url", manifest.get("license_url")) |
| if manifest.get("status") != "READY_FOR_HF_STAGING": |
| error("release.staging_status", manifest.get("status")) |
| pipeline_contract = json.loads((root / "metadata/pipeline_contract.json").read_text()) |
| if pipeline_contract.get("no_requery_policy") is not True: |
| error("pipeline.no_requery_policy", pipeline_contract.get("no_requery_policy")) |
| if pipeline_contract.get("source", {}).get("revision") != SOURCE_REVISION: |
| error("pipeline.source_revision", pipeline_contract.get("source", {}).get("revision")) |
| if pipeline_contract.get("code", {}).get("revision") != CODE_REVISION: |
| error("pipeline.code_revision", pipeline_contract.get("code", {}).get("revision")) |
| clean_load = json.loads((root / "metadata/clean_load_audit.json").read_text()) |
| if clean_load.get("hf_datasets_clean_load") != "PASS": |
| error("hosting.local_hf_clean_load", clean_load.get("hf_datasets_clean_load")) |
| if len(clean_load.get("configurations") or []) != len(names): |
| error("hosting.local_hf_configuration_count", len(clean_load.get("configurations") or [])) |
| croissant_receipt = json.loads( |
| (root / "metadata/croissant_validation.json").read_text() |
| ) |
| if croissant_receipt.get("status") != "PASS_LOCAL_CANDIDATE": |
| error("croissant.local_validation", croissant_receipt.get("status")) |
|
|
| with (root / "metadata/migration_manifest.csv").open( |
| newline="", encoding="utf-8-sig" |
| ) as handle: |
| migration_rows = list(csv.DictReader(handle)) |
| if len(migration_rows) != 32: |
| error("migration.record_count", len(migration_rows)) |
| migration_ids = [row.get("artifact_id") for row in migration_rows] |
| if len(migration_ids) != len(set(migration_ids)): |
| error("migration.duplicate_artifact_id", migration_ids) |
| migrated_targets = set() |
| for row in migration_rows: |
| target = row.get("target_path", "") |
| status = row.get("migration_status", "") |
| if status == "VERIFIED_COPY": |
| path = root / target |
| migrated_targets.add(target) |
| if not path.is_file(): |
| error("migration.missing_verified_copy", target) |
| continue |
| if sha256(path) != row.get("sha256"): |
| error("migration.digest", {"artifact_id": row.get("artifact_id"), "path": target}) |
| if path.suffix == ".csv" and row.get("row_count"): |
| with path.open(newline="", encoding="utf-8-sig") as handle: |
| actual_rows = len(list(csv.DictReader(handle))) |
| if actual_rows != int(row["row_count"]): |
| error("migration.row_count", {"artifact_id": row.get("artifact_id"), "expected": row.get("row_count"), "actual": actual_rows}) |
| elif target: |
| error("migration.unverified_target_exposed", {"artifact_id": row.get("artifact_id"), "status": status, "path": target}) |
| queried_files = { |
| path.relative_to(root).as_posix() |
| for path in (root / "data/queried").glob("*/*") |
| if path.is_file() |
| } |
| if queried_files - migrated_targets: |
| error("migration.untracked_queried_file", sorted(queried_files - migrated_targets)) |
| processed_config_paths = {item.get("path") for item in manifest_by.values()} |
| if processed_config_paths - migrated_targets: |
| error("migration.untracked_processed_configuration", sorted(processed_config_paths - migrated_targets)) |
|
|
| with (root / "metadata/data_dictionary.csv").open( |
| newline="", encoding="utf-8-sig" |
| ) as handle: |
| dictionary_rows = list(csv.DictReader(handle)) |
| dictionary = { |
| (row["configuration"], row["name"]): row for row in dictionary_rows |
| } |
|
|
| loaded = [] |
| for item in configs: |
| name = item["config_name"] |
| specs = item.get("data_files") or [] |
| if len(specs) != 1: |
| error("card.data_files_shape", {"configuration": name, "entries": specs}) |
| continue |
| spec = specs[0] |
| if spec.get("split") != "train": |
| error("card.split", {"configuration": name, "split": spec.get("split")}) |
| rel = spec.get("path") |
| path = root / str(rel) |
| if not path.is_file(): |
| error("card.missing_data_file", {"configuration": name, "path": rel}) |
| continue |
| with path.open(newline="", encoding="utf-8-sig") as handle: |
| reader = csv.DictReader(handle) |
| fields = list(reader.fieldnames or []) |
| rows = list(reader) |
| m = manifest_by.get(name, {}) |
| s = schema_by.get(name, {}) |
| if m.get("path") != rel: |
| error("manifest.path", {"configuration": name, "path": m.get("path")}) |
| if m.get("split") != "train": |
| error("manifest.split", {"configuration": name, "split": m.get("split")}) |
| if m.get("rows") != len(rows) or s.get("rows") != len(rows): |
| error( |
| "schema.row_count", |
| { |
| "configuration": name, |
| "csv": len(rows), |
| "manifest": m.get("rows"), |
| "schema": s.get("rows"), |
| }, |
| ) |
| if m.get("fields") != fields: |
| error("manifest.fields", {"configuration": name}) |
| schema_fields = [field.get("name") for field in s.get("fields", [])] |
| if schema_fields != fields: |
| error("schema.fields", {"configuration": name}) |
| key = m.get("primary_key") or [] |
| if not key or any(column not in fields for column in key): |
| error("manifest.primary_key", {"configuration": name, "key": key}) |
| else: |
| values = [tuple(row[column] for column in key) for row in rows] |
| if any(any(value == "" for value in item) for item in values): |
| error("data.null_primary_key", {"configuration": name, "key": key}) |
| if len(values) != len(set(values)): |
| error("data.duplicate_primary_key", {"configuration": name, "key": key}) |
| for field in s.get("fields", []): |
| row = dictionary.get((name, field.get("name"))) |
| if not row: |
| error( |
| "dictionary.missing_field", |
| {"configuration": name, "field": field.get("name")}, |
| ) |
| elif field.get("type") != row.get("type"): |
| error( |
| "schema.type", |
| { |
| "configuration": name, |
| "field": field.get("name"), |
| "schema": field.get("type"), |
| "dictionary": row.get("type"), |
| }, |
| ) |
| if row: |
| field_name = field.get("name") |
| declared_type = row.get("type") |
| for index, record in enumerate(rows, start=2): |
| value = record[field_name] |
| if value == "": |
| continue |
| try: |
| if declared_type == "int64": |
| int(value) |
| elif declared_type == "float64": |
| float(value) |
| elif declared_type == "bool" and value.lower() not in { |
| "true", |
| "false", |
| }: |
| raise ValueError("expected true or false") |
| except ValueError: |
| error( |
| "data.type_parse", |
| { |
| "configuration": name, |
| "field": field_name, |
| "row": index, |
| "type": declared_type, |
| "value": value, |
| }, |
| ) |
| break |
| loaded.append( |
| { |
| "configuration": name, |
| "path": rel, |
| "rows": len(rows), |
| "columns": len(fields), |
| "primary_key": key, |
| } |
| ) |
|
|
| context = croissant.get("@context") or {} |
| if context.get("cr") != "http://mlcommons.org/croissant/": |
| error("croissant.context", "missing Croissant namespace") |
| if context.get("rai") != "http://mlcommons.org/croissant/RAI/": |
| error("croissant.context", "missing RAI namespace") |
| if croissant.get("conformsTo") != "http://mlcommons.org/croissant/1.1": |
| error("croissant.version", croissant.get("conformsTo")) |
| for field in RAI_FIELDS: |
| if field not in croissant or croissant[field] in ("", None, [], {}): |
| error("croissant.rai", field) |
| if croissant.get("license") != LICENSE_URL: |
| error("croissant.license", {"expected": LICENSE_URL, "actual": croissant.get("license")}) |
| if not isinstance(croissant.get("rai:hasSyntheticData"), bool): |
| error("croissant.synthetic_boolean", croissant.get("rai:hasSyntheticData")) |
| for field in RAI_FIELDS: |
| if field in {"rai:hasSyntheticData", "prov:wasDerivedFrom", "prov:wasGeneratedBy"}: |
| continue |
| if len(str(croissant.get(field, "")).strip()) < 80: |
| error("croissant.rai_substantive", field) |
| if not croissant.get("creator"): |
| error("croissant.creator", "dataset creators are required") |
| if croissant.get("isAccessibleForFree") is not True: |
| error("croissant.free_access", croissant.get("isAccessibleForFree")) |
|
|
| distributions = { |
| item.get("name"): item for item in croissant.get("distribution", []) |
| } |
| record_sets = {item.get("name"): item for item in croissant.get("recordSet", [])} |
| if set(distributions) != set(names): |
| error("croissant.distribution_set", sorted(set(distributions) ^ set(names))) |
| if set(record_sets) != set(names): |
| error("croissant.record_set", sorted(set(record_sets) ^ set(names))) |
| for name in names: |
| m = manifest_by.get(name, {}) |
| distribution = distributions.get(name, {}) |
| record_set = record_sets.get(name, {}) |
| if distribution.get("contentUrl") != m.get("path"): |
| error("croissant.content_url", {"configuration": name}) |
| if distribution.get("sha256") != m.get("sha256"): |
| error("croissant.sha256", {"configuration": name}) |
| if distribution.get("contentSize") != str(m.get("bytes")): |
| error("croissant.content_size", {"configuration": name}) |
| cr_fields = record_set.get("field") or [] |
| if [item.get("name") for item in cr_fields] != m.get("fields"): |
| error("croissant.fields", {"configuration": name}) |
| for field in cr_fields: |
| expected = TYPE_MAP.get( |
| dictionary.get((name, field.get("name")), {}).get("type") |
| ) |
| if field.get("dataType") != expected: |
| error( |
| "croissant.data_type", |
| { |
| "configuration": name, |
| "field": field.get("name"), |
| "expected": expected, |
| "actual": field.get("dataType"), |
| }, |
| ) |
|
|
| checksum_path = root / "metadata/checksums.sha256" |
| checksums = {} |
| for line in checksum_path.read_text(encoding="utf-8").splitlines(): |
| if not line.strip(): |
| continue |
| match = re.fullmatch(r"([0-9a-f]{64}) (.+)", line) |
| if not match: |
| error("checksums.format", line) |
| continue |
| checksums[match.group(2)] = match.group(1) |
| payload = [ |
| path |
| for path in root.rglob("*") |
| if path.is_file() |
| and "__pycache__" not in path.parts |
| and ".git" not in path.parts |
| and path.relative_to(root).as_posix() |
| not in { |
| "audit_tmp.py", |
| "metadata/checksums.sha256", |
| "metadata/validation_run.json", |
| } |
| ] |
| for path in payload: |
| rel = path.relative_to(root).as_posix() |
| expected = checksums.get(rel) |
| if expected is None: |
| error("checksums.untracked", rel) |
| elif not args.skip_byte_checksums and sha256(path) != expected: |
| error("checksums.mismatch", rel) |
| stale = sorted(set(checksums) - {p.relative_to(root).as_posix() for p in payload}) |
| if stale: |
| error("checksums.stale", stale) |
| if args.skip_byte_checksums: |
| warnings.append( |
| { |
| "code": "checksums.byte_verification_skipped", |
| "detail": "coverage and format checked; hash bytes must be verified on the committed Git tree", |
| } |
| ) |
|
|
| ledger = json.loads((root / "metadata/claim_status.json").read_text()) |
| for claim in ledger.get("claims", []): |
| for rel in claim.get("supporting_artifacts", []): |
| if not (root / rel).is_file(): |
| error( |
| "claim.missing_support", |
| {"claim_id": claim.get("claim_id"), "path": rel}, |
| ) |
| with (root / "metadata/claim_ledger.csv").open( |
| newline="", encoding="utf-8-sig" |
| ) as handle: |
| for claim in csv.DictReader(handle): |
| for rel in claim["supporting_artifacts"].split(";"): |
| if rel and not (root / rel).is_file(): |
| error( |
| "claim.missing_support", |
| {"claim_id": claim["claim_id"], "path": rel}, |
| ) |
|
|
| text_suffixes = {".md", ".json", ".csv", ".yml", ".yaml", ".txt", ".cff"} |
| for path in root.rglob("*"): |
| if not path.is_file() or path.suffix.lower() not in text_suffixes: |
| continue |
| if "__pycache__" in path.parts or path.name == "checksums.sha256": |
| continue |
| content = path.read_text(encoding="utf-8", errors="ignore") |
| match = NONPUBLIC_REPOSITORY_URL.search(content) |
| if match: |
| error( |
| "public_boundary.nonpublic_repository_url", |
| {"path": path.relative_to(root).as_posix(), "url": match.group(0)}, |
| ) |
| blocker("release.hub_publication", "dataset is not published") |
| blocker( |
| "release.platform_validation", |
| "Dataset Viewer, platform Croissant merge, and official validation not run", |
| ) |
|
|
| report = { |
| "verdict": "READY_FOR_HF_STAGING" if not errors else "NOT_READY", |
| "publication_status": "NOT_YET_PUBLISHED" if blockers else "PUBLISHED", |
| "structural_status": "PASS" if not errors else "FAIL", |
| "errors": errors, |
| "blockers": blockers, |
| "warnings": warnings, |
| "configuration_count": len(configs), |
| "loaded": loaded, |
| } |
| rendered = json.dumps(report, indent=2, sort_keys=True) + "\n" |
| if args.json_out: |
| Path(args.json_out).write_text(rendered, encoding="utf-8") |
| print(rendered, end="") |
| if errors or (args.release_gate and blockers): |
| return 1 |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
