Update app.py

app.py

@@ -1,195 +1,176 @@
-import json, re, os
-from typing import Dict
-import gradio as gr
-
-# ===== Archivos del léxico (generados en Colab) =====
-MINI_JSON = "lexicon_minimax.json"   # ES -> code (Minimax)
-KOMI_JSON = "lexicon_komin.json"     # ES -> code (Kōmín)
-MAST_JSON = "lexicon_master.json"    # opcional: [{'lemma_es','lemma_en','minimax','komin'}, ...]
-
-# ===== (Opcional) Fallback EN<->ES con Argos si falta master =====
-USE_ARGOS = False
-try:
-    import argostranslate.translate as argos_tr
-    USE_ARGOS = True
-except Exception:
-    pass
+# =========================================
+# COLAB · Construcción masiva de léxico ES/EN desde OMW (WordNet)
+# y asignación de códigos para Minimax/Kōmín
+# =========================================
+!pip -q install wn wordfreq spacy
+
+import wn, json, csv, re, os, sys, math, random
+from collections import OrderedDict, defaultdict
+from typing import List, Dict, Tuple
+
+# ---- Parámetros editables ----
+SEED = 4242
+USE_SPACY = True           # Lematizar con spaCy si está leíble
+USE_ARGOS = False          # Completar EN faltante vía Argos (requiere red y modelos)
+MAXLEN_MINI = 3            # máx. longitud de código Minimax
+MAXLEN_CJK  = 2            # máx. longitud de código Kōmín
+LIMIT_ES    = None         # None = todos los lemas spa de OMW; o un entero para recortar
+# ------------------------------
+
+# (opcional) spaCy
+if USE_SPACY:
+    import spacy, spacy.cli
+    try:
+        nlp_es = spacy.load("es_core_news_sm")
+    except Exception:
+        try:
+            spacy.cli.download("es_core_news_sm"); nlp_es = spacy.load("es_core_news_sm")
+        except Exception:
+            nlp_es = None
+    try:
+        nlp_en = spacy.load("en_core_web_sm")
+    except Exception:
+        try:
+            spacy.cli.download("en_core_web_sm"); nlp_en = spacy.load("en_core_web_sm")
+        except Exception:
+            nlp_en = None
+else:
+    nlp_es = nlp_en = None
 
-def argos_translate_word(w: str, src: str, tgt: str) -> str:
-    if not USE_ARGOS:
-        return ""
+# (opcional) Argos
+if USE_ARGOS:
+    !pip -q install argostranslate
+    import argostranslate.package, argostranslate.translate
     try:
-        langs = argos_tr.get_installed_languages()
-        lsrc = next((l for l in langs if l.code == src), None)
-        ldst = next((l for l in langs if l.code == tgt), None)
-        if not (lsrc and ldst):
-            return ""
-        tr = lsrc.get_translation(ldst)
+        available = argostranslate.package.get_available_packages()
+        need = [p for p in available if {p.from_code, p.to_code} == {"es","en"}]
+        for p in need:
+            path = p.download()
+            argostranslate.package.install_from_path(path)
+        ARGOS_OK = True
+    except Exception as e:
+        print("[Aviso] No se pudieron instalar modelos Argos:", e)
+        ARGOS_OK = False
+else:
+    ARGOS_OK = False
+
+def argos_es2en(w: str) -> str:
+    if not ARGOS_OK: return ""
+    try:
+        langs = argostranslate.translate.get_installed_languages()
+        es = next((l for l in langs if l.code=="es"), None)
+        en = next((l for l in langs if l.code=="en"), None)
+        tr = es.get_translation(en)
         return tr.translate(w) or ""
     except Exception:
         return ""
 
-# ===== Normalización =====
-WORD_RE = re.compile(r"[A-Za-zÁÉÍÓÚÜÑáéíóúüñ]+", re.UNICODE)
-STRIP = str.maketrans("ÁÉÍÓÚÜÑáéíóúüñ", "AEIOUUNaeiouun")
+# ---- Frecuencia ----
+try:
+    from wordfreq import word_frequency, top_n_list
+except Exception:
+    top_n_list = None
+    def word_frequency(w, lang, minimum=0.0): return 0.0
 
+# ---- Normalización ----
+STRIP = str.maketrans("ÁÉÍÓÚÜÑáéíóúüñ", "AEIOUUNaeiouun")
 def norm_es(w: str) -> str:
-    return re.sub(r"[^a-záéíóúüñ]", "", w.lower()).translate(STRIP)
-
+    return re.sub(r"[^a-záéíóúüñ]", "", (w or "").lower()).translate(STRIP)
 def norm_en(w: str) -> str:
-    return re.sub(r"[^a-z]", "", w.lower())
+    return re.sub(r"[^a-z]", "", (w or "").lower())
 
-# ===== Lematización (spaCy si está; si no, reglas + irregulares) =====
-USE_SPACY = False
+def lemma_list_es(words: List[str]) -> List[str]:
+    if not USE_SPACY or nlp_es is None:
+        return [norm_es(w) for w in words if norm_es(w)]
+    doc = nlp_es(" ".join(words))
+    out = []
+    for t in doc:
+        if t.is_alpha:
+            out.append(norm_es(t.lemma_))
+    return out
+
+def lemma_list_en(words: List[str]) -> List[str]:
+    if not USE_SPACY or nlp_en is None:
+        return [norm_en(w) for w in words if norm_en(w)]
+    doc = nlp_en(" ".join(words))
+    out = []
+    for t in doc:
+        if t.is_alpha:
+            out.append(norm_en(t.lemma_))
+    return out
+
+# ---- Descarga OMW (WordNet multilingüe) ----
 try:
-    import spacy
+    wn.download("omw:1.4")  # paquete multilingüe clásico
+except Exception as e:
+    print("[Aviso] No se pudo descargar omw:1.4 (quizá ya está).", e)
+
+# Recolectar lemas ES y sus equivalentes EN por sinset
+print("Extrayendo lemas desde OMW ...")
+spa_lemmas: Dict[str, set] = defaultdict(set)  # es_lemma -> set(en_lemma)
+# Recorremos todos los sinsets disponibles y conectamos ES con EN
+for lex in wn.lexicons():  # todos los lexicones instalados
     try:
-        nlp_es = spacy.load("es_core_news_sm")
-        nlp_en = spacy.load("en_core_web_sm")
-        USE_SPACY = True
+        for ss in wn.synsets(lexicon=lex.id):
+            # lemas por idioma en el sinset
+            es_lem = [norm_es(w.lemma()) for w in ss.words(lang="spa")]
+            en_lem = [norm_en(w.lemma()) for w in ss.words(lang="eng")]
+            if not es_lem or not en_lem: 
+                continue
+            for es in es_lem:
+                if not es: 
+                    continue
+                for en in en_lem:
+                    if not en: 
+                        continue
+                    spa_lemmas[es].add(en)
     except Exception:
-        nlp_es = nlp_en = None
-except Exception:
-    nlp_es = nlp_en = None
+        continue
+
+# Lista final de lemas ES
+es_lemmas = list(spa_lemmas.keys())
+# filtro básico: sin números, mínimo 2 letras
+es_lemmas = [w for w in es_lemmas if len(w) >= 2]
+# Prioriza por frecuencia (wordfreq)
+def freq_es(w: str) -> float:
+    try:
+        return word_frequency(w, "es", minimum=0.0)
+    except Exception:
+        return 0.0
+es_lemmas.sort(key=lambda w: (-freq_es(w), w))
+
+if LIMIT_ES is not None:
+    es_lemmas = es_lemmas[:LIMIT_ES]
+
+# (opcional) lematiza de nuevo (suaviza duplicados y variantes)
+if USE_SPACY and nlp_es:
+    es_lemmas = lemma_list_es(es_lemmas)
+
+# dedup preservando orden
+es_lemmas = list(OrderedDict.fromkeys(es_lemmas))
+
+# Empareja EN
+es2en: Dict[str, str] = {}
+for es in es_lemmas:
+    ens = sorted(spa_lemmas.get(es, []))
+    if ens:
+        es2en[es] = ens[0]   # el primero por orden alfabético (estable)
+    elif ARGOS_OK:
+        tr = norm_en(argos_es2en(es))
+        if tr:
+            es2en[es] = tr
+    else:
+        es2en[es] = ""       # sin equivalente EN (no obligatorio)
+
+# ---- Alfabetos de los conlangs ----
+ALPHA_MINI = (
+    "@ptkmnslraeiouy"   # 14
+    "0123456789"        # +10 = 24
+    "><=:/!?.+-_*#"     # +13 = 37
+    "bcdfghjvqwxz"      # +13 = 50
+    "ACEGHIJKLMNOPRS"   # +16 = 66 (usamos 64 primeros)
+)[:64]
 
-# Irregulares frecuentes (clave normalizada sin tildes)
-IRREG_ES = {
-    # estar
-    "estoy":"estar","estas":"estar","esta":"estar","estamos":"estar","estan":"estar",
-    "estuve":"estar","estuviste":"estar","estuvo":"estar","estuvimos":"estar","estuvieron":"estar",
-    "estare":"estar","estaria":"estar",
-    # ser
-    "soy":"ser","eres":"ser","es":"ser","somos":"ser","son":"ser",
-    "fui":"ser","fuiste":"ser","fue":"ser","fuimos":"ser","fueron":"ser",
-    # tener
-    "tengo":"tener","tienes":"tener","tiene":"tener","tenemos":"tener","tienen":"tener",
-    "tuve":"tener","tuviste":"tener","tuvo":"tener","tuvimos":"tener","tuvieron":"tener",
-    # ir
-    "voy":"ir","vas":"ir","va":"ir","vamos":"ir","van":"ir",
-    "iba":"ir","ibas":"ir","ibamos":"ir","iban":"ir",
-    # haber (aux)
-    "he":"haber","has":"haber","ha":"haber","hemos":"haber","han":"haber",
-    "habia":"haber","habias":"haber","habian":"haber",
-    # otros comunes
-    "hago":"hacer","haces":"hacer","hace":"hacer","hacemos":"hacer","hacen":"hacer",
-    "digo":"decir","dices":"decir","dice":"decir","decimos":"decir","dicen":"decir",
-    "puedo":"poder","puedes":"poder","puede":"poder","podemos":"poder","pueden":"poder",
-    "pongo":"poner","pones":"poner","pone":"poner","ponemos":"poner","ponen":"poner",
-    "quiero":"querer","quieres":"querer","quiere":"querer","queremos":"querer","quieren":"querer",
-    "vengo":"venir","vienes":"venir","viene":"venir","venimos":"venir","vienen":"venir",
-    "veo":"ver","ves":"ver","ve":"ver","vemos":"ver","ven":"ver",
-    "doy":"dar","das":"dar","da":"dar","damos":"dar","dan":"dar",
-    "se":"saber","sabes":"saber","sabe":"saber","sabemos":"saber","saben":"saber",
-}
-
-INTERROG_ES = {
-    "como":"cómo","cómo":"cómo","que":"qué","qué":"qué",
-    "quien":"quién","quién":"quién","cuando":"cuándo","cuándo":"cuándo",
-    "donde":"dónde","dónde":"dónde","cual":"cuál","cuál":"cuál",
-    "cuanto":"cuánto","cuánto":"cuánto","cuanta":"cuánta","cuánta":"cuánta",
-    "cuantos":"cuántos","cuántos":"cuántos","cuantas":"cuántas","cuántas":"cuántas",
-    "porque":"porque","porqué":"porqué"
-}
-
-def lemma_es(token: str) -> str:
-    tok_raw = token.strip()
-    tok = norm_es(tok_raw)
-    if not tok:
-        return tok
-
-    # Interrogativos y afines: conservar como “lema” propio (con o sin acento)
-    if tok_raw.lower() in INTERROG_ES or tok in INTERROG_ES:
-        base = INTERROG_ES.get(tok_raw.lower(), INTERROG_ES.get(tok, tok))
-        return base
-
-    # Irregulares más comunes
-    if tok in IRREG_ES:
-        return IRREG_ES[tok]
-
-    # spaCy si está disponible
-    if USE_SPACY and nlp_es:
-        doc = nlp_es(tok)
-        for t in doc:
-            if t.is_alpha:
-                lem = norm_es(t.lemma_)
-                if lem:
-                    return lem
-
-    # Heurística conservadora (evita confundir “como”→“comer”):
-    rules = [
-        ("ando","ar"),("iendo","er"),("yendo","ir"),               # gerundios
-        ("abamos","ar"),("ábamos","ar"),("iamos","er"),("íamos","er"),("iamos","ir"),("íamos","ir"),
-        ("aste","ar"),("asteis","ar"),("aron","ar"),
-        ("iste","er"),("isteis","er"),("ieron","er"),("imos","er"),
-        ("iste","ir"),("isteis","ir"),("ieron","ir"),("imos","ir"),
-        ("aba","ar"),("abas","ar"),("aban","ar"),
-        ("ia","er"),("ía","er"),("ias","er"),("ías","er"),("ian","er"),("ían","er"),
-        ("ia","ir"),("ía","ir"),("ias","ir"),("ías","ir"),("ian","ir"),("ían","ir"),
-        ("are","ar"),("aré","ar"),("ere","er"),("eré","er"),("ire","ir"),("iré","ir"),
-        ("aria","ar"),("aría","ar"),("eria","er"),("ería","er"),("iria","ir"),("iría","ir"),
-    ]
-    for suf, inf in rules:
-        if tok.endswith(suf) and len(tok) > len(suf)+1:
-            base = tok[:-len(suf)]
-            return base + inf
-
-    return tok  # por defecto no tocar
-
-def lemma_en(token: str) -> str:
-    tok = norm_en(token)
-    if not tok:
-        return tok
-    if USE_SPACY and nlp_en:
-        doc = nlp_en(tok)
-        for t in doc:
-            if t.is_alpha:
-                lem = norm_en(t.lemma_)
-                if lem:
-                    return lem
-    # Heurística mínima: plurales y sufijos comunes
-    for suf, rep in [("ies","y"),("ing",""),("ed",""),("s","")]:
-        if tok.endswith(suf) and len(tok) > len(suf)+1:
-            return tok[:-len(suf)] + rep
-    return tok
-
-# ===== Carga de léxicos =====
-def load_json(path: str):
-    if not os.path.exists(path):
-        return None
-    with open(path, "r", encoding="utf-8") as f:
-        return json.load(f)
-
-def build_dicts():
-    mm = load_json(MINI_JSON) or {}
-    kk = load_json(KOMI_JSON) or {}
-    master = load_json(MAST_JSON) or {}
-
-    es2mini: Dict[str, str] = (mm.get("mapping") or {})
-    es2komi: Dict[str, str] = (kk.get("mapping") or {})
-
-    en2mini: Dict[str, str] = {}
-    en2komi: Dict[str, str] = {}
-    if isinstance(master, dict) and "entries" in master:
-        for e in master["entries"]:
-            es = norm_es(str(e.get("lemma_es","")))
-            en = norm_en(str(e.get("lemma_en","")))
-            mi = str(e.get("minimax",""))
-            ko = str(e.get("komin",""))
-            if en and mi:
-                en2mini[en] = mi
-            if en and ko:
-                en2komi[en] = ko
-
-    mini2es = {v:k for k,v in es2mini.items()}
-    komi2es = {v:k for k,v in es2komi.items()}
-    mini2en = {v:k for k,v in en2mini.items()} if en2mini else {}
-    komi2en = {v:k for k,v in en2komi.items()} if en2komi else {}
-    return es2mini, es2komi, en2mini, en2komi, mini2es, komi2es, mini2en, komi2en
-
-ES2MINI, ES2KOMI, EN2MINI, EN2KOMI, MINI2ES, KOMI2ES, MINI2EN, KOMI2EN = build_dicts()
-
-# ===== Refuerzo: asigna códigos cortos a “básicos” si faltan =====
-ALPHA_MINI = "@ptkmnslraeiouy0123456789><=:/!?.+-_*#bcdfghjvqwxzACEGHIJKLMNOPRS"[:64]
 CJK_BASE = (
     "天地人日月山川雨風星火水木土金石光影花草鳥犬猫魚"
     "東西南北中外上下午夜明暗手口目耳心言書家道路門"
@@ -198,152 +179,88 @@ CJK_BASE = (
 )
 ALPHA_CJK = (CJK_BASE * 10)[:256]
 
-def shortest_unused(prefix_list, used: set, alphabet: str, max_len: int = 3):
-    for L in range(1, max_len+1):
-        for p in prefix_list:
-            if len(p) == L and p not in used:
-                return p
-        def gen(L):
-            if L == 1:
-                for ch in alphabet: 
-                    yield ch
-            else:
-                for prev in gen(L-1):
-                    for ch in alphabet:
-                        yield prev + ch
-        for cand in gen(L):
-            if cand not in used:
-                return cand
-    # fallback
-    i = 1
-    while True:
-        cand = prefix_list[0] + alphabet[0]*i
-        if cand not in used:
-            return cand
-        i += 1
-
-def augment_basics():
-    global ES2MINI, ES2KOMI, MINI2ES, KOMI2ES
-    basics = [
-        "hola","adios","gracias","por","favor","si","no",
-        "que","qué","quien","quién","como","cómo",
-        "cuando","cuándo","donde","dónde","cual","cuál"
-    ]
-    used_mini = set(ES2MINI.values())
-    used_komi = set(ES2KOMI.values())
-    for w in basics:
-        k = norm_es(w)
-        if k not in ES2MINI:
-            code = shortest_unused([w[:1].lower()], used_mini, ALPHA_MINI, max_len=3)
-            ES2MINI[k] = code; MINI2ES[code] = k; used_mini.add(code)
-        if k not in ES2KOMI:
-            code = shortest_unused([w[:1]], used_komi, ALPHA_CJK, max_len=2)
-            ES2KOMI[k] = code; KOMI2ES[code] = k; used_komi.add(code)
-
-augment_basics()
-
-# ===== Codificar ES/EN → conlang (con lematización) =====
-def encode_text(text: str, src_lang: str, target: str) -> str:
-    if not text.strip():
-        return ""
-    lex_es = ES2MINI if target == "Minimax-ASCII" else ES2KOMI
-    lex_en = EN2MINI if target == "Minimax-ASCII" else EN2KOMI
-    use_en_lex = bool(lex_en)
-
-    def repl(m):
-        tok = m.group(0)
-        if src_lang == "Español":
-            key = lemma_es(tok)
-            return lex_es.get(key, tok)
-        else:
-            key = lemma_en(tok)
-            if use_en_lex and key in lex_en:
-                return lex_en[key]
-            # fallback EN->ES con Argos si no hay master
-            es_word = argos_translate_word(tok, "en", "es") if USE_ARGOS else ""
-            key_es = lemma_es(es_word) if es_word else ""
-            return lex_es.get(key_es, tok) if key_es else tok
-
-    return WORD_RE.sub(repl, text)
-
-# ===== Decodificar conlang → ES/EN =====
-SPLIT_CODE_RE = re.compile(r"([^\w\s]+)")
-
-def decode_text(text: str, source: str, tgt_lang: str) -> str:
-    if not text.strip():
-        return ""
-    code2es = MINI2ES if source == "Minimax-ASCII" else KOMI2ES
-    code2en = MINI2EN if source == "Minimax-ASCII" else KOMI2EN
-    have_en = bool(code2en)
-
-    parts = []
-    for chunk in re.split(r"(\s+)", text):
-        if not chunk:
-            continue
-        sub = re.split(SPLIT_CODE_RE, chunk)
-        parts.extend([s for s in sub if s != ""])
-
-    out = []
-    for p in parts:
-        if p.isspace() or re.fullmatch(SPLIT_CODE_RE, p):
-            out.append(p)
-            continue
-        es = code2es.get(p)
-        if tgt_lang == "Español":
-            out.append(es if es else p)
+# ---- Generación de códigos (por longitud creciente, alfabeto barajado por SEED) ----
+def gen_codes(alphabet: str, max_len: int) -> List[str]:
+    codes = []
+    # longitud 1
+    for ch in alphabet:
+        codes.append(ch)
+    # longitudes 2..max_len
+    def gen_len(L: int):
+        if L == 1:
+            for ch in alphabet:
+                yield ch
         else:
-            if have_en and p in code2en:
-                out.append(code2en[p])
-            else:
-                if es:
-                    en = argos_translate_word(es, "es", "en") if USE_ARGOS else ""
-                    out.append(en if en else es)
-                else:
-                    out.append(p)
-    return "".join(out)
-
-# ===== Ayudas UI =====
-HELP_ES = """
-**Consejos:**
-- Este Space **lematiza** la entrada (spaCy si está disponible; si no, reglas + irregulares), así “estás”→“estar” y casa con tu léxico.
-- Añadimos una pequeña **capa de básicos** (hola, gracias, sí, no, interrogativos) si faltan en los JSON, con códigos cortos sin colisiones.
-- Si prefieres trabajar por **formas superficiales** (sin lemas), regenera los JSON en Colab con `LEMMATIZE=False`.
-"""
-
-HELP_EN = """
-**Tips:**
-- Input is **lemmatized** (spaCy if available; otherwise rules + irregulars), so “running”→“run” and matches your lexicon.
-- A small set of **basic words** (hello/thanks/yes/no/interrogatives) gets short codes if missing from JSONs.
-- Prefer surface forms? Rebuild the lexicon in Colab with `LEMMATIZE=False`.
-"""
-
-# ===== UI =====
-with gr.Blocks(title="Conlangs hermanos · Minimax/Kōmín · ES/EN") as demo:
-    gr.Markdown("# Conlangs hermanos · Minimax-ASCII / Kōmín-CJK")
-    with gr.Row():
-        gr.Markdown(HELP_ES)
-        gr.Markdown(HELP_EN)
-
-    with gr.Tab("Codificar (ES/EN → Conlang)"):
-        with gr.Row():
-            src_lang = gr.Dropdown(["Español", "English"], value="Español", label="Idioma fuente")
-            tgt_con  = gr.Dropdown(["Minimax-ASCII", "Kōmín-CJK"], value="Minimax-ASCII", label="Conlang destino")
-        text_in = gr.Textbox(lines=4, label="Texto fuente", value="Hola ¿Cómo estás?")
-        btn_enc = gr.Button("Codificar", variant="primary")
-        text_out = gr.Textbox(lines=6, label="Salida")
-        btn_enc.click(encode_text, [text_in, src_lang, tgt_con], [text_out])
-
-    with gr.Tab("Decodificar (Conlang → ES/EN)"):
-        with gr.Row():
-            src_code = gr.Dropdown(["Minimax-ASCII", "Kōmín-CJK"], value="Minimax-ASCII", label="Conlang fuente")
-            tgt_lang = gr.Dropdown(["Español", "English"], value="Español", label="Idioma destino")
-        code_in = gr.Textbox(lines=4, label="Texto en conlang (separa códigos por espacios si es necesario)")
-        btn_dec = gr.Button("Decodificar", variant="secondary")
-        plain_out = gr.Textbox(lines=6, label="Salida")
-        btn_dec.click(decode_text, [code_in, src_code, tgt_lang], [plain_out])
-
-if __name__ == "__main__":
-    demo.launch()
+            for prev in gen_len(L-1):
+                for ch in alphabet:
+                    yield prev + ch
+    for L in range(2, max_len+1):
+        for c in gen_len(L):
+            codes.append(c)
+    return codes
+
+random.seed(SEED)
+alpha_m = list(ALPHA_MINI); random.shuffle(alpha_m); ALPHA_MINI_SHUF = "".join(alpha_m)
+alpha_k = list(ALPHA_CJK ); random.shuffle(alpha_k); ALPHA_CJK_SHUF  = "".join(alpha_k)
+
+codes_m = gen_codes(ALPHA_MINI_SHUF, MAXLEN_MINI)
+codes_k = gen_codes(ALPHA_CJK_SHUF,  MAXLEN_CJK )
+
+if len(codes_m) < len(es_lemmas): 
+    raise ValueError("Sube MAXLEN_MINI: no hay suficientes códigos para Minimax.")
+if len(codes_k) < len(es_lemmas): 
+    raise ValueError("Sube MAXLEN_CJK: no hay suficientes códigos para Kōmín.")
+
+# ---- Asignación por frecuencia (orden de es_lemmas ya está priorizado) ----
+es2mini = {}
+es2komi = {}
+for i, es in enumerate(es_lemmas):
+    es2mini[es] = codes_m[i]
+    es2komi[es] = codes_k[i]
+
+# ---- Guardado ----
+def write_json(path, obj):
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(obj, f, ensure_ascii=False, indent=2)
+
+def write_tsv(path, rows):
+    import csv
+    with open(path, "w", encoding="utf-8", newline="") as f:
+        w = csv.writer(f, delimiter="\t")
+        w.writerows(rows)
+
+write_json("lexicon_minimax.json", {
+    "lang": "es", "source": "OMW 1.4", "seed": SEED,
+    "alphabet": "Minimax-ASCII", "max_len": MAXLEN_MINI,
+    "size": len(es2mini), "mapping": es2mini
+})
+write_json("lexicon_komin.json", {
+    "lang": "es", "source": "OMW 1.4", "seed": SEED,
+    "alphabet": "Kōmín-CJK", "max_len": MAXLEN_CJK,
+    "size": len(es2komi), "mapping": es2komi
+})
+
+master_rows = [("lemma_es","lemma_en","code_minimax","code_komin")]
+master_json = []
+for es in es_lemmas:
+    master_rows.append((es, es2en.get(es, ""), es2mini[es], es2komi[es]))
+    master_json.append({
+        "lemma_es": es,
+        "lemma_en": es2en.get(es, ""),
+        "minimax": es2mini[es],
+        "komin":   es2komi[es]
+    })
+write_json("lexicon_master.json", {"seed": SEED, "source":"OMW 1.4", "entries": master_json})
+write_tsv("lexicon_master.tsv", master_rows)
+
+print("\n===== RESUMEN =====")
+print(f"Lemas ES extraídos de OMW: {len(es_lemmas)}")
+print("Archivos creados:")
+print(" - lexicon_minimax.json")
+print(" - lexicon_komin.json")
+print(" - lexicon_master.json")
+print(" - lexicon_master.tsv")
+print("Descárgalos desde el panel de archivos de Colab.")