Upload scripts/validate_dataset.py

scripts/validate_dataset.py

@@ -0,0 +1,224 @@
+#!/usr/bin/env python3
+"""Validate the checked-in YUTABASE RepoSearch MiniEval without dependencies."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from collections import Counter
+from pathlib import Path
+from typing import Any, Iterable
+
+
+ROOT = Path(__file__).resolve().parents[1]
+EXPECTED_COMMIT = "d72605d05061b7853a8e9bf3eb73417e3a4457dc"
+EXPECTED_TREE = "592f1b15b14fbe0ee29ef4e4769a43aace7e1e65"
+EXPECTED_QUERY_IDS = {f"Q{number:02d}" for number in range(1, 28)}
+EXPECTED_SPLIT_COUNTS = {"validation": 9, "test": 18}
+EXPECTED_LANGUAGE_COUNTS = {"en": 13, "yue-Hant": 11, "mul": 3}
+EXPECTED_CORPUS_COUNT = 73
+PROHIBITED_MARKERS = (
+    "/Users/",
+    "/home/",
+    ".codex/",
+    "BEGIN PRIVATE KEY",
+    "npm_",
+    "hf_",
+)
+
+
+class ValidationError(RuntimeError):
+    pass
+
+
+def read_jsonl(path: Path) -> list[dict[str, Any]]:
+    records: list[dict[str, Any]] = []
+    with path.open(encoding="utf-8") as handle:
+        for line_number, line in enumerate(handle, 1):
+            if not line.strip():
+                raise ValidationError(f"{path}:{line_number}: blank JSONL row")
+            try:
+                value = json.loads(line)
+            except json.JSONDecodeError as error:
+                raise ValidationError(f"{path}:{line_number}: {error}") from error
+            if not isinstance(value, dict):
+                raise ValidationError(f"{path}:{line_number}: row must be an object")
+            records.append(value)
+    return records
+
+
+def require(condition: bool, message: str) -> None:
+    if not condition:
+        raise ValidationError(message)
+
+
+def unique(records: Iterable[dict[str, Any]], key: str, label: str) -> dict[str, dict[str, Any]]:
+    indexed: dict[str, dict[str, Any]] = {}
+    for record in records:
+        value = record.get(key)
+        require(isinstance(value, str) and value != "", f"{label}: missing {key}")
+        require(value not in indexed, f"{label}: duplicate {key} {value!r}")
+        indexed[value] = record
+    return indexed
+
+
+def validate(root: Path = ROOT) -> dict[str, Any]:
+    manifest = json.loads((root / "source-manifest.json").read_text(encoding="utf-8"))
+    source = manifest.get("source", {})
+    require(
+        manifest.get("dataset_profile") == "yutabase.reposearch-minieval/0.1",
+        "unexpected dataset profile",
+    )
+    require(source.get("commit_sha") == EXPECTED_COMMIT, "manifest commit mismatch")
+    require(source.get("tree_sha") == EXPECTED_TREE, "manifest tree mismatch")
+    require(source.get("license") == "MIT", "manifest source license must be MIT")
+
+    artifacts = manifest.get("artifacts")
+    require(isinstance(artifacts, dict), "manifest artifacts must be an object")
+    for relative_path, expected in artifacts.items():
+        require(relative_path in {"data/corpus.jsonl", "data/validation.jsonl", "data/test.jsonl"}, f"unexpected artifact {relative_path}")
+        raw = (root / relative_path).read_bytes()
+        require(
+            hashlib.sha256(raw).hexdigest() == expected.get("sha256"),
+            f"{relative_path}: artifact SHA-256 mismatch",
+        )
+        require(
+            len(raw.splitlines()) == expected.get("rows"),
+            f"{relative_path}: artifact row-count mismatch",
+        )
+
+    source_license = (root / "SOURCE_LICENSES" / "YUTABASE-MIT.txt").read_bytes()
+    require(
+        hashlib.sha256(source_license).hexdigest() == source.get("license_sha256"),
+        "copied YUTABASE license does not match its pinned SHA-256",
+    )
+
+    allowlist_rows = manifest.get("allowlist")
+    require(isinstance(allowlist_rows, list) and len(allowlist_rows) == 12, "allowlist must contain 12 files")
+    allowlist = unique(allowlist_rows, "path", "allowlist")
+    for path, entry in allowlist.items():
+        require(not path.startswith("/") and ".." not in Path(path).parts, f"unsafe allowlist path: {path}")
+        require(len(entry.get("git_blob_sha1", "")) == 40, f"{path}: invalid Git blob")
+        require(len(entry.get("file_sha256", "")) == 64, f"{path}: invalid file SHA-256")
+        require(entry.get("source_kind") in {"markdown", "typescript"}, f"{path}: invalid source kind")
+        require(isinstance(entry.get("authority_class"), str), f"{path}: missing authority class")
+
+    corpus_rows = read_jsonl(root / "data" / "corpus.jsonl")
+    require(len(corpus_rows) == EXPECTED_CORPUS_COUNT, f"expected {EXPECTED_CORPUS_COUNT} corpus rows")
+    corpus = unique(corpus_rows, "chunk_id", "corpus")
+    source_prefix = f"{source['repo_url']}/blob/{EXPECTED_COMMIT}/"
+    corpus_text = []
+    for chunk_id, row in corpus.items():
+        path = row.get("path")
+        require(path in allowlist, f"{chunk_id}: source path is not allowlisted")
+        file_entry = allowlist[path]
+        for field in ("repo_id", "repo_url", "commit_sha", "tree_sha", "git_blob_sha1", "file_sha256", "source_kind", "authority_class"):
+            expected = source.get(field) if field in source else file_entry.get(field)
+            require(row.get(field) == expected, f"{chunk_id}: {field} mismatch")
+        require(row.get("license") == "MIT", f"{chunk_id}: license mismatch")
+        require(row.get("language") == "en", f"{chunk_id}: unexpected source language")
+        start = row.get("line_start")
+        end = row.get("line_end")
+        require(isinstance(start, int) and isinstance(end, int) and 1 <= start <= end, f"{chunk_id}: invalid line range")
+        text = row.get("text")
+        require(isinstance(text, str) and text != "", f"{chunk_id}: empty text")
+        require(len(text.splitlines()) == end - start + 1, f"{chunk_id}: text/line range mismatch")
+        require(
+            hashlib.sha256(text.encode("utf-8")).hexdigest() == row.get("chunk_sha256"),
+            f"{chunk_id}: chunk SHA-256 mismatch",
+        )
+        expected_url = f"{source_prefix}{path}#L{start}-L{end}"
+        require(row.get("source_url") == expected_url, f"{chunk_id}: source URL mismatch")
+        corpus_text.append(text)
+
+    query_rows: list[dict[str, Any]] = []
+    for split, expected_count in EXPECTED_SPLIT_COUNTS.items():
+        rows = read_jsonl(root / "data" / f"{split}.jsonl")
+        require(len(rows) == expected_count, f"{split}: expected {expected_count} rows")
+        for row in rows:
+            require(row.get("split") == split, f"{row.get('query_id')}: split mismatch")
+        query_rows.extend(rows)
+
+    queries = unique(query_rows, "query_id", "queries")
+    require(set(queries) == EXPECTED_QUERY_IDS, "query IDs must be exactly Q01 through Q27")
+    require(Counter(row.get("language") for row in query_rows) == EXPECTED_LANGUAGE_COUNTS, "language totals mismatch")
+    require(Counter(row.get("split") for row in query_rows) == EXPECTED_SPLIT_COUNTS, "split totals mismatch")
+
+    for query_id, row in queries.items():
+        query = row.get("query")
+        require(isinstance(query, str) and query.strip() == query and query, f"{query_id}: invalid query")
+        language = row.get("language")
+        languages = row.get("languages")
+        require(language in EXPECTED_LANGUAGE_COUNTS, f"{query_id}: invalid language")
+        require(isinstance(languages, list) and languages, f"{query_id}: languages must be non-empty")
+        if language != "mul":
+            require(language in languages, f"{query_id}: primary language missing from languages")
+        require(row.get("difficulty") in {"easy", "medium", "hard"}, f"{query_id}: invalid difficulty")
+        require(isinstance(row.get("query_type"), str) and row["query_type"], f"{query_id}: missing query type")
+        facts = row.get("expected_facts")
+        require(isinstance(facts, list) and facts and all(isinstance(f, str) and f for f in facts), f"{query_id}: invalid expected facts")
+        require(row.get("annotation_version") == "0.1", f"{query_id}: annotation version mismatch")
+        require(row.get("source_snapshot") == EXPECTED_COMMIT, f"{query_id}: source snapshot mismatch")
+
+        relevance = row.get("relevance")
+        require(isinstance(relevance, list) and relevance, f"{query_id}: missing relevance judgments")
+        relevant_ids: set[str] = set()
+        has_direct = False
+        for judgment in relevance:
+            require(isinstance(judgment, dict), f"{query_id}: judgment must be an object")
+            chunk_id = judgment.get("chunk_id")
+            grade = judgment.get("grade")
+            require(chunk_id in corpus, f"{query_id}: unknown relevant chunk {chunk_id!r}")
+            require(chunk_id not in relevant_ids, f"{query_id}: duplicate relevant chunk {chunk_id}")
+            require(type(grade) is int and 1 <= grade <= 3, f"{query_id}: invalid grade")
+            require(isinstance(judgment.get("rationale"), str) and judgment["rationale"], f"{query_id}: missing rationale")
+            relevant_ids.add(chunk_id)
+            has_direct = has_direct or grade == 3
+        require(has_direct, f"{query_id}: requires at least one grade-3 target")
+
+        hard_negatives = row.get("hard_negative_chunk_ids")
+        require(isinstance(hard_negatives, list) and hard_negatives, f"{query_id}: missing hard negatives")
+        require(len(hard_negatives) == len(set(hard_negatives)), f"{query_id}: duplicate hard negative")
+        for chunk_id in hard_negatives:
+            require(chunk_id in corpus, f"{query_id}: unknown hard negative {chunk_id!r}")
+            require(chunk_id not in relevant_ids, f"{query_id}: hard negative is also relevant: {chunk_id}")
+
+    checked_text = "\n".join(corpus_text + [json.dumps(row, ensure_ascii=False) for row in query_rows])
+    for marker in PROHIBITED_MARKERS:
+        require(marker not in checked_text, f"prohibited local/credential marker found: {marker!r}")
+
+    card = (root / "README.md").read_text(encoding="utf-8")
+    for required_fragment in (
+        "config_name: corpus",
+        "split: corpus",
+        "path: data/corpus.jsonl",
+        "config_name: queries",
+        "split: validation",
+        "split: test",
+        EXPECTED_COMMIT,
+        "not a universal code-search benchmark",
+    ):
+        require(required_fragment in card, f"dataset card missing {required_fragment!r}")
+
+    return {
+        "dataset_profile": manifest["dataset_profile"],
+        "corpus_rows": len(corpus_rows),
+        "query_rows": len(query_rows),
+        "split_counts": dict(sorted(EXPECTED_SPLIT_COUNTS.items())),
+        "language_counts": dict(sorted(EXPECTED_LANGUAGE_COUNTS.items())),
+        "source_commit": EXPECTED_COMMIT,
+    }
+
+
+def main() -> int:
+    try:
+        summary = validate()
+    except (OSError, KeyError, TypeError, ValueError, ValidationError) as error:
+        print(f"INVALID: {error}")
+        return 1
+    print(json.dumps({"valid": True, **summary}, ensure_ascii=False, indent=2, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())