Update app.py

app.py

@@ -2,7 +2,7 @@ import json, re, os
 from typing import Dict
 import gradio as gr
 
-# ===== Archivos de léxico (generados en Colab) =====
+# ===== 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'}, ...]
@@ -39,7 +39,7 @@ def norm_es(w: str) -> str:
 def norm_en(w: str) -> str:
     return re.sub(r"[^a-z]", "", w.lower())
 
-# ===== Lematización (spaCy si está; si no, reglas simples) =====
+# ===== Lematización (spaCy si está; si no, reglas + irregulares) =====
 USE_SPACY = False
 try:
     import spacy
@@ -52,11 +52,12 @@ try:
 except Exception:
     nlp_es = nlp_en = None
 
+# Irregulares frecuentes (clave normalizada sin tildes)
 IRREG_ES = {
     # estar
-    "estoy":"estar","estas":"estar","está":"estar","esta":"estar","estamos":"estar","estan":"estar","están":"estar",
+    "estoy":"estar","estas":"estar","esta":"estar","estamos":"estar","estan":"estar",
     "estuve":"estar","estuviste":"estar","estuvo":"estar","estuvimos":"estar","estuvieron":"estar",
-    "estaria":"estar","estaría":"estar","estarias":"estar","estaría":"estar","estaré":"estar","estare":"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",
@@ -65,11 +66,11 @@ IRREG_ES = {
     "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","íbamos":"ir","iban":"ir",
+    "iba":"ir","ibas":"ir","ibamos":"ir","iban":"ir",
     # haber (aux)
     "he":"haber","has":"haber","ha":"haber","hemos":"haber","han":"haber",
-    "habia":"haber","había":"haber","habias":"haber","habías":"haber","habian":"haber","habían":"haber",
-    # hacer/decir/poder/poner/querer/venir/ver/dar/saber
+    "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",
@@ -78,40 +79,61 @@ IRREG_ES = {
     "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","sé":"saber","sabes":"saber","sabe":"saber","sabemos":"saber","saben":"saber",
+    "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 = norm_es(token)
+    tok_raw = token.strip()
+    tok = norm_es(tok_raw)
     if not tok:
         return tok
-    # irregular primero
+
+    # 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_)
-                return lem if lem else tok
-    # heurística ligera para verbos regulares
-    for suf, inf in [("ando","ar"),("iendo","er"),("yendo","ir"),
-                     ("aré","ar"),("eré","er"),("iré","ir"),("aria","ar"),("aría","ar"),
-                     ("erias","er"),("erías","er"),("iria","ir"),("iría","ir"),
-                     ("aste","ar"),("asteis","ar"),("aron","ar"),("amos","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"),
-                     ("o","ar"),("as","ar"),("a","ar"),("an","ar"),
-                     ("o","er"),("es","er"),("e","er"),("en","er"),
-                     ("o","ir"),("es","ir"),("e","ir"),("en","ir")]:
-        if tok.endswith(suf):
+                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)]
-            if len(base) >= 2:
-                return base + inf
-    return tok
+            return base + inf
+
+    return tok  # por defecto no tocar
 
 def lemma_en(token: str) -> str:
     tok = norm_en(token)
@@ -122,9 +144,10 @@ def lemma_en(token: str) -> str:
         for t in doc:
             if t.is_alpha:
                 lem = norm_en(t.lemma_)
-                return lem if lem else tok
-    # heurística mínima: plurales y gerundio/participio
-    for suf, rep in [("ies","y"),("s",""),("ing",""),("ed","")]:
+                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
@@ -144,7 +167,6 @@ def build_dicts():
     es2mini: Dict[str, str] = (mm.get("mapping") or {})
     es2komi: Dict[str, str] = (kk.get("mapping") or {})
 
-    # EN directo desde master si existe
     en2mini: Dict[str, str] = {}
     en2komi: Dict[str, str] = {}
     if isinstance(master, dict) and "entries" in master:
@@ -166,6 +188,60 @@ def build_dicts():
 
 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 = (
+    "天地人日月山川雨風星火水木土金石光影花草鳥犬猫魚"
+    "東西南北中外上下午夜明暗手口目耳心言書家道路門"
+    "大小長短早晚高低新古青紅白黒金銀銅玉米茶酒米"
+    "文学楽音画体気電海空森林雪雲砂島橋城村国自由静"
+)
+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():
@@ -177,7 +253,7 @@ def encode_text(text: str, src_lang: str, target: str) -> str:
     def repl(m):
         tok = m.group(0)
         if src_lang == "Español":
-            key = lemma_es(tok)   # <— lematiza para casar con el léxico
+            key = lemma_es(tok)
             return lex_es.get(key, tok)
         else:
             key = lemma_en(tok)
@@ -191,7 +267,7 @@ def encode_text(text: str, src_lang: str, target: str) -> str:
     return WORD_RE.sub(repl, text)
 
 # ===== Decodificar conlang → ES/EN =====
-SPLIT_CODE_RE = re.compile(r"([^\w\s]+)")  # separa signos
+SPLIT_CODE_RE = re.compile(r"([^\w\s]+)")
 
 def decode_text(text: str, source: str, tgt_lang: str) -> str:
     if not text.strip():
@@ -226,15 +302,19 @@ def decode_text(text: str, source: str, tgt_lang: str) -> str:
                     out.append(p)
     return "".join(out)
 
-# ===== Ayuda UI =====
+# ===== Ayudas UI =====
 HELP_ES = """
-**Consejo:** Si tu léxico de Colab se creó con `LEMMATIZE=True`, esta app **lematiza** la entrada para que
-formen (p.ej., *“estás” → “estar”*) y **todo case**. Si prefieres no lematizar, regenera el léxico con `LEMMATIZE=False`.
+**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 = """
-**Tip:** If your Colab lexicon was built with `LEMMATIZE=True`, this app **lemmatizes** inputs (e.g., *“running” → “run”*)
-so entries match. If you prefer surface forms, rebuild the lexicon with `LEMMATIZE=False`.
+**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 =====
@@ -268,3 +348,4 @@ if __name__ == "__main__":
 
 
 
+