scripts/ingest_oracc.py

#!/usr/bin/env python3
"""Ingest Sumerian and Akkadian lexicon data from ORACC Neo glossaries.

ORACC (Open Richly Annotated Cuneiform Corpus) provides structured JSON
glossaries with citation forms, glosses, and POS tags. This is the richest
freely available source for Sumerian and Akkadian vocabulary.

URLs:
    Sumerian: https://build-oracc.museum.upenn.edu/neo/downloads/gloss-sux.json
    Akkadian: https://build-oracc.museum.upenn.edu/neo/downloads/gloss-akk.json

License: CC BY-SA (stated on ePSD2/ORACC metadata)

Iron Rule: All words come from HTTP API responses. No hardcoded data.

Usage:
    python scripts/ingest_oracc.py [--language sux|akk] [--dry-run]
"""

from __future__ import annotations

import argparse
import io
import json
import logging
import sys
import time
import unicodedata
import urllib.request
import urllib.error
from pathlib import Path

# Fix Windows encoding
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 transliteration_maps import transliterate  # noqa: E402
from cognate_pipeline.normalise.sound_class import ipa_to_sound_class  # noqa: E402

logger = logging.getLogger(__name__)

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

USER_AGENT = "PhaiPhon/1.0 (ancient-scripts-datasets)"

ORACC_CONFIGS = {
    "sux": {
        "name": "Sumerian",
        "url": "https://build-oracc.museum.upenn.edu/neo/downloads/gloss-sux.json",
    },
    "akk": {
        "name": "Akkadian",
        "url": "https://build-oracc.museum.upenn.edu/neo/downloads/gloss-akk.json",
    },
}


def download_glossary(url: str) -> dict:
    """Download an ORACC Neo glossary JSON file."""
    logger.info("Downloading %s ...", url)
    req = urllib.request.Request(url, headers={"User-Agent": USER_AGENT})

    for attempt in range(3):
        try:
            with urllib.request.urlopen(req, timeout=120) as resp:
                raw = resp.read()
                logger.info("Downloaded %d bytes", len(raw))
                return json.loads(raw.decode("utf-8"))
        except (urllib.error.URLError, urllib.error.HTTPError, OSError) as exc:
            if attempt < 2:
                logger.warning("Attempt %d failed: %s, retrying...", attempt + 1, exc)
                time.sleep(5 * (attempt + 1))
            else:
                logger.error("FAILED after 3 retries: %s", exc)
                raise


def extract_headwords(glossary: dict) -> list[dict]:
    """Extract headwords from an ORACC glossary JSON.

    Each entry has: cf (citation form), gw (guide word/gloss), pos, forms.
    """
    entries_raw = glossary.get("entries", [])
    results = []

    for entry in entries_raw:
        cf = entry.get("cf", "").strip()
        if not cf:
            continue

        # NFC normalize
        cf = unicodedata.normalize("NFC", cf)

        # Skip if too long or too short
        if len(cf) > 50 or len(cf) < 2:
            continue

        # Skip all-caps ASCII (Sumerograms in Akkadian glossary)
        if cf.isascii() and cf.isupper() and len(cf) > 3:
            continue

        gw = entry.get("gw", "").strip()
        pos = entry.get("pos", "").strip()

        results.append({
            "cf": cf,
            "gw": gw,
            "pos": pos,
        })

    return results


def load_existing_words(tsv_path: Path) -> set[str]:
    """Load existing Word column values."""
    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 ingest_language(iso: str, config: dict, dry_run: bool = False) -> dict:
    """Ingest a single language from ORACC Neo glossary."""
    tsv_path = LEXICON_DIR / f"{iso}.tsv"
    existing = load_existing_words(tsv_path)
    logger.info("%s (%s): %d existing entries", iso, config["name"], len(existing))

    # Download glossary
    glossary = download_glossary(config["url"])

    # Save raw glossary
    if not dry_run:
        RAW_DIR.mkdir(parents=True, exist_ok=True)
        raw_path = RAW_DIR / f"oracc_glossary_{iso}.json"
        with open(raw_path, "w", encoding="utf-8") as f:
            json.dump(glossary, f, ensure_ascii=False)

    # Extract headwords
    headwords = extract_headwords(glossary)
    logger.info("%s: %d headwords extracted from ORACC", iso, len(headwords))

    # Process entries
    new_entries = []
    audit_trail = []
    skipped = 0

    for hw in headwords:
        word = hw["cf"]
        if word in existing:
            skipped += 1
            continue

        # Transliterate
        try:
            ipa = transliterate(word, iso)
        except Exception:
            ipa = word

        if not ipa:
            ipa = word

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

        new_entries.append({
            "word": word,
            "ipa": ipa,
            "sca": sca,
        })
        existing.add(word)  # Prevent intra-batch dupes

        audit_trail.append({
            "word": word,
            "ipa": ipa,
            "gloss": hw["gw"],
            "pos": hw["pos"],
            "source": "oracc_neo",
        })

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

    if dry_run:
        return {
            "iso": iso,
            "name": config["name"],
            "existing": len(existing) - len(new_entries),
            "oracc_total": len(headwords),
            "new": len(new_entries),
            "total": len(existing),
            "skipped": skipped,
        }

    # Write to TSV
    if new_entries:
        if not tsv_path.exists():
            with open(tsv_path, "w", encoding="utf-8") as f:
                f.write("Word\tIPA\tSCA\tSource\tConcept_ID\tCognate_Set_ID\n")

        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']}\toracc_neo\t-\t-\n")

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

    return {
        "iso": iso,
        "name": config["name"],
        "existing": len(existing) - len(new_entries),
        "oracc_total": len(headwords),
        "new": len(new_entries),
        "total": len(existing),
        "skipped": skipped,
    }


def main():
    parser = argparse.ArgumentParser(description="Ingest from ORACC Neo glossaries")
    parser.add_argument("--language", "-l", choices=["sux", "akk"],
                        help="Specific ISO code (default: both)")
    parser.add_argument("--dry-run", action="store_true")
    args = parser.parse_args()

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

    if args.language:
        configs = {args.language: ORACC_CONFIGS[args.language]}
    else:
        configs = ORACC_CONFIGS

    results = []
    for iso, config in configs.items():
        result = ingest_language(iso, config, dry_run=args.dry_run)
        results.append(result)

    print(f"\n{'DRY RUN: ' if args.dry_run else ''}ORACC Neo Ingestion:")
    print("=" * 70)
    for r in results:
        print(f"  {r['iso']:8s} {r['name']:15s} ORACC={r['oracc_total']:>6d}, "
              f"existing={r['existing']:>5d}, new={r['new']:>5d}, total={r['total']:>5d}")
    total_new = sum(r["new"] for r in results)
    print(f"\n  Total new entries: {total_new}")
    print("=" * 70)


if __name__ == "__main__":
    main()