"""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())