scripts/expand_wiktionary_categories.py

#!/usr/bin/env python3
"""Expand lexicons for 7 languages by paginating through ALL Wiktionary category members.

This script uses the MediaWiki API with cmcontinue pagination to fetch every
lemma in each language's Wiktionary category, extracts glosses from individual
pages, deduplicates against existing TSV entries, and appends new entries.

Languages handled:
  - Proto-Indo-European (ine-pro) — Category:Proto-Indo-European_lemmas (ns=118)
  - Ugaritic (uga)               — Category:Ugaritic_lemmas
  - Old Persian (peo)            — Category:Old_Persian_lemmas
  - Avestan (ave)                — Category:Avestan_lemmas
  - Proto-Dravidian (dra-pro)    — Category:Proto-Dravidian_lemmas (ns=118)
  - Proto-Semitic (sem-pro)      — Category:Proto-Semitic_lemmas (ns=118)
  - Proto-Kartvelian (ccs-pro)   — Category:Proto-Kartvelian_lemmas (ns=118)

Data source: Wiktionary MediaWiki API (en.wiktionary.org)
Iron Rule: NO hardcoded lexical data. Every entry traced to API responses.

Usage:
    python scripts/expand_wiktionary_categories.py [--language ISO] [--dry-run]
"""

from __future__ import annotations

import argparse
import json
import logging
import os
import re
import sys
import time
import unicodedata
from pathlib import Path

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
from transliteration_maps import transliterate  # noqa: E402

# Also import the enhanced wiktionary parser with category pagination
sys.path.insert(0, str(ROOT / "scripts" / "parsers"))
from parse_wiktionary import (  # noqa: E402
    fetch_category_members,
    fetch_page_html,
    extract_gloss_from_html,
    extract_romanization_from_html,
)

logger = logging.getLogger(__name__)

# ---------------------------------------------------------------------------
# Configuration
# ---------------------------------------------------------------------------

LEXICON_DIR = ROOT / "data" / "training" / "lexicons"
AUDIT_TRAIL_DIR = ROOT / "data" / "training" / "audit_trails"

LANGUAGE_CONFIGS = {
    "ine-pro": {
        "name": "Proto-Indo-European",
        "category": "Category:Proto-Indo-European_lemmas",
        "namespace": 118,  # Reconstruction namespace
        "wikt_lang_name": "Proto-Indo-European",
        "iso_for_translit": "ine",
        "tsv_filename": "ine-pro.tsv",
        "source_label": "wiktionary_cat",
    },
    "uga": {
        "name": "Ugaritic",
        "category": "Category:Ugaritic_lemmas",
        "namespace": 0,
        "wikt_lang_name": "Ugaritic",
        "iso_for_translit": "uga",
        "tsv_filename": "uga.tsv",
        "source_label": "wiktionary_cat",
    },
    "peo": {
        "name": "Old Persian",
        "category": "Category:Old_Persian_lemmas",
        "namespace": 0,
        "wikt_lang_name": "Old Persian",
        "iso_for_translit": "peo",
        "tsv_filename": "peo.tsv",
        "source_label": "wiktionary_cat",
        # Also check Reconstruction namespace
        "extra_namespace": 118,
        "extra_category": "Category:Old_Persian_lemmas",
    },
    "ave": {
        "name": "Avestan",
        "category": "Category:Avestan_lemmas",
        "namespace": 0,
        "wikt_lang_name": "Avestan",
        "iso_for_translit": "ave",
        "tsv_filename": "ave.tsv",
        "source_label": "wiktionary_cat",
    },
    "dra-pro": {
        "name": "Proto-Dravidian",
        "category": "Category:Proto-Dravidian_lemmas",
        "namespace": 118,
        "wikt_lang_name": "Proto-Dravidian",
        "iso_for_translit": "dra",
        "tsv_filename": "dra-pro.tsv",
        "source_label": "wiktionary_cat",
    },
    "sem-pro": {
        "name": "Proto-Semitic",
        "category": "Category:Proto-Semitic_lemmas",
        "namespace": 118,
        "wikt_lang_name": "Proto-Semitic",
        "iso_for_translit": "sem",
        "tsv_filename": "sem-pro.tsv",
        "source_label": "wiktionary_cat",
    },
    "ccs-pro": {
        "name": "Proto-Kartvelian",
        "category": "Category:Proto-Kartvelian_lemmas",
        "namespace": 118,
        "wikt_lang_name": "Proto-Kartvelian",
        "iso_for_translit": "ccs",
        "tsv_filename": "ccs-pro.tsv",
        "source_label": "wiktionary_cat",
    },
    # --- New languages added for Phase B expansion ---
    "xlw": {
        "name": "Luwian",
        "category": "Category:Luwian_lemmas",
        "namespace": 0,
        "wikt_lang_name": "Luwian",
        "iso_for_translit": "xlw",  # dedicated Luwian transliteration map
        "tsv_filename": "xlw.tsv",
        "source_label": "wiktionary_cat",
        "use_word_for_ipa": True,  # Don't trust romanization field
    },
    "xhu": {
        "name": "Hurrian",
        "category": "Category:Hurrian_lemmas",
        "namespace": 0,
        "wikt_lang_name": "Hurrian",
        "iso_for_translit": "xhu",  # dedicated Hurrian transliteration map
        "tsv_filename": "xhu.tsv",
        "source_label": "wiktionary_cat",
        "use_word_for_ipa": True,
    },
    "ett": {
        "name": "Etruscan",
        "category": "Category:Etruscan_lemmas",
        "namespace": 0,
        "wikt_lang_name": "Etruscan",
        "iso_for_translit": "ett",  # dedicated Etruscan transliteration map
        "tsv_filename": "ett.tsv",
        "source_label": "wiktionary_cat",
        "use_word_for_ipa": True,
    },
    "txb": {
        "name": "Tocharian B",
        "category": "Category:Tocharian_B_lemmas",
        "namespace": 0,
        "wikt_lang_name": "Tocharian B",
        "iso_for_translit": "txb",  # Tocharian transliteration
        "tsv_filename": "txb.tsv",
        "source_label": "wiktionary_cat",
        "use_word_for_ipa": True,
    },
    "xto": {
        "name": "Tocharian A",
        "category": "Category:Tocharian_A_lemmas",
        "namespace": 0,
        "wikt_lang_name": "Tocharian A",
        "iso_for_translit": "xto",  # Tocharian transliteration
        "tsv_filename": "xto.tsv",
        "source_label": "wiktionary_cat",
        "use_word_for_ipa": True,
    },
    # --- Tier 1 new languages (Phase 3) ---
    "non": {
        "name": "Old Norse",
        "category": "Category:Old_Norse_lemmas",
        "namespace": 0,
        "wikt_lang_name": "Old Norse",
        "iso_for_translit": "non",
        "tsv_filename": "non.tsv",
        "source_label": "wiktionary_cat",
    },
    "got": {
        "name": "Gothic",
        "category": "Category:Gothic_lemmas",
        "namespace": 0,
        "wikt_lang_name": "Gothic",
        "iso_for_translit": "got",
        "tsv_filename": "got.tsv",
        "source_label": "wiktionary_cat",
    },
    "chu": {
        "name": "Old Church Slavonic",
        "category": "Category:Old_Church_Slavonic_lemmas",
        "namespace": 0,
        "wikt_lang_name": "Old Church Slavonic",
        "iso_for_translit": "chu",
        "tsv_filename": "chu.tsv",
        "source_label": "wiktionary_cat",
        "use_word_for_ipa": True,
    },
    "gmy": {
        "name": "Mycenaean Greek",
        "category": "Category:Mycenaean_Greek_lemmas",
        "namespace": 0,
        "wikt_lang_name": "Mycenaean Greek",
        "iso_for_translit": "gmy",
        "tsv_filename": "gmy.tsv",
        "source_label": "wiktionary_cat",
        "use_word_for_ipa": True,
    },
    "akk": {
        "name": "Akkadian",
        "category": "Category:Akkadian_lemmas",
        "namespace": 0,
        "wikt_lang_name": "Akkadian",
        "iso_for_translit": "akk",
        "tsv_filename": "akk.tsv",
        "source_label": "wiktionary_cat",
    },
    "sux": {
        "name": "Sumerian",
        "category": "Category:Sumerian_lemmas",
        "namespace": 0,
        "wikt_lang_name": "Sumerian",
        "iso_for_translit": "sux",
        "tsv_filename": "sux.tsv",
        "source_label": "wiktionary_cat",
        "use_word_for_ipa": True,
    },
}


# ---------------------------------------------------------------------------
# Pre-processing (reused from extract_wiktionary_lexicons.py)
# ---------------------------------------------------------------------------

def preprocess_kartvelian(word: str) -> str:
    """Convert Klimov (1998) Wiktionary notation to transliteration_maps input."""
    word = unicodedata.normalize("NFC", word)
    replacements = [
        ("č̣", "č'"), ("c̣", "c'"), ("ṭ", "t'"), ("ḳ", "k'"),
        ("p̣", "p'"), ("q̣", "q'"), ("ʓ̌", "ǯ"), ("ʓ₁", "ʒ"),
        ("ʓ", "ʒ"), ("s₁", "s"), ("c₁", "c"), ("z₁", "z"),
        ("//", ""),
    ]
    for old, new in replacements:
        word = word.replace(old, new)
    return word


def preprocess_semitic(word: str) -> str:
    """Convert Kogan (2012) Wiktionary notation to transliteration_maps input."""
    word = unicodedata.normalize("NFC", word)
    replacements = [
        ("ṣ́", "ṣ"), ("ṣ̂", "ṣ"), ("ŝ", "ś"), ("ṯ̣", "ṱ"), ("ā̆", "ā"),
    ]
    for old, new in replacements:
        word = word.replace(old, new)
    return word


def custom_transliterate(word: str, iso: str) -> str:
    """Apply language-specific preprocessing before transliteration."""
    if iso == "ccs":
        word = preprocess_kartvelian(word)
    elif iso == "sem":
        word = preprocess_semitic(word)
        # Handle extra Semitic chars not in standard map
        result = transliterate(word, iso)
        extra = {"ḫ": "x", "V": "a", "ṣ́": "sˤ", "ŝ": "ɬ", "ṱ": "θˤ"}
        return "".join(extra.get(c, c) for c in result)

    return transliterate(word, iso)


# ---------------------------------------------------------------------------
# Core logic
# ---------------------------------------------------------------------------

def load_existing_words(tsv_path: Path) -> set[str]:
    """Load existing Word column values from a TSV (case-sensitive)."""
    existing = set()
    if tsv_path.exists():
        with open(tsv_path, "r", encoding="utf-8") as f:
            for line in f:
                if line.startswith("Word\t"):
                    continue
                word = line.split("\t")[0]
                existing.add(word)
    return existing


def clean_word(word: str, namespace: int) -> str:
    """Clean a word extracted from Wiktionary title."""
    # For Reconstruction namespace, strip prefix
    if namespace == 118:
        parts = word.split("/")
        word = parts[-1].strip() if len(parts) >= 2 else word

    # Remove reconstruction asterisk
    word = re.sub(r"^\*+", "", word)
    # Remove trailing/leading hyphens (keep internal ones)
    word = word.strip()
    # Normalize unicode
    word = unicodedata.normalize("NFC", word)
    return word


def is_valid_word(word: str) -> bool:
    """Check if a word looks like a valid lexical entry."""
    if not word or len(word) > 50:
        return False
    if " " in word and len(word) > 25:
        return False
    # Skip if all uppercase ASCII (likely English leak)
    if word.isascii() and word.isupper() and len(word) > 3:
        return False
    return True


def expand_language(
    iso: str,
    config: dict,
    dry_run: bool = False,
) -> dict:
    """Expand a single language's lexicon from Wiktionary category.

    Returns a summary dict with counts.
    """
    tsv_path = LEXICON_DIR / config["tsv_filename"]
    existing_words = load_existing_words(tsv_path)
    logger.info("%s: loaded %d existing entries from %s",
                iso, len(existing_words), tsv_path)

    # Fetch all category members
    all_members = fetch_category_members(
        config["category"],
        namespace=config["namespace"],
    )

    # Also fetch from extra namespace if configured
    if "extra_namespace" in config:
        extra = fetch_category_members(
            config.get("extra_category", config["category"]),
            namespace=config["extra_namespace"],
        )
        all_members.extend(extra)
        logger.info("%s: total members including extra namespace: %d",
                    iso, len(all_members))

    # Process each member
    new_entries: list[dict] = []
    audit_trail: list[dict] = []
    skipped = 0

    for i, m in enumerate(all_members):
        title = m.get("title", "")
        ns = m.get("ns", 0)
        word = clean_word(title, ns)

        if not is_valid_word(word):
            skipped += 1
            continue

        # Check if already in existing TSV
        if word in existing_words:
            skipped += 1
            continue

        # Fetch gloss from individual page
        gloss = ""
        romanization = ""
        try:
            html = fetch_page_html(title)
            if html:
                gloss = extract_gloss_from_html(html, config["wikt_lang_name"])
                romanization = extract_romanization_from_html(
                    html, config["wikt_lang_name"]
                )
        except Exception as exc:
            logger.warning("Failed to fetch '%s': %s", title, exc)

        # Use romanization if found, otherwise the word itself
        translit_input = romanization if romanization else word

        # Apply transliteration -> IPA
        try:
            ipa = custom_transliterate(translit_input, config["iso_for_translit"])
        except Exception:
            ipa = translit_input

        if not ipa:
            ipa = translit_input

        # Generate SCA
        try:
            sca = ipa_to_sound_class(ipa)
        except Exception:
            sca = ""

        # Determine concept ID from gloss
        if gloss:
            concept = gloss.split(",")[0].split(";")[0].strip()
            concept_id = concept.replace(" ", "_").lower()[:50]
        else:
            concept_id = "-"

        entry = {
            "word": word,
            "ipa": ipa,
            "sca": sca,
            "source": config["source_label"],
            "concept_id": concept_id,
            "cognate_set_id": "-",
        }
        new_entries.append(entry)
        existing_words.add(word)  # Prevent intra-batch dupes

        # Audit trail
        audit_trail.append({
            "word": word,
            "page_title": title,
            "namespace": ns,
            "gloss": gloss,
            "romanization": romanization,
            "ipa": ipa,
        })

        # Rate limiting
        if (i + 1) % 50 == 0:
            logger.info("  %s: processed %d/%d members (%d new)",
                        iso, i + 1, len(all_members), len(new_entries))
            time.sleep(3)
        else:
            time.sleep(1.5)

    logger.info("%s: %d new entries, %d skipped (existing/invalid)",
                iso, len(new_entries), skipped)

    if dry_run:
        logger.info("%s: DRY RUN — not writing to disk", iso)
        return {
            "iso": iso,
            "existing": len(existing_words) - len(new_entries),
            "new": len(new_entries),
            "total": len(existing_words),
            "skipped": skipped,
        }

    # Append new entries to TSV
    if new_entries:
        with open(tsv_path, "a", encoding="utf-8") as f:
            for e in new_entries:
                f.write(
                    f"{e['word']}\t{e['ipa']}\t{e['sca']}\t"
                    f"{e['source']}\t{e['concept_id']}\t{e['cognate_set_id']}\n"
                )

    # Write audit trail
    AUDIT_TRAIL_DIR.mkdir(parents=True, exist_ok=True)
    audit_path = AUDIT_TRAIL_DIR / f"wiktionary_expansion_{iso}.jsonl"
    with open(audit_path, "w", encoding="utf-8") as f:
        for record in audit_trail:
            f.write(json.dumps(record, ensure_ascii=False) + "\n")

    logger.info("%s: wrote %d new entries to %s", iso, len(new_entries), tsv_path)
    logger.info("%s: audit trail at %s", iso, audit_path)

    return {
        "iso": iso,
        "existing": len(existing_words) - len(new_entries),
        "new": len(new_entries),
        "total": len(existing_words),
        "skipped": skipped,
    }


# ---------------------------------------------------------------------------
# Main
# ---------------------------------------------------------------------------

def main():
    parser = argparse.ArgumentParser(
        description="Expand lexicons from Wiktionary categories"
    )
    parser.add_argument(
        "--language", "-l",
        help="ISO code of specific language to expand (default: all 7)",
    )
    parser.add_argument(
        "--dry-run", action="store_true",
        help="Fetch data but don't write to TSV files",
    )
    args = parser.parse_args()

    logging.basicConfig(
        level=logging.INFO,
        format="%(asctime)s %(levelname)s: %(message)s",
        datefmt="%H:%M:%S",
    )

    if args.language:
        if args.language not in LANGUAGE_CONFIGS:
            print(f"Unknown language: {args.language}", file=sys.stderr)
            print(f"Valid options: {', '.join(LANGUAGE_CONFIGS)}", file=sys.stderr)
            sys.exit(1)
        languages = {args.language: LANGUAGE_CONFIGS[args.language]}
    else:
        languages = LANGUAGE_CONFIGS

    print("=" * 60)
    print("Wiktionary Category Expansion")
    print(f"Languages: {', '.join(languages)}")
    print(f"Dry run: {args.dry_run}")
    print("=" * 60)

    results = []
    for iso, config in languages.items():
        print(f"\n--- {config['name']} ({iso}) ---")
        try:
            result = expand_language(iso, config, dry_run=args.dry_run)
            results.append(result)
        except Exception as exc:
            logger.error("FAILED for %s: %s", iso, exc, exc_info=True)
            results.append({"iso": iso, "error": str(exc)})

    # Summary
    print("\n" + "=" * 60)
    print("SUMMARY")
    print("=" * 60)
    for r in results:
        if "error" in r:
            print(f"  {r['iso']:10s} FAILED: {r['error']}")
        else:
            print(f"  {r['iso']:10s} existing={r['existing']}, "
                  f"new={r['new']}, total={r['total']}")
    print("=" * 60)


if __name__ == "__main__":
    main()