#!/usr/bin/env python3 """Ingest Eblaite lexical data from the ORACC DCCLT/Ebla corpus. Source: https://oracc.museum.upenn.edu/json/dcclt-ebla.zip License: CC0 (public domain) Language code: akk-x-earakk (Early Archaic Akkadian = Eblaite, ~2400 BCE) Academic editors: Marco Bonechi (Rome), Niek Veldhuis (Berkeley) Iron Rule: All data comes from the downloaded ZIP. No hardcoded word forms. Data sources inside the ZIP: - dcclt/ebla/gloss-akk-x-earakk.json : 45 lemmatized glossary entries - dcclt/ebla/corpusjson/P*.json : Per-text corpus files with tokens Filtering rules: - Only syllabic (lowercase Assyriology transliteration) forms — no pure logograms - No broken/unreadable forms (containing 'x' as damage indicator) - No pure number strings - No mixed forms where ANY hyphen-delimited syllable is uppercase (= Sumerogram) - Minimum 2 characters after stripping hyphens and subscripts Usage: python scripts/ingest_dcclt_ebla.py [--dry-run] """ from __future__ import annotations import argparse import io import json import logging import sys import unicodedata import zipfile 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" ZIP_PATH = RAW_DIR / "dcclt-ebla.zip" ISO = "xeb" SOURCE = "dcclt-ebla" # Subscript digit characters to strip (they indicate sign variant readings) SUBSCRIPTS = str.maketrans("", "", "₀₁₂₃₄₅₆₇₈₉") # --------------------------------------------------------------------------- # Form filtering helpers # --------------------------------------------------------------------------- def strip_subscripts(s: str) -> str: """Remove subscript digit characters (₀₁₂₃₄₅₆₇₈₉) from a string.""" return s.translate(SUBSCRIPTS) def stripped_len(form: str) -> int: """Return the length of a form after stripping hyphens and subscripts.""" return len(strip_subscripts(form).replace("-", "")) def has_damage(form: str) -> bool: """Return True if any syllable is exactly 'x' (damage/lacuna indicator).""" for part in form.split("-"): if strip_subscripts(part).lower() == "x": return True return False def is_pure_number(form: str) -> bool: """Return True if the form is purely numeric (line numbers, counts).""" return form.replace("-", "").isdigit() def is_syllable_uppercase(syllable: str) -> bool: """Return True if a syllable contains uppercase ASCII letters (= logogram).""" clean = strip_subscripts(syllable) return any(c.isupper() for c in clean) def is_pure_syllabic(form: str) -> bool: """Return True if ALL syllables are lowercase (syllabic readings only). Rejects forms where any hyphen-delimited part is a Sumerogram (uppercase). Also rejects parenthesized complex signs like idₓ(NI), which embed logograms. """ if is_pure_number(form) or has_damage(form): return False # Reject forms with parenthesized sign names (e.g. idₓ(NI)) if "(" in form or ")" in form: return False # Reject forms with pipe-enclosed complex signs (|GUD×DIŠ|) if "|" in form: return False # Reject forms with determinative markers ({d}, {x}) if "{" in form: return False # Reject forms with degree sign (°) — marks uncertain/dubious readings in ORACC if "\u00b0" in form: return False parts = form.split("-") if not parts: return False return all(not is_syllable_uppercase(p) for p in parts if p) def keep_form(form: str) -> bool: """Combined filter: True if the form should be retained.""" if not form: return False form_nfc = unicodedata.normalize("NFC", form) return ( is_pure_syllabic(form_nfc) and stripped_len(form_nfc) >= 2 ) # --------------------------------------------------------------------------- # CDL walker (ORACC JSON corpus format) # --------------------------------------------------------------------------- def walk_cdl(node: object, tokens: list) -> None: """Recursively walk an ORACC CDL node tree, collecting token dicts.""" if isinstance(node, dict): if node.get("node") == "l": f = node.get("f", {}) if f.get("lang") == "akk-x-earakk": tokens.append({ "form": f.get("form", ""), "norm": f.get("norm", ""), "cf": f.get("cf", ""), "gw": f.get("gw", ""), }) for child in node.get("cdl", []): walk_cdl(child, tokens) elif isinstance(node, list): for item in node: walk_cdl(item, tokens) # --------------------------------------------------------------------------- # Main extraction # --------------------------------------------------------------------------- def extract_glossary_entries(gloss: dict) -> list[dict]: """Extract all entries from the glossary JSON. Returns list of dicts with: form, cf, gw, pos Only syllabic forms are kept (logograms like 'A', 'MUŠ' are filtered). """ entries = gloss.get("entries", []) results = [] for entry in entries: cf = entry.get("cf", "").strip() gw = entry.get("gw", "").strip() pos = entry.get("pos", "").strip() for frm in entry.get("forms", []): n = frm.get("n", "").strip() if n and keep_form(n): results.append({ "form": unicodedata.normalize("NFC", n), "cf": cf, "gw": gw, "pos": pos, }) return results def extract_corpus_tokens(z: zipfile.ZipFile) -> list[dict]: """Walk all corpus JSON files and collect Eblaite tokens.""" corpus_files = [n for n in z.namelist() if "corpusjson/P" in n] tokens = [] for nm in corpus_files: raw = z.read(nm) if not raw.strip(): continue try: doc = json.loads(raw) except json.JSONDecodeError as exc: logger.warning("Skipping %s: JSON error: %s", nm, exc) continue walk_cdl(doc.get("cdl", []), tokens) return tokens def build_glossary_lookup(gloss: dict) -> dict[str, str]: """Build form-string -> guide-word lookup from glossary entries.""" lookup = {} for entry in gloss.get("entries", []): gw = entry.get("gw", "").strip() for frm in entry.get("forms", []): n = frm.get("n", "").strip() if n: lookup[unicodedata.normalize("NFC", n)] = gw return lookup def convert_to_ipa(form: str) -> str: """Convert an Eblaite syllabic form to approximate IPA. Steps: 1. NFC normalize 2. Apply EBLAITE_MAP (inherits AKKADIAN_MAP) via transliterate() 3. Strip subscript digits from the result 4. Remove hyphens (syllable boundaries are not phonemic in the output) """ form_nfc = unicodedata.normalize("NFC", form) ipa_with_hyphens = transliterate(form_nfc, ISO) # Strip subscript digits that survive the map (sign variant markers) ipa_no_subscripts = strip_subscripts(ipa_with_hyphens) # Remove hyphens — syllable boundaries are orthographic, not phonemic ipa = ipa_no_subscripts.replace("-", "") return ipa def ingest(dry_run: bool = False) -> dict: """Run the full ingestion pipeline.""" if not ZIP_PATH.exists(): raise FileNotFoundError(f"ZIP not found: {ZIP_PATH}") tsv_path = LEXICON_DIR / f"{ISO}.tsv" audit_path = AUDIT_TRAIL_DIR / f"dcclt_ingest_{ISO}.jsonl" # Load existing words to avoid duplicates existing: set[str] = set() if tsv_path.exists(): with open(tsv_path, "r", encoding="utf-8") as f: for line in f: if not line.startswith("Word\t"): word = line.split("\t")[0] if word: existing.add(word) logger.info("Existing %s entries: %d", ISO, len(existing)) with zipfile.ZipFile(ZIP_PATH) as z: # Step 1: Parse glossary with z.open("dcclt/ebla/gloss-akk-x-earakk.json") as f: gloss = json.load(f) gloss_entries = extract_glossary_entries(gloss) logger.info("Glossary entries (syllabic only): %d", len(gloss_entries)) # Build gloss lookup form_to_gw = build_glossary_lookup(gloss) # Step 2: Parse corpus tokens all_corpus_tokens = extract_corpus_tokens(z) logger.info("Total corpus tokens (all Eblaite): %d", len(all_corpus_tokens)) # Step 3: Collect all unique syllabic corpus forms corpus_forms_raw = [t["form"] for t in all_corpus_tokens] total_corpus_forms = len(corpus_forms_raw) unique_corpus_forms_raw = set(corpus_forms_raw) logger.info("Unique raw corpus forms: %d", len(unique_corpus_forms_raw)) # Filter to syllabic only syllabic_corpus_forms = { unicodedata.normalize("NFC", f) for f in unique_corpus_forms_raw if keep_form(f) } logger.info("Unique syllabic corpus forms (after filtering): %d", len(syllabic_corpus_forms)) # Step 4: Merge glossary forms + corpus forms # Glossary forms come first (they have gloss metadata) all_entries = [] # From glossary for e in gloss_entries: form = e["form"] if form not in existing: gw = e["gw"] concept_id = gw if gw else "-" ipa = convert_to_ipa(form) try: sca = ipa_to_sound_class(ipa) except Exception: sca = "" all_entries.append({ "word": form, "ipa": ipa, "sca": sca, "source": SOURCE, "concept_id": concept_id, "cognate_set_id": "-", "gw": gw, }) existing.add(form) # From corpus (forms not already in glossary) for form in sorted(syllabic_corpus_forms): if form in existing: continue gw = form_to_gw.get(form, "") concept_id = gw if gw else "-" ipa = convert_to_ipa(form) try: sca = ipa_to_sound_class(ipa) except Exception: sca = "" all_entries.append({ "word": form, "ipa": ipa, "sca": sca, "source": SOURCE, "concept_id": concept_id, "cognate_set_id": "-", "gw": gw, }) existing.add(form) logger.info("New entries to write: %d", len(all_entries)) # Step 5: Identity rate calculation n_identity = sum(1 for e in all_entries if e["ipa"] == e["word"]) identity_pct = n_identity / len(all_entries) * 100 if all_entries else 0 stats = { "iso": ISO, "total_corpus_tokens": total_corpus_forms, "unique_corpus_forms_raw": len(unique_corpus_forms_raw), "unique_syllabic": len(syllabic_corpus_forms), "glossary_entries_syllabic": len(gloss_entries), "new_entries": len(all_entries), "identity_count": n_identity, "identity_pct": round(identity_pct, 1), } if dry_run: stats["status"] = "dry_run" return stats # Step 6: Write TSV LEXICON_DIR.mkdir(parents=True, exist_ok=True) 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") if all_entries: with open(tsv_path, "a", encoding="utf-8") as f: for e in all_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" ) # Step 7: Write audit trail AUDIT_TRAIL_DIR.mkdir(parents=True, exist_ok=True) with open(audit_path, "w", encoding="utf-8") as f: for e in all_entries: record = { "word": e["word"], "ipa": e["ipa"], "source": e["source"], "concept_id": e["concept_id"], } f.write(json.dumps(record, ensure_ascii=False) + "\n") stats["status"] = "written" logger.info("TSV written: %s", tsv_path) logger.info("Audit trail written: %s", audit_path) return stats def main(): parser = argparse.ArgumentParser(description="Ingest Eblaite data from DCCLT/Ebla ORACC corpus") parser.add_argument("--dry-run", action="store_true", help="Show what would be written without writing files") args = parser.parse_args() logging.basicConfig( level=logging.INFO, format="%(asctime)s %(levelname)s: %(message)s", datefmt="%H:%M:%S", ) stats = ingest(dry_run=args.dry_run) print() print("=" * 70) print(f"DCCLT/Ebla Ingestion [{'DRY RUN' if args.dry_run else 'LIVE'}]") print("=" * 70) print(f" ISO code: {stats['iso']}") print(f" Total corpus tokens: {stats['total_corpus_tokens']}") print(f" Unique raw forms: {stats['unique_corpus_forms_raw']}") print(f" Unique syllabic forms: {stats['unique_syllabic']}") print(f" Glossary entries (syl): {stats['glossary_entries_syllabic']}") print(f" New entries written: {stats['new_entries']}") print(f" Identity rate: {stats['identity_pct']:.1f}% " f"({stats['identity_count']}/{stats['new_entries']} forms unchanged)") print(f" Status: {stats['status']}") print("=" * 70) if __name__ == "__main__": main()