validate_iceland.py

#!/usr/bin/env python3
"""Validate the bilingual fictional technology-ethics microdataset.

SPDX-License-Identifier: MIT
"""

from __future__ import annotations

import argparse
import json
import re
from collections import Counter, defaultdict
from pathlib import Path
from typing import Any, Iterable


ROOT = Path(__file__).resolve().parent
DEFAULT_DATA = ROOT / "data" / "train.jsonl"

EXPECTED_PAIR_DOMAINS = {
    "ice-tech-ethics-01": "emergency-energy-allocation",
    "ice-tech-ethics-02": "public-safety-surveillance",
    "ice-tech-ethics-03": "algorithmic-resource-governance",
    "ice-tech-ethics-04": "sustainable-computing",
    "ice-tech-ethics-05": "autonomous-access-control",
    "ice-tech-ethics-06": "emotion-recognition",
    "ice-tech-ethics-07": "healthcare-ai",
    "ice-tech-ethics-08": "autonomous-logistics",
    "ice-tech-ethics-09": "generative-ai-memorials",
    "ice-tech-ethics-10": "workplace-algorithms",
    "ice-tech-ethics-11": "biometric-access",
    "ice-tech-ethics-12": "conversational-ai-spiritual-care",
}
EXPECTED_PAIR_MOTIFS = {
    "ice-tech-ethics-01": "geothermal-valley",
    "ice-tech-ethics-02": "glacier-lagoon",
    "ice-tech-ethics-03": "basalt-bay",
    "ice-tech-ethics-04": "winter-greenhouse",
    "ice-tech-ethics-05": "mossy-lava-field",
    "ice-tech-ethics-06": "black-sand-coast",
    "ice-tech-ethics-07": "stormy-fjord",
    "ice-tech-ethics-08": "snowy-highlands",
    "ice-tech-ethics-09": "volcanic-island",
    "ice-tech-ethics-10": "winter-harbor",
    "ice-tech-ethics-11": "lava-ridge-shelter",
    "ice-tech-ethics-12": "glacier-edge-shelter",
}
ALLOWED_CONCEPTS = {
    "care-for-vulnerable",
    "common-good",
    "creation-care",
    "hospitality",
    "human-dignity",
    "humility",
    "justice",
    "love-of-neighbor",
    "non-coercion",
    "remembrance",
    "sabbath-rest",
    "stewardship",
    "truthfulness",
}
PLURALISM_COMMITMENTS = {
    "multiple-worldviews-welcome",
    "no-group-consensus-claim",
    "no-required-assent",
}
REVIEW_FOCUS = {
    "bilingual-equivalence",
    "cultural-non-attribution",
    "technology-ethics",
    "theological-pluralism",
}
RECORD_KEYS = {
    "audience",
    "christian_ethics_concepts",
    "creation",
    "discussion_question",
    "fictionality",
    "id",
    "intended_use",
    "landscape_motif",
    "language",
    "license",
    "pair_id",
    "perspectives",
    "pluralism",
    "scenario_title",
    "setting",
    "status",
    "technology_domain",
    "topic_tags",
    "translation_of",
    "version",
}
ID_PATTERN = re.compile(r"^ice-tech-ethics-(?:0[1-9]|1[0-2])-(?:pt-br|en)$")
PAIR_PATTERN = re.compile(r"^ice-tech-ethics-(?:0[1-9]|1[0-2])$")
SLUG_PATTERN = re.compile(r"^[a-z0-9]+(?:-[a-z0-9]+)*$")
PROHIBITED_PHRASES = {
    "a visão cristã é",
    "aceitar jesus",
    "all christians",
    "christians believe",
    "christians must",
    "converter-se ao cristianismo",
    "cristãos acreditam",
    "cristãos devem",
    "deve acreditar",
    "icelanders believe",
    "islandeses acreditam",
    "must believe",
    "only correct answer",
    "the christian view is",
    "todos os cristãos",
    "única resposta correta",
}


def _read_jsonl(path: Path) -> tuple[list[dict[str, Any]], list[str]]:
    records: list[dict[str, Any]] = []
    errors: list[str] = []
    try:
        lines = path.read_text(encoding="utf-8").splitlines()
    except (OSError, UnicodeError) as exc:
        return [], [f"cannot read {path}: {exc}"]
    for line_number, raw_line in enumerate(lines, 1):
        if not raw_line.strip():
            errors.append(f"line {line_number}: blank JSONL line")
            continue
        try:
            value = json.loads(raw_line, parse_constant=_reject_constant)
        except (json.JSONDecodeError, ValueError) as exc:
            errors.append(f"line {line_number}: invalid JSON: {exc}")
            continue
        if not isinstance(value, dict):
            errors.append(f"line {line_number}: record must be a JSON object")
            continue
        records.append(value)
    return records, errors


def _reject_constant(token: str) -> Any:
    raise ValueError(f"non-standard JSON constant {token!r}")


def _nonempty_text(value: Any, *, minimum: int = 1) -> bool:
    return isinstance(value, str) and len(value.strip()) >= minimum


def _exact_keys(value: Any, expected: set[str]) -> bool:
    return isinstance(value, dict) and set(value) == expected


def _record_text(record: dict[str, Any]) -> str:
    return json.dumps(record, ensure_ascii=False, sort_keys=True).casefold()


def _duplicate_values(values: Iterable[str]) -> set[str]:
    return {value for value, count in Counter(values).items() if count > 1}


def validate_records(records: list[dict[str, Any]]) -> list[str]:
    """Return human-readable validation errors for already parsed records."""

    errors: list[str] = []
    if len(records) != 24:
        errors.append(f"dataset must contain exactly 24 records; found {len(records)}")

    record_ids = [record.get("id") for record in records if isinstance(record.get("id"), str)]
    for duplicate in sorted(_duplicate_values(record_ids)):
        errors.append(f"duplicate record id {duplicate!r}")

    pairs: dict[str, list[dict[str, Any]]] = defaultdict(list)
    for index, record in enumerate(records, 1):
        label = str(record.get("id") or f"line-{index}")
        if set(record) != RECORD_KEYS:
            missing = sorted(RECORD_KEYS - set(record))
            unexpected = sorted(set(record) - RECORD_KEYS)
            errors.append(
                f"{label}: record keys mismatch; missing={missing}, unexpected={unexpected}"
            )

        record_id = record.get("id")
        pair_id = record.get("pair_id")
        language = record.get("language")
        if not isinstance(record_id, str) or not ID_PATTERN.fullmatch(record_id):
            errors.append(f"{label}: invalid id")
        if not isinstance(pair_id, str) or not PAIR_PATTERN.fullmatch(pair_id):
            errors.append(f"{label}: invalid pair_id")
        else:
            pairs[pair_id].append(record)
        if language not in {"pt-BR", "en"}:
            errors.append(f"{label}: language must be pt-BR or en")
        elif isinstance(pair_id, str):
            expected_id = f"{pair_id}-{'pt-br' if language == 'pt-BR' else 'en'}"
            if record_id != expected_id:
                errors.append(f"{label}: id must be {expected_id!r}")

        if record.get("version") != "1.0.0":
            errors.append(f"{label}: version must be '1.0.0'")
        if record.get("status") != "ai-generated-draft-human-review-required":
            errors.append(f"{label}: invalid review status")
        if record.get("license") != "CC-BY-4.0":
            errors.append(f"{label}: license must be CC-BY-4.0")
        if record.get("intended_use") != "facilitated-ethical-discussion":
            errors.append(f"{label}: invalid intended_use")
        if record.get("audience") != ["adult-learners", "educators"]:
            errors.append(f"{label}: audience must be adult-learners and educators")

        expected_domain = EXPECTED_PAIR_DOMAINS.get(pair_id)
        if record.get("technology_domain") != expected_domain:
            errors.append(f"{label}: unexpected technology_domain")
        expected_motif = EXPECTED_PAIR_MOTIFS.get(pair_id)
        if record.get("landscape_motif") != expected_motif:
            errors.append(f"{label}: unexpected landscape_motif")

        if not _nonempty_text(record.get("scenario_title"), minimum=8):
            errors.append(f"{label}: scenario_title is too short")
        if not _nonempty_text(record.get("setting"), minimum=100):
            errors.append(f"{label}: setting must be substantive")
        question = record.get("discussion_question")
        if not _nonempty_text(question, minimum=40) or not question.strip().endswith("?"):
            errors.append(f"{label}: discussion_question must be a substantive question")

        tags = record.get("topic_tags")
        if (
            not isinstance(tags, list)
            or not 2 <= len(tags) <= 5
            or len(tags) != len(set(tags))
            or not all(isinstance(tag, str) and SLUG_PATTERN.fullmatch(tag) for tag in tags)
        ):
            errors.append(f"{label}: topic_tags must contain 2-5 unique slugs")

        concepts = record.get("christian_ethics_concepts")
        if (
            not isinstance(concepts, list)
            or not 2 <= len(concepts) <= 4
            or len(concepts) != len(set(concepts))
            or not set(concepts) <= ALLOWED_CONCEPTS
        ):
            errors.append(f"{label}: invalid christian_ethics_concepts")

        fictionality = record.get("fictionality")
        if not _exact_keys(
            fictionality,
            {"claims_real_icelandic_or_christian_practices", "is_fictional", "notice"},
        ):
            errors.append(f"{label}: invalid fictionality object")
        else:
            if fictionality["is_fictional"] is not True:
                errors.append(f"{label}: scenario must be marked fictional")
            if fictionality["claims_real_icelandic_or_christian_practices"] is not False:
                errors.append(f"{label}: record must disclaim real-practice claims")
            notice = fictionality["notice"]
            expected_terms = ("ficcional", "não descreve") if language == "pt-BR" else ("fictional", "does not describe")
            if not _nonempty_text(notice, minimum=80) or not all(term in notice.casefold() for term in expected_terms):
                errors.append(f"{label}: fictionality notice is incomplete for {language}")

        pluralism = record.get("pluralism")
        if not _exact_keys(pluralism, {"commitments", "required", "safeguard"}):
            errors.append(f"{label}: invalid pluralism object")
        else:
            if pluralism["required"] is not True:
                errors.append(f"{label}: pluralism safeguard must be required")
            commitments = pluralism["commitments"]
            if not isinstance(commitments, list) or set(commitments) != PLURALISM_COMMITMENTS or len(commitments) != 3:
                errors.append(f"{label}: pluralism commitments are incomplete")
            if not _nonempty_text(pluralism["safeguard"], minimum=120):
                errors.append(f"{label}: pluralism safeguard must be substantive")

        creation = record.get("creation")
        if not _exact_keys(creation, {"human_review_status", "method", "review_focus"}):
            errors.append(f"{label}: invalid creation object")
        else:
            if creation["method"] != "ai-generated-original-draft":
                errors.append(f"{label}: creation method must disclose AI generation")
            if creation["human_review_status"] != "required-before-curated-release-or-use":
                errors.append(f"{label}: human review requirement is missing")
            focus = creation["review_focus"]
            if not isinstance(focus, list) or set(focus) != REVIEW_FOCUS or len(focus) != 4:
                errors.append(f"{label}: review_focus is incomplete")

        perspectives = record.get("perspectives")
        if not isinstance(perspectives, list) or len(perspectives) != 2:
            errors.append(f"{label}: exactly two perspectives are required")
        else:
            perspective_ids: list[str] = []
            arguments: list[str] = []
            for perspective_index, perspective in enumerate(perspectives):
                pointer = f"{label}: perspective[{perspective_index}]"
                if not _exact_keys(perspective, {"argument", "id", "questions", "title"}):
                    errors.append(f"{pointer}: invalid object")
                    continue
                perspective_ids.append(perspective["id"])
                arguments.append(perspective["argument"])
                if not _nonempty_text(perspective["title"], minimum=8):
                    errors.append(f"{pointer}: title is too short")
                if not _nonempty_text(perspective["argument"], minimum=120):
                    errors.append(f"{pointer}: argument must be substantive")
                questions = perspective["questions"]
                if (
                    not isinstance(questions, list)
                    or len(questions) != 2
                    or len(set(questions)) != 2
                    or not all(_nonempty_text(item, minimum=20) and item.strip().endswith("?") for item in questions)
                ):
                    errors.append(f"{pointer}: exactly two substantive questions are required")
            if set(perspective_ids) != {"a", "b"} or len(perspective_ids) != 2:
                errors.append(f"{label}: perspective ids must be a and b")
            if len(arguments) == 2 and arguments[0].strip() == arguments[1].strip():
                errors.append(f"{label}: perspectives must present distinct arguments")

        text = _record_text(record)
        for phrase in sorted(PROHIBITED_PHRASES):
            if phrase in text:
                errors.append(f"{label}: prohibited universalizing or proselytizing phrase {phrase!r}")

    expected_pairs = set(EXPECTED_PAIR_DOMAINS)
    if set(pairs) != expected_pairs:
        errors.append(
            f"pair set mismatch; missing={sorted(expected_pairs - set(pairs))}, "
            f"unexpected={sorted(set(pairs) - expected_pairs)}"
        )

    stable_fields = (
        "audience",
        "christian_ethics_concepts",
        "creation",
        "intended_use",
        "landscape_motif",
        "license",
        "status",
        "technology_domain",
        "topic_tags",
        "version",
    )
    for pair_id in sorted(expected_pairs):
        pair_records = pairs.get(pair_id, [])
        languages = [record.get("language") for record in pair_records]
        if len(pair_records) != 2 or Counter(languages) != Counter({"pt-BR": 1, "en": 1}):
            errors.append(f"{pair_id}: pair must contain exactly one pt-BR and one en record")
            continue
        by_language = {record["language"]: record for record in pair_records}
        source = by_language["pt-BR"]
        translated = by_language["en"]
        if source.get("translation_of") is not None:
            errors.append(f"{source['id']}: pt-BR root must have null translation_of")
        if translated.get("translation_of") != source.get("id"):
            errors.append(f"{translated['id']}: en record must translate directly from pt-BR root")
        for field in stable_fields:
            if source.get(field) != translated.get(field):
                errors.append(f"{pair_id}: bilingual invariant {field!r} differs")
        if [item.get("id") for item in source.get("perspectives", [])] != [
            item.get("id") for item in translated.get("perspectives", [])
        ]:
            errors.append(f"{pair_id}: perspective order differs across languages")

    return errors


def validate_repository(data_path: Path = DEFAULT_DATA) -> list[str]:
    """Validate data plus the minimum Hugging Face release files."""

    records, errors = _read_jsonl(data_path)
    errors.extend(validate_records(records))

    readme = ROOT / "README.md"
    license_file = ROOT / "LICENSE"
    try:
        readme_text = readme.read_text(encoding="utf-8")
    except (OSError, UnicodeError) as exc:
        errors.append(f"cannot read {readme}: {exc}")
    else:
        required_card_fragments = (
            "---\nlanguage:\n- pt\n- en\n",
            "license: cc-by-4.0",
            "path: data/train.jsonl",
            "AI-generated",
            "human review",
        )
        for fragment in required_card_fragments:
            if fragment not in readme_text:
                errors.append(f"README.md is missing required fragment {fragment!r}")

    try:
        license_text = license_file.read_text(encoding="utf-8")
    except (OSError, UnicodeError) as exc:
        errors.append(f"cannot read {license_file}: {exc}")
    else:
        if "Creative Commons Attribution 4.0 International" not in license_text:
            errors.append("LICENSE does not identify CC BY 4.0")
        if "https://creativecommons.org/licenses/by/4.0/legalcode" not in license_text:
            errors.append("LICENSE does not link to the official legal code")

    return errors


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--data", type=Path, default=DEFAULT_DATA)
    args = parser.parse_args()
    errors = validate_repository(args.data)
    if errors:
        for error in errors:
            print(f"ERROR: {error}")
        return 1
    print("valid: 24 records in 12 pt-BR/en pairs")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())