cognate_pipeline/tests/e2e/test_expanded_validation.py

"""End-to-end tests for expanded validation branches (CLDF-derived).

Tests all new and expanded TSV files generated from NorthEuraLex,
WOLD, ABVD, and sinotibetan CLDF repositories.
"""

from __future__ import annotations

import csv
import os
from pathlib import Path

import pytest

from cognate_pipeline.cognate.baseline_levenshtein import BaselineLevenshtein
from cognate_pipeline.cognate.candidate_gen import generate_candidates
from cognate_pipeline.cognate.clustering import cluster_links
from cognate_pipeline.config.schema import (
    ClusteringAlgorithm,
    ColumnMapping,
    NormalisationConfig,
    SourceDef,
    SourceFormat,
)
from cognate_pipeline.ingest.csv_ingester import CsvIngester
from cognate_pipeline.normalise.ipa_normaliser import IpaNormaliser
from cognate_pipeline.normalise.models import NormalisedLexeme
from cognate_pipeline.normalise.sound_class import tokenize_ipa

VALIDATION_DIR = Path(r"C:\Users\alvin\ancient-scripts-datasets\data\validation")

# (branch_name, min_entries, min_languages)
EXPANDED_BRANCHES = [
    # Expanded existing families
    ("germanic_expanded", 600, 8),
    ("celtic_expanded", 200, 3),
    ("balto_slavic_expanded", 800, 10),
    ("indo_iranian_expanded", 500, 7),
    ("italic_expanded", 500, 7),
    ("hellenic_expanded", 100, 2),
    ("semitic_expanded", 150, 2),
    ("turkic_expanded", 600, 8),
    ("uralic_expanded", 1500, 20),
    # New families
    ("albanian", 80, 1),
    ("armenian", 80, 1),
    ("dravidian", 300, 4),
    ("kartvelian", 80, 1),
    ("austronesian", 1000, 15),
    ("sino_tibetan", 200, 5),
    ("mongolic", 200, 3),
    ("tungusic", 200, 3),
    ("japonic", 80, 1),
    ("koreanic", 80, 1),
    ("northeast_caucasian", 500, 6),
    ("northwest_caucasian", 150, 2),
    ("eskimo_aleut", 200, 3),
    ("isolates", 300, 4),
    ("afroasiatic_berber", 80, 1),
    ("afroasiatic_chadic", 80, 1),
    ("afroasiatic_cushitic", 150, 2),
    ("niger_congo_bantu", 80, 1),
    ("tai_kadai", 80, 1),
    ("austroasiatic", 150, 2),
    ("mayan", 150, 2),
    ("quechuan", 80, 1),
    ("uto_aztecan", 80, 1),
    ("hmong_mien", 80, 1),
    ("chukotko_kamchatkan", 150, 2),
    ("yukaghir", 150, 2),
    ("saharan", 80, 1),
]


def _make_source(branch_name: str) -> SourceDef:
    return SourceDef(
        name=branch_name,
        path=VALIDATION_DIR / f"{branch_name}.tsv",
        format=SourceFormat.TSV,
        license="CC-BY / Research",
        column_mapping=ColumnMapping(
            language="Language_ID",
            form="Form",
            concept="Parameter_ID",
            ipa="IPA",
            glottocode="Glottocode",
        ),
    )


def _ingest_and_normalise(branch_name: str) -> list[NormalisedLexeme]:
    source = _make_source(branch_name)
    ingester = CsvIngester(source)
    config = NormalisationConfig(
        ipa_backend_priority=["attested"],
        transliteration_passthrough=False,
    )
    normaliser = IpaNormaliser(config)
    return [normaliser.normalise(r) for r in ingester.ingest()]


@pytest.mark.parametrize(
    "branch,min_entries,min_langs",
    EXPANDED_BRANCHES,
    ids=[b[0] for b in EXPANDED_BRANCHES],
)
class TestExpandedBranch:
    """Parametrized tests for all expanded/new validation branches."""

    def test_file_exists(self, branch: str, min_entries: int, min_langs: int):
        """TSV file exists."""
        path = VALIDATION_DIR / f"{branch}.tsv"
        assert path.exists(), f"{branch}.tsv not found"

    def test_ingest_count(self, branch: str, min_entries: int, min_langs: int):
        """Branch produces at least min_entries lexemes."""
        source = _make_source(branch)
        ingester = CsvIngester(source)
        lexemes = list(ingester.ingest())
        assert len(lexemes) >= min_entries, (
            f"{branch}: expected >= {min_entries} lexemes, got {len(lexemes)}"
        )

    def test_language_count(self, branch: str, min_entries: int, min_langs: int):
        """Branch contains at least min_langs distinct languages."""
        source = _make_source(branch)
        ingester = CsvIngester(source)
        lang_ids = set(lex.language_id for lex in ingester.ingest())
        assert len(lang_ids) >= min_langs, (
            f"{branch}: expected >= {min_langs} languages, got {len(lang_ids)}: {lang_ids}"
        )

    def test_no_duplicate_lang_concept(self, branch: str, min_entries: int, min_langs: int):
        """No duplicate (Language_ID, Parameter_ID) within a TSV."""
        path = VALIDATION_DIR / f"{branch}.tsv"
        seen = set()
        dupes = []
        with open(path, encoding="utf-8") as f:
            for row in csv.DictReader(f, delimiter="\t"):
                key = (row["Language_ID"], row["Parameter_ID"])
                if key in seen:
                    dupes.append(key)
                seen.add(key)
        assert len(dupes) == 0, (
            f"{branch}: {len(dupes)} duplicate (lang, concept) pairs: {dupes[:5]}"
        )

    def test_scoring_produces_links(self, branch: str, min_entries: int, min_langs: int):
        """Scoring produces links above 0.3 threshold (multi-lang branches)."""
        if min_langs < 2:
            pytest.skip(f"{branch}: single-language branch, no pairs possible")
        normalised = _ingest_and_normalise(branch)
        pairs = generate_candidates(normalised, family_aware=True)
        if len(pairs) == 0:
            pytest.skip(f"{branch}: no candidate pairs generated")
        scorer = BaselineLevenshtein()
        links = scorer.score_pairs(pairs, threshold=0.3)
        assert len(links) > 0, f"{branch}: no links above 0.3 threshold"


class TestGlobalCoverage:
    """Coverage assertions across all expanded TSV files."""

    def _count_all_entries(self) -> tuple[int, set[str], set[str]]:
        total = 0
        all_langs = set()
        all_concepts = set()
        for f in os.listdir(VALIDATION_DIR):
            if not f.endswith(".tsv"):
                continue
            # Skip metadata files
            if f in ("concepts.tsv", "concepts_expanded.tsv", "languages.tsv",
                      "names_pairs.tsv"):
                continue
            path = VALIDATION_DIR / f
            with open(path, encoding="utf-8") as fh:
                reader = csv.DictReader(fh, delimiter="\t")
                for row in reader:
                    if row.get("IPA", "_") == "_" or row.get("Form", "_") == "_":
                        continue
                    total += 1
                    all_langs.add(row.get("Language_ID", ""))
                    all_concepts.add(row.get("Parameter_ID", ""))
        return total, all_langs, all_concepts

    def test_minimum_200_languages(self):
        """At least 200 unique languages across all validation TSVs."""
        _, all_langs, _ = self._count_all_entries()
        assert len(all_langs) >= 200, (
            f"Expected >= 200 languages, got {len(all_langs)}"
        )

    def test_minimum_100_concepts(self):
        """At least 100 unique concepts across all expanded TSVs."""
        _, _, all_concepts = self._count_all_entries()
        assert len(all_concepts) >= 100, (
            f"Expected >= 100 concepts, got {len(all_concepts)}"
        )

    def test_minimum_15000_entries(self):
        """At least 15,000 total word entries across all TSVs."""
        total, _, _ = self._count_all_entries()
        assert total >= 15000, (
            f"Expected >= 15,000 entries, got {total:,}"
        )

    def test_concepts_expanded_file(self):
        """concepts_expanded.tsv exists and has > 100 concepts."""
        path = VALIDATION_DIR / "concepts_expanded.tsv"
        assert path.exists(), "concepts_expanded.tsv not found"
        with open(path, encoding="utf-8") as f:
            rows = list(csv.DictReader(f, delimiter="\t"))
        assert len(rows) >= 100, (
            f"Expected >= 100 concepts in expanded list, got {len(rows)}"
        )

    def test_languages_tsv_file(self):
        """languages.tsv exists and has > 150 languages."""
        path = VALIDATION_DIR / "languages.tsv"
        assert path.exists(), "languages.tsv not found"
        with open(path, encoding="utf-8") as f:
            rows = list(csv.DictReader(f, delimiter="\t"))
        assert len(rows) >= 150, (
            f"Expected >= 150 languages in master list, got {len(rows)}"
        )

    def test_all_glottocodes_valid_format(self):
        """All Glottocodes match the 8-char format (xxxx1234)."""
        path = VALIDATION_DIR / "languages.tsv"
        with open(path, encoding="utf-8") as f:
            for row in csv.DictReader(f, delimiter="\t"):
                gc = row.get("Glottocode", "")
                if gc:
                    assert len(gc) == 8 and gc[:4].isalpha() and gc[4:].isdigit(), (
                        f"Invalid Glottocode: {gc} for {row.get('Language_ID')}"
                    )


class TestCrossFamilyExpanded:
    """Test that loading multiple branches produces both relationship types."""

    def test_cross_family_pairs(self):
        """Loading two different families produces similarity_only pairs."""
        germanic = _ingest_and_normalise("germanic_expanded")
        italic = _ingest_and_normalise("italic_expanded")
        combined = germanic + italic
        pairs = generate_candidates(combined, family_aware=True)
        inherited = [p for p in pairs if p[2] == "cognate_inherited"]
        similarity = [p for p in pairs if p[2] == "similarity_only"]
        assert len(inherited) > 0, "No cognate_inherited pairs found"
        assert len(similarity) > 0, "No similarity_only pairs found"