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