| |
| |
| """Validate GauntletBench Hugging Face dataset package structure and release readiness.""" |
|
|
| from __future__ import annotations |
|
|
| import json |
| import re |
| from collections import Counter |
| from pathlib import Path |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| DATA_PATH = ROOT / "data" / "test.jsonl" |
| README_PATH = ROOT / "README.md" |
| DATASET_LICENSE = ROOT / "LICENSE" |
| CODE_LICENSE = ROOT / "LICENSE-APACHE" |
| THIRD_PARTY = ROOT / "THIRD_PARTY_NOTICES.md" |
| SUMMARY_PATH = ROOT / "metadata" / "summary.json" |
| REPO_ID = "gauntletbench-flight/gauntletbench" |
|
|
| FORBIDDEN_PATHS = ( |
| ROOT / "UPLOAD_INSTRUCTIONS.md", |
| ROOT / "scripts" / "upload_to_hf.sh", |
| ) |
|
|
| SECRET_PATTERNS = ( |
| re.compile(r"hf_[A-Za-z0-9]{20,}"), |
| re.compile(r"(?i)(api[_-]?key|secret|password|token)\s*[:=]\s*\S+"), |
| re.compile(r"/Users/[^\s\"']+"), |
| re.compile(r"@[a-zA-Z0-9._%+-]+\.[a-zA-Z]{2,}"), |
| ) |
|
|
| PLACEHOLDER_PATTERNS = ( |
| re.compile(r"YOUR_HF_ORG", re.I), |
| re.compile(r"TODO\b", re.I), |
| re.compile(r"PLACEHOLDER", re.I), |
| re.compile(r"example\.com", re.I), |
| ) |
|
|
|
|
| def fail(message: str) -> None: |
| raise AssertionError(message) |
|
|
|
|
| def read_text(path: Path) -> str: |
| assert path.is_file(), f"Missing required file: {path.relative_to(ROOT)}" |
| return path.read_text(encoding="utf-8") |
|
|
|
|
| def parse_readme_front_matter(readme: str) -> dict: |
| if not readme.startswith("---\n"): |
| fail("README must begin with YAML front matter delimited by ---") |
| end = readme.find("\n---\n", 4) |
| if end == -1: |
| fail("README front matter is not closed with ---") |
| block = readme[4:end] |
| try: |
| import yaml |
| except ImportError as e: |
| raise SystemExit("PyYAML is required for README front matter validation") from e |
| metadata = yaml.safe_load(block) |
| if not isinstance(metadata, dict): |
| fail("README front matter must parse to a mapping") |
| return metadata |
|
|
|
|
| def check_release_readiness() -> None: |
| readme = read_text(README_PATH) |
| front = parse_readme_front_matter(readme) |
| body = readme.split("\n---\n", 2)[-1] |
|
|
| license_value = str(front.get("license", "")).strip().lower() |
| if license_value != "cc-by-4.0": |
| fail(f"README front matter license must be cc-by-4.0, got {front.get('license')!r}") |
|
|
| configs = front.get("configs") |
| if not isinstance(configs, list) or not configs: |
| fail("README front matter must declare configs for Dataset Viewer/Croissant") |
| default = configs[0] |
| if not isinstance(default, dict): |
| fail("README configs entry must be a mapping") |
| if default.get("config_name") != "default": |
| fail("README configs must include config_name: default") |
| data_files = default.get("data_files") |
| if not isinstance(data_files, list) or not data_files: |
| fail("README configs must declare data_files") |
| test_entry = data_files[0] |
| if test_entry.get("split") != "test" or test_entry.get("path") != "data/test.jsonl": |
| fail("README must declare test split at data/test.jsonl") |
| if not DATA_PATH.is_file(): |
| fail("Declared data file data/test.jsonl is missing") |
|
|
| required_sections = { |
| "## License": "licensing", |
| "## Intended use": "intended use", |
| "## Limitations": "limitations", |
| "## Responsible AI considerations": "responsible AI", |
| "## Citation": "citation", |
| "## Third-party materials and exclusions": "third-party exclusions", |
| } |
| for heading, label in required_sections.items(): |
| if heading not in body: |
| fail(f"README missing required {label} section: {heading}") |
|
|
| if REPO_ID not in readme: |
| fail(f"README must reference actual dataset repo id {REPO_ID}") |
| for pattern in PLACEHOLDER_PATTERNS: |
| if pattern.search(readme): |
| fail(f"README contains placeholder pattern: {pattern.pattern}") |
|
|
| dataset_license = read_text(DATASET_LICENSE) |
| if "Creative Commons Attribution 4.0 International" not in dataset_license: |
| fail("LICENSE must contain full CC BY 4.0 legal text") |
| if "Apache License" in dataset_license: |
| fail("Dataset LICENSE must not contain Apache license text") |
|
|
| code_license = read_text(CODE_LICENSE) |
| if "Apache License" not in code_license or "Version 2.0" not in code_license: |
| fail("LICENSE-APACHE must contain full Apache-2.0 legal text") |
|
|
| third_party = read_text(THIRD_PARTY) |
| if "opensky-network.org" not in third_party.lower(): |
| fail("THIRD_PARTY_NOTICES must attribute OpenSky with opensky-network.org URL") |
| if "not redistributed" not in third_party.lower(): |
| fail("THIRD_PARTY_NOTICES must state third-party apps/media are not redistributed") |
| if "openstreetmap" in third_party.lower(): |
| fail("Do not claim OpenStreetMap attribution without distributing OSM-derived material") |
|
|
| if not SUMMARY_PATH.is_file(): |
| fail("Missing dataset_summary.json metadata summary") |
|
|
| for forbidden in FORBIDDEN_PATHS: |
| if forbidden.exists(): |
| fail(f"Internal upload artifact must be removed: {forbidden.relative_to(ROOT)}") |
|
|
| self_path = Path(__file__).resolve() |
| scanned_files = [ |
| p |
| for p in ROOT.rglob("*") |
| if p.is_file() and ".git" not in p.parts and "__pycache__" not in p.parts |
| ] |
| for path in scanned_files: |
| if path.resolve() == self_path: |
| continue |
| if path.is_symlink(): |
| fail(f"Symlinks are not allowed: {path.relative_to(ROOT)}") |
| text = path.read_text(encoding="utf-8", errors="ignore") |
| patterns = list(SECRET_PATTERNS) |
| if path == DATA_PATH: |
| patterns = [p for p in patterns if "@" not in p.pattern] |
| for pattern in patterns: |
| if pattern.search(text): |
| fail( |
| f"Potential secret or personal path in {path.relative_to(ROOT)} " |
| f"(pattern: {pattern.pattern})" |
| ) |
|
|
|
|
| def validate_rows() -> None: |
| rows = [] |
| with DATA_PATH.open(encoding="utf-8") as f: |
| for lineno, line in enumerate(f, 1): |
| try: |
| rows.append(json.loads(line)) |
| except Exception as e: |
| raise SystemExit(f"Invalid JSON on line {lineno}: {e}") from e |
|
|
| required = { |
| "id", |
| "application", |
| "application_name", |
| "task_number", |
| "difficulty", |
| "title", |
| "prompt", |
| "result_format", |
| "ground_truth", |
| "ground_truth_type", |
| "source_page", |
| } |
| assert len(rows) == 100, f"Expected 100 rows, got {len(rows)}" |
| assert len({r["id"] for r in rows}) == 100, "IDs are not unique" |
| for r in rows: |
| missing = required - r.keys() |
| assert not missing, f"{r.get('id')}: missing {missing}" |
| assert r["difficulty"] in {"easy", "medium", "hard"} |
| assert r["ground_truth_type"] in {"text_answer", "application_state"} |
| if r["ground_truth_type"] == "text_answer": |
| assert r["ground_truth"] is not None |
| json.loads(r["ground_truth"]) |
| else: |
| assert r["ground_truth"] is None |
|
|
| apps = Counter(r["application"] for r in rows) |
| diffs = Counter(r["difficulty"] for r in rows) |
| gt = Counter(r["ground_truth_type"] for r in rows) |
| assert set(apps.values()) == {20}, apps |
| assert diffs == Counter({"hard": 45, "medium": 45, "easy": 10}), diffs |
| assert gt == Counter({"application_state": 72, "text_answer": 28}), gt |
|
|
| print("OK") |
| print("rows:", len(rows)) |
| print("applications:", dict(apps)) |
| print("difficulty:", dict(diffs)) |
| print("ground truth types:", dict(gt)) |
|
|
|
|
| def main() -> None: |
| check_release_readiness() |
| validate_rows() |
| print("release readiness: OK") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
