#!/usr/bin/env python3 """Validate the CropMath Hugging Face release package.""" from __future__ import annotations import argparse import json from pathlib import Path import re EXPECTED = { "default": {"dev": 252, "test": 751, "gold": 95}, "eval_prompts": {"dev": 1512, "test": 4506, "gold": 570}, } EXPECTED_HIDDEN_PUBLIC = 160 CONDITIONS = {"C", "K_name", "K_formula", "K_domain", "K_distractor", "K_wrong"} PUBLIC_CONTENT_SUFFIXES = {".json", ".jsonl", ".csv", ".yaml", ".yml"} FORBIDDEN_PUBLIC_CONTENT = { "specific framework name": re.compile( r"RiceGrow|CH4MOD|AgroC|\bSIMPLE\b|\bDSSAT\b|\bAPSIM\b|" r"\bWOFOST\b|\bORYZA\b|\bDNDC\b|\bCENTURY\b|\bDayCent\b|" r"\bCERES\b|\bAquaCrop\b|\bSTICS\b|\bEPIC\b" ), "source-code wording": re.compile( r"source[ -]?code|codebase|源代码|源码|代码溯源|代码实现|代码位置", re.IGNORECASE, ), "implementation file reference": re.compile( r"(?:^|[\s'\"])(?:src|scripts)/[^\s'\"]+|\b[^\s/]+\.(?:py|R)\b", re.IGNORECASE, ), "generated citation": re.compile( r"\bet\s+al\.?\b|\bdoi\s*:|https?://|\bcited in\b|\bcitation\b", re.IGNORECASE, ), } # Code-area scan: catches model-name and provenance leaks in the public repo's # Python/Markdown sources. Unlike FORBIDDEN_PUBLIC_CONTENT this does NOT reject # legitimate ``.py`` references (code files legitimately live in the repo) and # does NOT reject generic URLs (eval scripts reference model hubs); it focuses # on the specific residue that would reveal the private formula provenance. REPO_ROOT_SCAN_DIRS = ("src", "evaluation", "scripts", "tests") REPO_ROOT_SCAN_FILES = ("README.md", "AGENTS.md") REPO_ROOT_CODE_SUFFIXES = {".py", ".md", ".yaml", ".yml", ".sh"} REPO_ROOT_FORBIDDEN = { "specific framework name": re.compile( r"RiceGrow|CH4MOD|AgroC|\bSIMPLE crop\b|\bSIMPLE model\b|" r"\bDSSAT\b|\bAPSIM\b|\bWOFOST\b|\bORYZA\b|\bDNDC\b|" r"\bCENTURY\b|\bDayCent\b|\bCERES\b|\bAquaCrop\b|\bSTICS\b|\bEPIC\b" ), "provenance citation in code": re.compile( r"\b(?:Tang|Huang|Herbst|Zhao)\s+(?:19|20)\d{2}\b|" r"\bfrom\s+(?:CH4MOD|RiceGrow|AgroC)\s+code\b|" r"\bCommon\.R\b|\bfunc_[A-Za-z][A-Za-z0-9_]+", re.IGNORECASE, ), "implementation file reference": re.compile( r"\bcropmath\.formulas\b|\bcropmath\.generator\b|" r"\b[^\s/]+\.R\b", re.IGNORECASE, ), } # Files that legitimately encode the forbidden patterns as a *defense* (the # validator itself and the clean-release builder, both of which carry the # blocklist). Scanned but whitelisted by relative path so the defense keeps # working without false positives. REPO_ROOT_SCAN_ALLOWLIST = { "scripts/validate_cropmath_release.py", "scripts/build_clean_public_release.py", } def load_jsonl(path: Path) -> list[dict]: with path.open(encoding="utf-8") as f: return [json.loads(line) for line in f if line.strip()] def require(condition: bool, message: str, issues: list[str]) -> None: if not condition: issues.append(message) def validate_public_content(release_dir: Path) -> list[str]: """Reject private implementation and citation residue in public data files.""" issues: list[str] = [] for path in sorted(release_dir.rglob("*")): if not path.is_file() or path.suffix.lower() not in PUBLIC_CONTENT_SUFFIXES: continue text = path.read_text(encoding="utf-8", errors="replace") for label, pattern in FORBIDDEN_PUBLIC_CONTENT.items(): match = pattern.search(text) if match: relative = path.relative_to(release_dir) issues.append(f"{relative}: {label}: {match.group(0)!r}") return issues def validate_repo_root_content(repo_root: Path) -> list[str]: """Reject private provenance residue in the public repo's own source files. Scans ``src/``, ``evaluation/``, ``scripts/``, ``tests/`` plus top-level markdown for crop-model names, paper-year citations, and implementation references that would reveal the private formula provenance. The validator itself is allowlisted so its defensive blocklist keeps working. """ issues: list[str] = [] candidates: list[Path] = [] for name in REPO_ROOT_SCAN_DIRS: directory = repo_root / name if directory.is_dir(): for path in directory.rglob("*"): if path.is_file() and path.suffix.lower() in REPO_ROOT_CODE_SUFFIXES: candidates.append(path) for name in REPO_ROOT_SCAN_FILES: path = repo_root / name if path.is_file(): candidates.append(path) for path in sorted(candidates): try: relative = path.relative_to(repo_root).as_posix() except ValueError: relative = str(path) if relative in REPO_ROOT_SCAN_ALLOWLIST: continue text = path.read_text(encoding="utf-8", errors="replace") for label, pattern in REPO_ROOT_FORBIDDEN.items(): match = pattern.search(text) if match: issues.append(f"{relative}: {label}: {match.group(0)!r}") return issues def validate_jsonl(release_dir: Path) -> list[str]: issues: list[str] = [] rows: dict[tuple[str, str], list[dict]] = {} for config, split_counts in EXPECTED.items(): for split, expected_n in split_counts.items(): path = release_dir / "data" / config / f"{split}.jsonl" require(path.exists(), f"missing file: {path}", issues) if not path.exists(): continue data = load_jsonl(path) rows[(config, split)] = data ids = [row["id"] for row in data] require(len(data) == expected_n, f"{config}/{split}: {len(data)} rows, expected {expected_n}", issues) require(len(ids) == len(set(ids)), f"{config}/{split}: duplicate IDs", issues) require(all(row.get("answer") not in (None, "") for row in data), f"{config}/{split}: missing answer", issues) if config == "eval_prompts": require(all(row.get("prompt") for row in data), f"{config}/{split}: missing prompt", issues) require({row.get("condition") for row in data} <= CONDITIONS, f"{config}/{split}: invalid condition", issues) dev_ids = {row["id"] for row in rows.get(("default", "dev"), [])} test_ids = {row["id"] for row in rows.get(("default", "test"), [])} gold_ids = {row["id"] for row in rows.get(("default", "gold"), [])} require(not (dev_ids & test_ids), "default/dev and default/test overlap", issues) require(gold_ids <= test_ids, "default/gold is not a subset of default/test", issues) for split in ["dev", "test", "gold"]: default_ids = {row["id"] for row in rows.get(("default", split), [])} eval_rows = rows.get(("eval_prompts", split), []) eval_sample_ids = [row["sample_id"] for row in eval_rows] require(set(eval_sample_ids) == default_ids, f"eval_prompts/{split}: sample IDs do not match default/{split}", issues) for sample_id in default_ids: sample_conditions = {row["condition"] for row in eval_rows if row["sample_id"] == sample_id} require(sample_conditions == CONDITIONS, f"eval_prompts/{split}: {sample_id} does not have all six conditions", issues) hidden_path = release_dir / "hidden_public" / "hidden_public.jsonl" require(hidden_path.exists(), "missing hidden public file", issues) if hidden_path.exists(): hidden_rows = load_jsonl(hidden_path) hidden_ids = {row["id"] for row in hidden_rows} require(len(hidden_rows) == EXPECTED_HIDDEN_PUBLIC, f"hidden_public: {len(hidden_rows)} rows, expected {EXPECTED_HIDDEN_PUBLIC}", issues) require(len(hidden_rows) == len(hidden_ids), "hidden_public: duplicate IDs", issues) require(not (hidden_ids & (dev_ids | test_ids | gold_ids)), "hidden_public overlaps dev/test/gold IDs", issues) forbidden = {"answer", "solution", "effective_parameters", "answer_float"} leaked = [row["id"] for row in hidden_rows if forbidden & set(row)] require(not leaked, f"hidden_public leaks answer-bearing fields: {leaked[:5]}", issues) require(all(row.get("answer_hidden") is True for row in hidden_rows), "hidden_public rows must set answer_hidden=true", issues) bad_sensitivity = [row["id"] for row in hidden_rows if row.get("mode") == "sensitivity" and not row.get("change")] require(not bad_sensitivity, f"hidden_public sensitivity rows missing change: {bad_sensitivity[:5]}", issues) private_markers = list(release_dir.rglob("*private*")) + list(release_dir.rglob("*answer*.jsonl")) leaked_private = [str(path.relative_to(release_dir)) for path in private_markers if "hidden_public" not in str(path)] require(not leaked_private, f"private answer-like files found in public release: {leaked_private}", issues) return issues def validate_hf_loader(release_dir: Path) -> list[str]: try: from datasets import load_dataset except ImportError: return ["datasets is not installed; HF loader validation requires this dependency"] issues: list[str] = [] for config, split_counts in EXPECTED.items(): dataset = load_dataset(str(release_dir), config) observed = {split: len(dataset[split]) for split in split_counts} if observed != split_counts: issues.append(f"HF loader {config}: {observed}, expected {split_counts}") hidden_dataset = load_dataset(str(release_dir), "hidden_public") hidden_observed = len(hidden_dataset["hidden_public"]) if hidden_observed != EXPECTED_HIDDEN_PUBLIC: issues.append(f"HF loader hidden_public: {hidden_observed}, expected {EXPECTED_HIDDEN_PUBLIC}") return issues def main() -> None: parser = argparse.ArgumentParser(description="Validate CropMath release/cropmath-v1") parser.add_argument("--release-dir", default="release/cropmath-v1") parser.add_argument("--skip-hf-loader", action="store_true") parser.add_argument( "--no-scan-repo-root", dest="scan_repo_root", action="store_false", default=True, help="Skip scanning the public repo source tree for provenance residue.", ) args = parser.parse_args() release_dir = Path(args.release_dir).resolve() repo_root = release_dir.parents[1] if release_dir.name == "cropmath-v1" else Path.cwd().resolve() try: release_label = str(release_dir.relative_to(Path.cwd().resolve())) except ValueError: release_label = str(Path(args.release_dir)) issues = validate_jsonl(release_dir) issues.extend(validate_public_content(release_dir)) repo_root_issues: list[str] = [] if args.scan_repo_root: repo_root_issues = validate_repo_root_content(repo_root) hf_issues = [] if args.skip_hf_loader else validate_hf_loader(release_dir) all_hard_issues = issues + repo_root_issues + hf_issues report = { "release_dir": release_label, "jsonl_pass": not issues, "hf_loader_pass": None if args.skip_hf_loader else not hf_issues, "repo_root_scan_pass": None if not args.scan_repo_root else not repo_root_issues, "issues": issues + repo_root_issues, "hf_loader_issues": hf_issues, } print(json.dumps(report, ensure_ascii=False, indent=2)) if all_hard_issues: raise SystemExit(1) if __name__ == "__main__": main()