| """Validate a DATA LAB source manifest without external dependencies.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import re |
| from datetime import datetime |
| from pathlib import Path, PurePosixPath |
| from typing import Any |
| from urllib.parse import urlparse |
|
|
| SHA256_RE = re.compile(r"^[a-f0-9]{64}$") |
| SOURCE_ID_RE = re.compile(r"^[a-z0-9][a-z0-9._-]*$") |
| DECISIONS = {"proposed", "approved", "rejected", "withdrawn"} |
| PERMISSIONS = {"pending", "approved", "rejected"} |
| REDISTRIBUTION = {"allowed", "restricted", "prohibited", "unknown"} |
| PRIVACY_STATES = {"pending", "passed", "failed"} |
|
|
|
|
| def _is_https(value: Any) -> bool: |
| if not isinstance(value, str): |
| return False |
| parsed = urlparse(value) |
| return parsed.scheme == "https" and bool(parsed.netloc) |
|
|
|
|
| def _is_utc_timestamp(value: Any) -> bool: |
| if not isinstance(value, str) or not value.endswith("Z"): |
| return False |
| try: |
| datetime.fromisoformat(value.removesuffix("Z") + "+00:00") |
| except ValueError: |
| return False |
| return True |
|
|
|
|
| def _is_safe_relative_path(value: Any) -> bool: |
| if not isinstance(value, str) or not value.strip() or "\\" in value: |
| return False |
| path = PurePosixPath(value) |
| return not path.is_absolute() and ".." not in path.parts and "." not in path.parts |
|
|
|
|
| def validate_manifest(data: Any) -> list[str]: |
| """Return human-readable validation errors; an empty list means valid.""" |
| errors: list[str] = [] |
| if not isinstance(data, dict): |
| return ["manifest root must be a JSON object"] |
|
|
| if data.get("schema_version") != "1.0": |
| errors.append("schema_version must be '1.0'") |
| if not isinstance(data.get("dataset_id"), str) or not data["dataset_id"].strip(): |
| errors.append("dataset_id must be a non-empty string") |
|
|
| decision = data.get("decision") |
| if not isinstance(decision, dict): |
| errors.append("decision must be an object") |
| decision = {} |
| status = decision.get("status") |
| if status not in DECISIONS: |
| errors.append(f"decision.status must be one of {sorted(DECISIONS)}") |
| if not isinstance(decision.get("notes"), list) or not all( |
| isinstance(note, str) for note in decision.get("notes", []) |
| ): |
| errors.append("decision.notes must be an array of strings") |
| if status == "approved": |
| if not isinstance(decision.get("reviewed_by"), str) or not decision["reviewed_by"].strip(): |
| errors.append("approved manifest requires decision.reviewed_by") |
| if not _is_utc_timestamp(decision.get("reviewed_at")): |
| errors.append("approved manifest requires a UTC decision.reviewed_at ending in Z") |
|
|
| sources = data.get("sources") |
| if not isinstance(sources, list): |
| errors.append("sources must be an array") |
| return errors |
|
|
| seen_ids: set[str] = set() |
| for index, source in enumerate(sources): |
| prefix = f"sources[{index}]" |
| if not isinstance(source, dict): |
| errors.append(f"{prefix} must be an object") |
| continue |
|
|
| source_id = source.get("source_id") |
| if not isinstance(source_id, str) or not SOURCE_ID_RE.fullmatch(source_id): |
| errors.append(f"{prefix}.source_id must use lowercase letters, digits, dot, underscore, or hyphen") |
| elif source_id in seen_ids: |
| errors.append(f"{prefix}.source_id is duplicated: {source_id}") |
| else: |
| seen_ids.add(source_id) |
|
|
| for field in ("title", "publisher", "version"): |
| if not isinstance(source.get(field), str) or not source[field].strip(): |
| errors.append(f"{prefix}.{field} must be a non-empty string") |
| if not _is_https(source.get("canonical_url")): |
| errors.append(f"{prefix}.canonical_url must be an HTTPS URL") |
| if not _is_utc_timestamp(source.get("retrieved_at")): |
| errors.append(f"{prefix}.retrieved_at must be a UTC timestamp ending in Z") |
| if not _is_safe_relative_path(source.get("content_path")): |
| errors.append(f"{prefix}.content_path must be a safe POSIX-style relative path") |
| if not isinstance(source.get("sha256"), str) or not SHA256_RE.fullmatch(source["sha256"]): |
| errors.append(f"{prefix}.sha256 must be a lowercase 64-character SHA-256 digest") |
|
|
| licence = source.get("license") |
| if not isinstance(licence, dict): |
| errors.append(f"{prefix}.license must be an object") |
| licence = {} |
| if not isinstance(licence.get("identifier"), str) or not licence["identifier"].strip(): |
| errors.append(f"{prefix}.license.identifier must be non-empty") |
| if not _is_https(licence.get("url")): |
| errors.append(f"{prefix}.license.url must be an HTTPS URL") |
| if licence.get("permission_status") not in PERMISSIONS: |
| errors.append(f"{prefix}.license.permission_status is invalid") |
| if licence.get("redistribution") not in REDISTRIBUTION: |
| errors.append(f"{prefix}.license.redistribution is invalid") |
|
|
| privacy = source.get("privacy") |
| if not isinstance(privacy, dict): |
| errors.append(f"{prefix}.privacy must be an object") |
| privacy = {} |
| if privacy.get("review_status") not in PRIVACY_STATES: |
| errors.append(f"{prefix}.privacy.review_status is invalid") |
| if privacy.get("contains_personal_data") not in (True, False, None): |
| errors.append(f"{prefix}.privacy.contains_personal_data must be true, false, or null") |
| if not isinstance(privacy.get("notes"), list) or not all( |
| isinstance(note, str) for note in privacy.get("notes", []) |
| ): |
| errors.append(f"{prefix}.privacy.notes must be an array of strings") |
|
|
| use = source.get("use") |
| if not isinstance(use, dict): |
| errors.append(f"{prefix}.use must be an object") |
| use = {} |
| if not isinstance(use.get("purpose"), str) or not use["purpose"].strip(): |
| errors.append(f"{prefix}.use.purpose must be non-empty") |
| if not isinstance(use.get("allowed"), bool): |
| errors.append(f"{prefix}.use.allowed must be a boolean") |
| if not isinstance(use.get("restrictions"), list) or not all( |
| isinstance(item, str) for item in use.get("restrictions", []) |
| ): |
| errors.append(f"{prefix}.use.restrictions must be an array of strings") |
|
|
| if status == "approved": |
| if licence.get("permission_status") != "approved": |
| errors.append(f"{prefix} is not approved by the licensing review") |
| if privacy.get("review_status") != "passed": |
| errors.append(f"{prefix} has not passed privacy review") |
| if not isinstance(privacy.get("consent_or_lawful_basis"), str) or not privacy[ |
| "consent_or_lawful_basis" |
| ].strip(): |
| errors.append(f"{prefix} lacks consent or another documented lawful basis") |
| if use.get("allowed") is not True: |
| errors.append(f"{prefix}.use.allowed must be true for an approved manifest") |
|
|
| return errors |
|
|
|
|
| def load_manifest(path: Path) -> dict[str, Any]: |
| data = json.loads(path.read_text(encoding="utf-8")) |
| if not isinstance(data, dict): |
| raise ValueError("manifest root must be an object") |
| return data |
|
|
|
|
| def main() -> int: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("manifest", type=Path) |
| args = parser.parse_args() |
|
|
| try: |
| data = load_manifest(args.manifest) |
| except (OSError, json.JSONDecodeError, ValueError) as exc: |
| print(f"INVALID: {exc}") |
| return 2 |
|
|
| errors = validate_manifest(data) |
| if errors: |
| print("INVALID") |
| for error in errors: |
| print(f"- {error}") |
| return 1 |
|
|
| print(f"VALID: {data['dataset_id']} ({data['decision']['status']})") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
