scripts/extract_abvd_cognates_v2.py

#!/usr/bin/env python3
"""Extract ABVD cognate pairs from the authoritative CognateTable.

Reads sources/abvd/cldf/cognates.csv (291K expert entries) instead of the
forms.csv Cognacy column. Fixes: doubt flag leakage, multi-set truncation.

Output: staging/cognate_pairs/abvd_cognate_pairs.tsv (14-column schema)
"""

from __future__ import annotations

import csv
import io
import sys
from collections import defaultdict
from itertools import combinations
from pathlib import Path

sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8")
sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding="utf-8")

ROOT = Path(__file__).resolve().parent.parent
sys.path.insert(0, str(ROOT / "cognate_pipeline" / "src"))
sys.path.insert(0, str(ROOT / "scripts"))

from cognate_pipeline.normalise.sound_class import ipa_to_sound_class  # noqa: E402

SOURCES_DIR = ROOT / "sources" / "abvd" / "cldf"
STAGING_DIR = ROOT / "staging" / "cognate_pairs"
STAGING_DIR.mkdir(parents=True, exist_ok=True)

HEADER = (
    "Lang_A\tWord_A\tIPA_A\tLang_B\tWord_B\tIPA_B\tConcept_ID\t"
    "Relationship\tScore\tSource\tRelation_Detail\tDonor_Language\t"
    "Confidence\tSource_Record_ID\n"
)


def sca_similarity(ipa_a: str, ipa_b: str) -> float:
    """Compute normalised Levenshtein similarity on SCA strings."""
    try:
        sca_a = ipa_to_sound_class(ipa_a)
        sca_b = ipa_to_sound_class(ipa_b)
    except Exception:
        return 0.0
    if not sca_a or not sca_b:
        return 0.0
    # Levenshtein distance
    m, n = len(sca_a), len(sca_b)
    if m == 0 or n == 0:
        return 0.0
    dp = list(range(n + 1))
    for i in range(1, m + 1):
        prev = dp[0]
        dp[0] = i
        for j in range(1, n + 1):
            temp = dp[j]
            if sca_a[i - 1] == sca_b[j - 1]:
                dp[j] = prev
            else:
                dp[j] = 1 + min(prev, dp[j], dp[j - 1])
            prev = temp
    dist = dp[n]
    return round(1.0 - dist / max(m, n), 4)


def form_to_pseudo_ipa(form: str) -> str:
    """Convert ABVD orthographic form to pseudo-IPA (lowercase, strip parens)."""
    # ABVD forms are orthographic — no true IPA. Basic normalisation only.
    result = form.lower().strip()
    result = result.replace("(", "").replace(")", "")
    return result


def main():
    print("=" * 60)
    print("ABVD Cognate Extraction v2")
    print("=" * 60)

    # Step 1: Read languages.csv → Language_ID → ISO code
    lang_path = SOURCES_DIR / "languages.csv"
    lang_iso = {}
    with open(lang_path, "r", encoding="utf-8") as f:
        reader = csv.DictReader(f)
        for row in reader:
            lid = row["ID"]
            iso = row.get("ISO639P3code", "").strip()
            if iso:
                lang_iso[lid] = iso
    print(f"  Languages with ISO codes: {len(lang_iso)}")

    # Step 2: Read forms.csv → Form_ID → {language, word, ipa, concept, loan}
    forms_path = SOURCES_DIR / "forms.csv"
    forms = {}
    with open(forms_path, "r", encoding="utf-8") as f:
        reader = csv.DictReader(f)
        for row in reader:
            fid = row["ID"]
            lid = str(row["Language_ID"])
            iso = lang_iso.get(lid, "")
            if not iso:
                continue
            form = row.get("Form", row.get("Value", "")).strip()
            if not form:
                continue
            param_id = row.get("Parameter_ID", "").strip()
            # Extract concept from Parameter_ID (e.g., "1_hand" → "hand")
            concept = param_id.split("_", 1)[1] if "_" in param_id else param_id
            ipa = form_to_pseudo_ipa(form)
            loan = row.get("Loan", "").strip()
            forms[fid] = {
                "iso": iso,
                "word": form,
                "ipa": ipa,
                "concept": concept,
                "loan": loan,
            }
    print(f"  Forms loaded: {len(forms)}")

    # Step 3: Read cognates.csv → group by Cognateset_ID
    cognates_path = SOURCES_DIR / "cognates.csv"
    cogsets: dict[str, list[dict]] = defaultdict(list)
    doubt_count = 0
    total_cognate_rows = 0
    with open(cognates_path, "r", encoding="utf-8") as f:
        reader = csv.DictReader(f)
        for row in reader:
            total_cognate_rows += 1
            form_id = row["Form_ID"]
            cogset_id = row["Cognateset_ID"]
            doubt = row.get("Doubt", "false").strip().lower() == "true"
            if doubt:
                doubt_count += 1
            form_data = forms.get(form_id)
            if form_data is None:
                continue
            cogsets[cogset_id].append({
                **form_data,
                "doubt": doubt,
                "cogset_id": cogset_id,
                "form_id": form_id,
            })
    print(f"  Cognate rows read: {total_cognate_rows}")
    print(f"  Doubtful entries: {doubt_count}")
    print(f"  Cognate sets: {len(cogsets)}")

    # Step 4: Generate cross-language pairs within each cognate set
    output_path = STAGING_DIR / "abvd_cognate_pairs.tsv"
    pair_count = 0
    loan_flagged_count = 0
    with open(output_path, "w", encoding="utf-8") as out:
        out.write(HEADER)
        for cogset_id, members in cogsets.items():
            # Deduplicate members by (iso, word) — ABVD maps multiple
            # Language_IDs to the same ISO code with identical forms
            seen_members: set[tuple[str, str]] = set()
            deduped: list[dict] = []
            for m in members:
                key = (m["iso"], m["word"])
                if key not in seen_members:
                    seen_members.add(key)
                    deduped.append(m)
            members = deduped
            # Filter to cross-language pairs only
            for a, b in combinations(members, 2):
                if a["iso"] == b["iso"]:
                    continue
                score = sca_similarity(a["ipa"], b["ipa"])
                confidence = "doubtful" if (a["doubt"] or b["doubt"]) else "certain"
                # Check if either form is flagged as a loan
                a_loan = a.get("loan", "")
                b_loan = b.get("loan", "")
                if (a_loan and a_loan.lower() != "false") or (b_loan and b_loan.lower() != "false"):
                    relation_detail = "loan_flagged"
                    loan_flagged_count += 1
                else:
                    relation_detail = "inherited"
                out.write(
                    f"{a['iso']}\t{a['word']}\t{a['ipa']}\t"
                    f"{b['iso']}\t{b['word']}\t{b['ipa']}\t"
                    f"{a['concept']}\texpert_cognate\t{score}\tabvd\t"
                    f"{relation_detail}\t-\t{confidence}\t{cogset_id}\n"
                )
                pair_count += 1
                if pair_count % 500000 == 0:
                    print(f"    ... {pair_count:,} pairs written")

    print(f"\n  Total pairs: {pair_count:,}")
    print(f"  Loan-flagged pairs: {loan_flagged_count:,}")
    print(f"  Output: {output_path}")
    print("=" * 60)


if __name__ == "__main__":
    main()