""" Invariant tests for cterdam/region dataset. Run from dataset root after cloning: pip install datasets pytest pytest test/test_invariants.py -v Verifies: - name field matches lang selection (name_en/ru/zh) - lang matches region-based language rule - code format and uniqueness - region prefix matches code - all name fields in correct script (en=Latin, zh=CJK, ru=Cyrillic) - no typographic quotes in name_ru - balanced parentheses in all name fields and alt lists - no whitespace anomalies - name_en starts uppercase, not all-caps, no trailing punctuation - no duplicate values across all name fields within a row - alt lists: primary not duplicated, no non-Latin in names_en_alt - links are valid URLs with no duplicates per row - no empty lists (use None instead of []) - parent/children hierarchy integrity """ import re import unicodedata import pytest from collections import Counter from datasets import load_dataset SLAVIC_REGIONS = { 'RU', 'UA', 'BY', 'KZ', 'UZ', 'TJ', 'KG', 'TM', 'GE', 'AZ', 'AM', 'MD', 'LT', 'LV', 'EE', 'RS', 'ME', 'BA', 'HR', 'SI', 'SK', 'CZ', 'PL', 'BG', 'MK', 'FI' } SINOPHONE_REGIONS = { 'CN', 'TW', 'HK', 'MO', 'JP', 'KR', 'KP', 'MN', 'SG', 'VN', 'LA', 'TH', 'MM', 'KH', 'MY', 'BN' } def determine_expected_lang(region_code: str) -> str: if region_code in SINOPHONE_REGIONS: return 'zh' elif region_code in SLAVIC_REGIONS: return 'ru' else: return 'en' @pytest.fixture(scope="session") def dataset(): return load_dataset('cterdam/region', split='train') @pytest.fixture(scope="session") def dataset_index(dataset): return {e['code']: dict(e) for e in dataset} # --------------------------------------------------------------------------- # lang / name consistency # --------------------------------------------------------------------------- def test_lang_values_valid(dataset): """lang field must be one of: en, ru, zh.""" invalid = [(e['code'], e['lang']) for e in dataset if e.get('lang') not in ('en', 'ru', 'zh')] assert invalid == [], f"Invalid lang values: {invalid[:5]}" def test_name_matches_lang_field(dataset): """name field must equal name_en/ru/zh based on lang.""" lang_to_field = {'en': 'name_en', 'ru': 'name_ru', 'zh': 'name_zh'} mismatches = [] for e in dataset: name = e.get('name') lang = e.get('lang') if not name or not lang: continue lang_val = e.get(lang_to_field.get(lang, '')) if name != lang_val: mismatches.append((e['code'], lang, name[:30], (lang_val or '')[:30])) assert mismatches == [], f"Name/lang field mismatches: {mismatches[:5]}" def test_lang_matches_parent_region(dataset): """lang field must match parent region's language rule.""" mismatches = [(e['code'], e.get('region'), e.get('lang'), determine_expected_lang(e.get('region', ''))) for e in dataset if e.get('lang') != determine_expected_lang(e.get('region', ''))] assert mismatches == [], f"Lang mismatches: {mismatches[:5]}" # --------------------------------------------------------------------------- # Script / character rules # --------------------------------------------------------------------------- def _is_cjk(c): cp = ord(c) return ( 0x3400 <= cp <= 0x9FFF or 0xF900 <= cp <= 0xFAFF or 0x20000 <= cp <= 0x2A6DF or 0x2A700 <= cp <= 0x2EBEF or 0x30000 <= cp <= 0x323AF ) def _non_latin_alpha(s): """Return list of non-Latin alphabetic characters in s. Allows: ASCII Latin, Latin Extended (ā ẓ etc.), modifier letters (ʻ ʿ ʾ etc.), superscript/subscript Latin letters (ⁿ etc.). Flags: Arabic, Hebrew, Bengali, Myanmar, Tifinagh, Greek, etc. """ out = [] for c in (s or ''): if not c.isalpha(): continue name = unicodedata.name(c, '') if not ( 'A' <= c <= 'Z' or 'a' <= c <= 'z' or name.startswith('LATIN') or name.startswith('MODIFIER') or name.startswith('COMBINING') or 'SUPERSCRIPT' in name or 'SUBSCRIPT' in name ): out.append(c) return out def test_name_zh_only_cjk_letters(dataset): """All letter chars in name_zh and names_zh_alt must be CJK.""" bad = [] for e in dataset: for v in [e.get('name_zh')] + list(e.get('names_zh_alt') or []): if not v: continue foreign = [c for c in v if c.isalpha() and not _is_cjk(c)] if foreign: bad.append((e['code'], v, foreign)) assert bad == [], f"name_zh/alts with non-CJK letters: {bad[:10]}" def test_name_ru_only_cyrillic_letters(dataset): """All letter chars in name_ru and names_ru_alt must be Cyrillic.""" bad = [] for e in dataset: for v in [e.get('name_ru')] + list(e.get('names_ru_alt') or []): if not v: continue foreign = [c for c in v if c.isalpha() and not ('Ѐ' <= c <= 'ӿ')] if foreign: bad.append((e['code'], v, foreign)) assert bad == [], f"name_ru/alts with non-Cyrillic letters: {bad[:10]}" def test_name_en_only_latin(dataset): """All letter chars in name_en and names_en_alt must be Latin.""" bad = [] for e in dataset: for v in [e.get('name_en')] + list(e.get('names_en_alt') or []): if not v: continue non_latin = _non_latin_alpha(v) if non_latin: bad.append((e['code'], v, non_latin)) assert bad == [], f"name_en/alts with non-Latin letters: {bad[:10]}" # --------------------------------------------------------------------------- # Code / structure # --------------------------------------------------------------------------- def test_code_format(dataset): """code must match ^[A-Z]{2}-[A-Z0-9]{1,6}$.""" bad = [(e['code'],) for e in dataset if not re.match(r'^[A-Z]{2}-[A-Z0-9]{1,6}$', e.get('code', ''))] assert bad == [], f"Malformed codes: {bad[:10]}" def test_code_unique(dataset): """Each code must be unique across the dataset.""" counts = Counter(e['code'] for e in dataset) dups = [(c, n) for c, n in counts.items() if n > 1] assert dups == [], f"Duplicate codes: {dups[:10]}" def test_region_matches_code_prefix(dataset): """region must equal the country prefix of the code (e.g. AD-02 → region=AD).""" bad = [(e['code'], e.get('region')) for e in dataset if e.get('region') != (e.get('code', '') or '')[:2]] assert bad == [], f"region != code prefix: {bad[:10]}" # --------------------------------------------------------------------------- # Name field hygiene # --------------------------------------------------------------------------- def test_no_typographic_quotes_in_ru(dataset): """name_ru must not contain typographic quotes «».""" bad = [(e['code'], e['name_ru']) for e in dataset if e.get('name_ru') and re.search(r'[«»]', e['name_ru'])] assert bad == [], f"name_ru with «» quotes: {bad[:10]}" def test_balanced_parentheses(dataset): """All name fields and alt lists must have balanced ASCII and fullwidth parentheses.""" bad = [] for e in dataset: for f in ('name_en', 'name_ru', 'name_zh'): v = e.get(f) or '' if v.count('(') != v.count(')') or v.count('（') != v.count('）'): bad.append((e['code'], f, v)) for lst in ('names_en_alt', 'names_ru_alt', 'names_zh_alt'): for v in (e.get(lst) or []): if v.count('(') != v.count(')') or v.count('（') != v.count('）'): bad.append((e['code'], lst, v)) assert bad == [], f"Unbalanced parens: {bad[:10]}" def test_no_whitespace_in_names(dataset): """Name fields must not have leading or trailing whitespace.""" bad = [(e['code'], f) for e in dataset for f in ('name_en', 'name_ru', 'name_zh') if e.get(f) and e[f] != e[f].strip()] assert bad == [], f"Leading/trailing whitespace: {bad[:10]}" def test_no_double_spaces_in_names(dataset): """Name fields must not contain consecutive spaces.""" bad = [(e['code'], f) for e in dataset for f in ('name_en', 'name_ru', 'name_zh') if e.get(f) and ' ' in e[f]] assert bad == [], f"Double spaces: {bad[:10]}" def test_no_newlines_in_names(dataset): """Name fields must not contain newline or tab characters.""" bad = [(e['code'], f) for e in dataset for f in ('name_en', 'name_ru', 'name_zh') if any(c in (e.get(f) or '') for c in '\n\t\r')] assert bad == [], f"Newline/tab in names: {bad[:10]}" def test_no_ideographic_space(dataset): """Name fields and alt lists must not contain ideographic space U+3000.""" bad = [] for e in dataset: for f in ('name_en', 'name_ru', 'name_zh'): if '　' in (e.get(f) or ''): bad.append((e['code'], f)) for lst in ('names_en_alt', 'names_ru_alt', 'names_zh_alt'): for v in (e.get(lst) or []): if '　' in v: bad.append((e['code'], lst)) assert bad == [], f"Ideographic space: {bad[:10]}" def test_name_en_starts_uppercase(dataset): """name_en first alphabetic character must be uppercase.""" bad = [(e['code'], e['name_en']) for e in dataset if e.get('name_en') and any(c.isalpha() for c in e['name_en']) and next(c for c in e['name_en'] if c.isalpha()).islower()] assert bad == [], f"name_en starts lowercase: {bad[:10]}" def test_name_en_not_allcaps(dataset): """name_en must not be entirely uppercase.""" bad = [(e['code'], e['name_en']) for e in dataset if e.get('name_en') and e['name_en'] == e['name_en'].upper() and e['name_en'].replace(' ', '').replace('-', '').isalpha()] assert bad == [], f"name_en all-caps: {bad[:10]}" def test_name_en_no_trailing_punctuation(dataset): """name_en must not end with ., ,, ;, :, !, ?.""" bad = [(e['code'], e['name_en']) for e in dataset if e.get('name_en') and e['name_en'][-1] in '.,:;!?'] assert bad == [], f"name_en trailing punctuation: {bad[:10]}" # --------------------------------------------------------------------------- # Alt list rules # --------------------------------------------------------------------------- def test_no_duplicate_names_within_entry(dataset): """No value may appear twice across all name fields (including names_other).""" bad = [] for e in dataset: vals = [] for f in ('name_en', 'name_ru', 'name_zh'): if e.get(f): vals.append(e[f]) for lst in ('names_en_alt', 'names_ru_alt', 'names_zh_alt', 'names_other'): vals += (e.get(lst) or []) seen = set() duped = set() for v in vals: if v in seen: duped.add(v) seen.add(v) if duped: bad.append((e['code'], sorted(duped))) assert bad == [], f"Duplicate values within entry: {bad[:10]}" def test_no_empty_alt_lists(dataset): """Alt list fields must be None when empty, not [].""" bad = [(e['code'], lst) for e in dataset for lst in ('names_en_alt', 'names_ru_alt', 'names_zh_alt', 'names_other') if e.get(lst) == []] assert bad == [], f"Empty list instead of None: {bad[:10]}" # --------------------------------------------------------------------------- # Links # --------------------------------------------------------------------------- def test_links_are_urls(dataset): """Every link must start with http:// or https://.""" bad = [(e['code'], l) for e in dataset for l in (e.get('links') or []) if not l.startswith(('http://', 'https://'))] assert bad == [], f"Bad links: {bad[:10]}" def test_no_duplicate_links(dataset): """No duplicate URLs within a row's link list.""" bad = [(e['code'],) for e in dataset if len(e.get('links') or []) != len(set(e.get('links') or []))] assert bad == [], f"Duplicate links: {bad[:10]}" # --------------------------------------------------------------------------- # Parent / children hierarchy # --------------------------------------------------------------------------- def test_parent_is_valid_code(dataset, dataset_index): """parent, when set, must be a code present in the dataset.""" bad = [(e['code'], e['parent']) for e in dataset if e.get('parent') and e['parent'] not in dataset_index] assert bad == [], f"Invalid parent codes: {bad[:10]}" def test_children_are_valid_codes(dataset, dataset_index): """All children codes must be present in the dataset.""" bad = [(e['code'], c) for e in dataset for c in (e.get('children') or []) if c not in dataset_index] assert bad == [], f"Invalid children codes: {bad[:10]}" def test_no_self_referential_parent(dataset): """parent must not equal code.""" bad = [(e['code'],) for e in dataset if e.get('parent') == e.get('code')] assert bad == [], f"Self-referential parent: {bad[:10]}" def test_parent_in_children(dataset, dataset_index): """If A.parent = B, then B.children must contain A.""" bad = [(e['code'], e['parent']) for e in dataset if e.get('parent') and e['parent'] in dataset_index and e['code'] not in (dataset_index[e['parent']].get('children') or [])] assert bad == [], f"A.parent=B but B.children missing A: {bad[:10]}" def test_children_have_back_reference(dataset, dataset_index): """If B.children contains A, then A.parent must equal B.""" bad = [(e['code'], c, (dataset_index[c].get('parent') if c in dataset_index else None)) for e in dataset for c in (e.get('children') or []) if c in dataset_index and dataset_index[c].get('parent') != e['code']] assert bad == [], f"B.children contains A but A.parent != B: {bad[:10]}" def test_parent_region_matches(dataset, dataset_index): """parent's region must match this entry's region.""" bad = [(e['code'], e['region'], e['parent'], dataset_index[e['parent']]['region']) for e in dataset if e.get('parent') and e['parent'] in dataset_index and dataset_index[e['parent']]['region'] != e['region']] assert bad == [], f"parent.region != entry.region: {bad[:10]}"