LoloSemper commited on
Commit
55a788b
·
verified ·
1 Parent(s): 995ba42

Update app.py

Browse files
Files changed (1) hide show
  1. app.py +177 -30
app.py CHANGED
@@ -1,5 +1,5 @@
1
  import os, re, json, base64
2
- from typing import Dict, List
3
  import gradio as gr
4
 
5
  # ------------ Archivos ya existentes ------------
@@ -9,10 +9,11 @@ LEX_MASTER = "lexicon_master.json" # {entries:[{lemma_es,lemma_en,minimax,kom
9
 
10
  # ------------ Normalización ------------
11
  WORD_RE = re.compile(r"[A-Za-zÁÉÍÓÚÜÑáéíóúüñ]+", re.UNICODE)
12
- PUNCT_SPLIT = re.compile(r"([^\w\s]+)")
13
  STRIP = str.maketrans("ÁÉÍÓÚÜÑáéíóúüñ", "AEIOUUNaeiouun")
 
14
  def norm_es(w: str) -> str:
15
  return re.sub(r"[^a-záéíóúüñ]", "", (w or "").lower()).translate(STRIP)
 
16
  def norm_en(w: str) -> str:
17
  return re.sub(r"[^a-z]", "", (w or "").lower())
18
 
@@ -32,20 +33,36 @@ def load_lexicons():
32
  mini2es = {v:k for k,v in es2mini.items()}
33
  komi2es = {v:k for k,v in es2komi.items()}
34
 
35
- en2mini, en2komi, mini2en, komi2en = {}, {}, {}, {}
 
 
 
 
 
 
36
  if isinstance(master, dict) and "entries" in master:
37
  for e in master["entries"]:
38
  es = norm_es(str(e.get("lemma_es","")))
39
  en = norm_en(str(e.get("lemma_en","")))
40
  mi = str(e.get("minimax",""))
41
  ko = str(e.get("komin",""))
42
- if en and mi: en2mini[en] = mi
43
- if en and ko: en2komi[en] = ko
44
- mini2en = {v:k for k,v in en2mini.items()}
45
- komi2en = {v:k for k,v in en2komi.items()}
46
- return es2mini, es2komi, mini2es, komi2es, en2mini, en2komi, mini2en, komi2en
 
47
 
48
- ES2MINI, ES2KOMI, MINI2ES, KOMI2ES, EN2MINI, EN2KOMI, MINI2EN, KOMI2EN = load_lexicons()
 
 
 
 
 
 
 
 
 
49
 
50
  # ------------ OOV reversible ------------
51
  ALPHA_MINI64 = "@ptkmnslraeiouy0123456789><=:/!?.+-_*#bcdfghjvqwxzACEGHIJKLMNOPRS"[:64]
@@ -110,6 +127,17 @@ def lemma_of(tok, src_lang: str) -> str:
110
  else:
111
  return norm_en(tok.lemma_ if tok.lemma_ else tok.text)
112
 
 
 
 
 
 
 
 
 
 
 
 
113
  # ------------ mapeo lema→código (usa tus JSON) ------------
114
  def code_es(lemma: str, target: str) -> str:
115
  lemma = norm_es(lemma)
@@ -127,7 +155,7 @@ def code_en(lemma: str, target: str) -> str:
127
  if EN2KOMI: return EN2KOMI.get(lemma) or enc_oov_komin(lemma)
128
  return enc_oov_komin(lemma)
129
 
130
- # ------------ reglas compactas ------------
131
  TAM_MINI = {"Pres":"P", "Past":"T", "Fut":"F", "UNK":"P"}
132
  TAM_KOMI = {"Pres":"Ⓟ", "Past":"Ⓣ", "Fut":"Ⓕ", "UNK":"Ⓟ"}
133
 
@@ -143,7 +171,7 @@ def detect_neg(doc) -> bool:
143
  def detect_tense(root) -> str:
144
  m = root.morph
145
  if "Tense=Past" in m: return "Past"
146
- if "Tense=Fut" in m: return "Fut"
147
  if "Tense=Pres" in m: return "Pres"
148
  for c in root.children:
149
  if c.pos_ == "AUX":
@@ -169,19 +197,21 @@ def realize_minimax(doc, src_lang: str, drop_articles=True, zero_copula=True):
169
  root, subs, objs, obls, advs = extract_core(doc)
170
  tense, is_q, is_neg = detect_tense(root), detect_polarity(doc), detect_neg(doc)
171
 
172
- vlem = lemma_of(root, src_lang)
173
  vcode = code_es(vlem, "Minimax-ASCII") if src_lang=="Español" else code_en(vlem, "Minimax-ASCII")
174
 
175
  tail = TAM_MINI.get(tense, "P")
176
  if is_neg: tail += "N"
177
  if is_q: tail += "Q"
178
  if tail:
179
- vcode = f"{vcode}·{tail}"
180
 
181
  def realize_np(tokens):
182
  outs=[]
183
  for t in tokens:
184
- lem = lemma_of(t, src_lang)
 
 
185
  code = code_es(lem, "Minimax-ASCII") if src_lang=="Español" else code_en(lem, "Minimax-ASCII")
186
  outs.append(code)
187
  return outs
@@ -190,7 +220,9 @@ def realize_minimax(doc, src_lang: str, drop_articles=True, zero_copula=True):
190
  O = realize_np(objs) + realize_np(obls)
191
  ADV=[]
192
  for a in advs:
193
- lem = lemma_of(a, src_lang)
 
 
194
  ADV.append(code_es(lem, "Minimax-ASCII") if src_lang=="Español" else code_en(lem, "Minimax-ASCII"))
195
 
196
  if zero_copula and vlem in ("ser","estar","be") and tense=="Pres" and not is_neg and not is_q:
@@ -214,7 +246,9 @@ def realize_komin(doc, src_lang: str, drop_articles=True, zero_copula=True):
214
  def realize_np(tokens, particle):
215
  outs=[]
216
  for t in tokens:
217
- lem = lemma_of(t, src_lang)
 
 
218
  code = code_es(lem, "Kōmín-CJK") if src_lang=="Español" else code_en(lem, "Kōmín-CJK")
219
  outs.append(code + particle)
220
  return outs
@@ -223,7 +257,9 @@ def realize_komin(doc, src_lang: str, drop_articles=True, zero_copula=True):
223
  O = realize_np(objs + obls, P_OBJ)
224
  ADV=[]
225
  for a in advs:
226
- lem = lemma_of(a, src_lang)
 
 
227
  ADV.append(code_es(lem, "Kōmín-CJK") if src_lang=="Español" else code_en(lem, "Kōmín-CJK"))
228
 
229
  v_form = vcode + TAM + (NEG_M if is_neg else "")
@@ -270,8 +306,8 @@ def decode_simple(text: str, source: str, tgt_lang: str) -> str:
270
  code2en = MINI2EN if source=="Minimax-ASCII" else KOMI2EN
271
 
272
  mini_tail_re = re.compile(r"^(?P<stem>.+?)·(?P<tail>[PTFNQ]+)$")
273
- komi_np_re = re.compile(r"(?P<stem>.+?)(?:[ᵖᵒ])$") # NP partículas
274
- komi_tam_re = re.compile(r"^(?P<stem>.+?)[ⓅⓉⒻ]+(?:\u0306)?$") # Verbo TAM + breve
275
 
276
  tokens = re.split(r"(\s+|[^\w\s]+)", text)
277
  out=[]
@@ -345,26 +381,118 @@ def decode_simple(text: str, source: str, tgt_lang: str) -> str:
345
 
346
  return "".join(out)
347
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
348
  # ------------ UI y explicaciones ------------
349
  EXPLAIN_ES = """
350
- **Objetivo:** reversibilidad total (ES/EN ↔ conlang).
351
- - **Minimax (VSO)**: verbo lleva sufijos TAM/neg/pregunta, separados por **`·`** del código léxico: `código·PTFNQ`.
352
- - **Kōmín (SOV)**: partículas **ᵖ/ᵒ** para S/O; verbo final con **Ⓟ/Ⓣ/Ⓕ** y breve de negación; pregunta con **「?」**.
353
- - El decodificador pela esas marcas antes de consultar el diccionario. OOV se mantiene **reversible**.
 
354
  """
 
355
  EXPLAIN_EN = """
356
- **Goal:** full reversibility (EN/ES ↔ conlang).
357
- - **Minimax (VSO)**: verb carries TAM/neg/question suffixes, separated by **`·`** from the base code: `code·PTFNQ`.
358
- - **Kōmín (SOV)**: particles **ᵖ/ᵒ** for S/O; final verb with **Ⓟ/Ⓣ/Ⓕ** and short neg mark; question with **「?」**.
359
- - Decoder strips these markers before dictionary lookup. OOV is **reversibly wrapped**.
 
360
  """
361
 
362
- with gr.Blocks(title="Conlangs · Reversible Phrase Builder") as demo:
363
- gr.Markdown("# Minimax-ASCII / Kōmín-CJK · Reversible Translator")
364
  with gr.Row():
365
  gr.Markdown(EXPLAIN_ES)
366
  gr.Markdown(EXPLAIN_EN)
367
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
368
  with gr.Tab("Construir frase (ES/EN → Conlang)"):
369
  with gr.Row():
370
  src_lang = gr.Dropdown(["Español","English"], value="Español", label="Fuente")
@@ -376,7 +504,8 @@ with gr.Blocks(title="Conlangs · Reversible Phrase Builder") as demo:
376
  out = gr.Textbox(lines=6, label="Salida")
377
  gr.Button("Construir").click(build_sentence, [text_in, src_lang, target, drop_articles, zero_copula], [out])
378
 
379
- with gr.Tab("Codificar simple (solo léxico)"):
 
380
  with gr.Row():
381
  src_lang2 = gr.Dropdown(["Español","English"], value="Español", label="Fuente")
382
  target2 = gr.Dropdown(["Minimax-ASCII","Kōmín-CJK"], value="Minimax-ASCII", label="Conlang")
@@ -392,6 +521,23 @@ with gr.Blocks(title="Conlangs · Reversible Phrase Builder") as demo:
392
  out3 = gr.Textbox(lines=6, label="Salida")
393
  gr.Button("Decodificar").click(decode_simple, [code_in, src_code, tgt_lang], [out3])
394
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
395
  if __name__ == "__main__":
396
  demo.launch()
397
 
@@ -401,3 +547,4 @@ if __name__ == "__main__":
401
 
402
 
403
 
 
 
1
  import os, re, json, base64
2
+ from typing import Dict, List, Tuple
3
  import gradio as gr
4
 
5
  # ------------ Archivos ya existentes ------------
 
9
 
10
  # ------------ Normalización ------------
11
  WORD_RE = re.compile(r"[A-Za-zÁÉÍÓÚÜÑáéíóúüñ]+", re.UNICODE)
 
12
  STRIP = str.maketrans("ÁÉÍÓÚÜÑáéíóúüñ", "AEIOUUNaeiouun")
13
+
14
  def norm_es(w: str) -> str:
15
  return re.sub(r"[^a-záéíóúüñ]", "", (w or "").lower()).translate(STRIP)
16
+
17
  def norm_en(w: str) -> str:
18
  return re.sub(r"[^a-z]", "", (w or "").lower())
19
 
 
33
  mini2es = {v:k for k,v in es2mini.items()}
34
  komi2es = {v:k for k,v in es2komi.items()}
35
 
36
+ # Tablas naturales ↔ naturales a partir del master
37
+ es2en_lemma: Dict[str,str] = {}
38
+ en2es_lemma: Dict[str,str] = {}
39
+
40
+ en2mini, en2komi = {}, {}
41
+ mini2en, komi2en = {}, {}
42
+
43
  if isinstance(master, dict) and "entries" in master:
44
  for e in master["entries"]:
45
  es = norm_es(str(e.get("lemma_es","")))
46
  en = norm_en(str(e.get("lemma_en","")))
47
  mi = str(e.get("minimax",""))
48
  ko = str(e.get("komin",""))
49
+ if es and en:
50
+ # guardamos el primero estable
51
+ es2en_lemma.setdefault(es, en)
52
+ en2es_lemma.setdefault(en, es)
53
+ if en and mi: en2mini.setdefault(en, mi)
54
+ if en and ko: en2komi.setdefault(en, ko)
55
 
56
+ mini2en = {v:k for k,v in en2mini.items()}
57
+ komi2en = {v:k for k,v in en2komi.items()}
58
+
59
+ return (es2mini, es2komi, mini2es, komi2es,
60
+ en2mini, en2komi, mini2en, komi2en,
61
+ es2en_lemma, en2es_lemma)
62
+
63
+ (ES2MINI, ES2KOMI, MINI2ES, KOMI2ES,
64
+ EN2MINI, EN2KOMI, MINI2EN, KOMI2EN,
65
+ ES2EN_LEMMA, EN2ES_LEMMA) = load_lexicons()
66
 
67
  # ------------ OOV reversible ------------
68
  ALPHA_MINI64 = "@ptkmnslraeiouy0123456789><=:/!?.+-_*#bcdfghjvqwxzACEGHIJKLMNOPRS"[:64]
 
127
  else:
128
  return norm_en(tok.lemma_ if tok.lemma_ else tok.text)
129
 
130
+ # ------------ filtros de contenido (evita “hola”, “cómo”, etc. en el núcleo) ------------
131
+ def is_content_token(t) -> bool:
132
+ if t.pos_ in ("INTJ", "DET", "ADP", "SCONJ", "PART", "SYM", "PUNCT"):
133
+ return False
134
+ if t.tag_.startswith("W") or t.lower_ in (
135
+ "como","cómo","que","qué","quien","quién","donde","dónde","cuando","cuándo",
136
+ "por","porqué","por qué","how","what","who","where","when","why"
137
+ ):
138
+ return False
139
+ return True
140
+
141
  # ------------ mapeo lema→código (usa tus JSON) ------------
142
  def code_es(lemma: str, target: str) -> str:
143
  lemma = norm_es(lemma)
 
155
  if EN2KOMI: return EN2KOMI.get(lemma) or enc_oov_komin(lemma)
156
  return enc_oov_komin(lemma)
157
 
158
+ # ------------ reglas compactas (fraseador) ------------
159
  TAM_MINI = {"Pres":"P", "Past":"T", "Fut":"F", "UNK":"P"}
160
  TAM_KOMI = {"Pres":"Ⓟ", "Past":"Ⓣ", "Fut":"Ⓕ", "UNK":"Ⓟ"}
161
 
 
171
  def detect_tense(root) -> str:
172
  m = root.morph
173
  if "Tense=Past" in m: return "Past"
174
+ if "Tense=Fut" in m: return "Fut"
175
  if "Tense=Pres" in m: return "Pres"
176
  for c in root.children:
177
  if c.pos_ == "AUX":
 
197
  root, subs, objs, obls, advs = extract_core(doc)
198
  tense, is_q, is_neg = detect_tense(root), detect_polarity(doc), detect_neg(doc)
199
 
200
+ vlem = lemma_of(root, src_lang)
201
  vcode = code_es(vlem, "Minimax-ASCII") if src_lang=="Español" else code_en(vlem, "Minimax-ASCII")
202
 
203
  tail = TAM_MINI.get(tense, "P")
204
  if is_neg: tail += "N"
205
  if is_q: tail += "Q"
206
  if tail:
207
+ vcode = f"{vcode}·{tail}" # separador para decodificar
208
 
209
  def realize_np(tokens):
210
  outs=[]
211
  for t in tokens:
212
+ if not is_content_token(t):
213
+ continue
214
+ lem = lemma_of(t, src_lang)
215
  code = code_es(lem, "Minimax-ASCII") if src_lang=="Español" else code_en(lem, "Minimax-ASCII")
216
  outs.append(code)
217
  return outs
 
220
  O = realize_np(objs) + realize_np(obls)
221
  ADV=[]
222
  for a in advs:
223
+ if not is_content_token(a):
224
+ continue
225
+ lem = lemma_of(a, src_lang)
226
  ADV.append(code_es(lem, "Minimax-ASCII") if src_lang=="Español" else code_en(lem, "Minimax-ASCII"))
227
 
228
  if zero_copula and vlem in ("ser","estar","be") and tense=="Pres" and not is_neg and not is_q:
 
246
  def realize_np(tokens, particle):
247
  outs=[]
248
  for t in tokens:
249
+ if not is_content_token(t):
250
+ continue
251
+ lem = lemma_of(t, src_lang)
252
  code = code_es(lem, "Kōmín-CJK") if src_lang=="Español" else code_en(lem, "Kōmín-CJK")
253
  outs.append(code + particle)
254
  return outs
 
257
  O = realize_np(objs + obls, P_OBJ)
258
  ADV=[]
259
  for a in advs:
260
+ if not is_content_token(a):
261
+ continue
262
+ lem = lemma_of(a, src_lang)
263
  ADV.append(code_es(lem, "Kōmín-CJK") if src_lang=="Español" else code_en(lem, "Kōmín-CJK"))
264
 
265
  v_form = vcode + TAM + (NEG_M if is_neg else "")
 
306
  code2en = MINI2EN if source=="Minimax-ASCII" else KOMI2EN
307
 
308
  mini_tail_re = re.compile(r"^(?P<stem>.+?)·(?P<tail>[PTFNQ]+)$")
309
+ komi_np_re = re.compile(r"(?P<stem>.+?)(?:[ᵖᵒ])$")
310
+ komi_tam_re = re.compile(r"^(?P<stem>.+?)[ⓅⓉⒻ]+(?:\u0306)?$")
311
 
312
  tokens = re.split(r"(\s+|[^\w\s]+)", text)
313
  out=[]
 
381
 
382
  return "".join(out)
383
 
384
+ # ------------ Natural ↔ Natural (lemas) ------------
385
+ def translate_natural(text: str, src_lang: str, tgt_lang: str) -> str:
386
+ """
387
+ Traducción de ES<->EN a nivel de lema usando lexicon_master.json.
388
+ Devuelve lemas (no inflexiona).
389
+ """
390
+ if not text.strip(): return ""
391
+ if not USE_SPACY: return "[Error] spaCy no está cargado (revisa requirements.txt)."
392
+ nlp = nlp_es if src_lang=="Español" else nlp_en
393
+ doc = nlp(text)
394
+ out=[]
395
+ for t in doc:
396
+ if not t.is_alpha:
397
+ out.append(t.text)
398
+ continue
399
+ lem = lemma_of(t, src_lang)
400
+ if src_lang=="Español": # ES -> EN
401
+ tr = ES2EN_LEMMA.get(lem)
402
+ out.append(tr if tr else lem)
403
+ else: # EN -> ES
404
+ tr = EN2ES_LEMMA.get(lem)
405
+ out.append(tr if tr else lem)
406
+ return " ".join(out)
407
+
408
+ # ------------ Round-trip (ida→vuelta) ------------
409
+ def round_trip(text: str, src_lang: str, target: str, drop_articles: bool, zero_copula: bool):
410
+ if not text.strip():
411
+ return "", ""
412
+ conlang_out = build_sentence(text, src_lang, target, drop_articles, zero_copula)
413
+ back_out = decode_simple(conlang_out, target, src_lang)
414
+ return conlang_out, back_out
415
+
416
+ # ------------ Traductor universal (4-way) ------------
417
+ ALL_LANGS = ["Español","English","Minimax-ASCII","Kōmín-CJK"]
418
+
419
+ def universal_translate(text: str, src: str, tgt: str,
420
+ drop_articles: bool, zero_copula: bool) -> str:
421
+ if not text.strip(): return ""
422
+ if src == tgt: return text
423
+
424
+ # Natural → Conlang
425
+ if src in ("Español","English") and tgt in ("Minimax-ASCII","Kōmín-CJK"):
426
+ return build_sentence(text, src, tgt, drop_articles, zero_copula)
427
+
428
+ # Conlang → Natural
429
+ if src in ("Minimax-ASCII","Kōmín-CJK") and tgt in ("Español","English"):
430
+ return decode_simple(text, src, tgt)
431
+
432
+ # Natural ↔ Natural (lemas)
433
+ if src in ("Español","English") and tgt in ("Español","English"):
434
+ return translate_natural(text, src, tgt)
435
+
436
+ # Conlang ↔ Conlang: Conlang_src -> ES (lemmas) -> Conlang_tgt (lexical)
437
+ if src in ("Minimax-ASCII","Kōmín-CJK") and tgt in ("Minimax-ASCII","Kōmín-CJK"):
438
+ # 1) decodifica a Español (preferimos ES porque el léxico base es ES)
439
+ es_lemmas = decode_simple(text, src, "Español")
440
+ # 2) lexical encode (simple) al conlang destino
441
+ # nota: aquí no fraseamos; mapeamos palabra a palabra
442
+ words = re.findall(r"\w+|[^\w\s]+", es_lemmas)
443
+ out=[]
444
+ for w in words:
445
+ if re.fullmatch(r"\w+", w):
446
+ code = ES2MINI.get(norm_es(w)) if tgt=="Minimax-ASCII" else ES2KOMI.get(norm_es(w))
447
+ if not code:
448
+ code = enc_oov_minimax(w) if tgt=="Minimax-ASCII" else enc_oov_komin(w)
449
+ out.append(code)
450
+ else:
451
+ out.append(w)
452
+ return " ".join(out)
453
+
454
+ return "[No soportado]"
455
+
456
  # ------------ UI y explicaciones ------------
457
  EXPLAIN_ES = """
458
+ **Reversibilidad garantizada (ES/EN ↔ conlangs).**
459
+ - **Minimax (VSO)**: verbo con sufijos **TAM/neg/pregunta** separados por **`·`** del código léxico (p. ej. `código·PTFNQ`).
460
+ - **Kōmín (SOV)**: partículas **ᵖ/ᵒ**, marcas **Ⓟ/Ⓣ/Ⓕ**, negación breve y **「?」** final. El decodificador **pela** todo antes de buscar el código base.
461
+ - **OOV**: tokens fuera de diccionario se envuelven de forma **reversible** (`~…` / `「…」`).
462
+ - **Naturales**: ES↔EN se hace a nivel de **lema** usando `lexicon_master.json` (no hay inflexión).
463
  """
464
+
465
  EXPLAIN_EN = """
466
+ **Full reversibility (EN/ES ↔ conlangs).**
467
+ - **Minimax (VSO)**: verb carries compact **TAM/neg/question** after a reserved separator **`·`** (e.g. `code·PTFNQ`).
468
+ - **Kōmín (SOV)**: particles **ᵖ/ᵒ**, verb **Ⓟ/Ⓣ/Ⓕ**, short neg mark, final **「?」**. Decoder strips them before lookup.
469
+ - **OOV**: unknown tokens are wrapped **reversibly** (`~…` / `「…」`).
470
+ - **Natural languages**: EN↔ES is lemma-level via `lexicon_master.json` (no inflection).
471
  """
472
 
473
+ with gr.Blocks(title="Universal Conlang Translator (Reversible)") as demo:
474
+ gr.Markdown("# Universal Conlang Translator · Minimax-ASCII / Kōmín-CJK")
475
  with gr.Row():
476
  gr.Markdown(EXPLAIN_ES)
477
  gr.Markdown(EXPLAIN_EN)
478
 
479
+ # --- Traducir (universal) ---
480
+ with gr.Tab("Traducir (universal)"):
481
+ with gr.Row():
482
+ uni_src = gr.Dropdown(ALL_LANGS, value="Español", label="Fuente")
483
+ uni_tgt = gr.Dropdown(ALL_LANGS, value="Minimax-ASCII", label="Destino")
484
+ uni_text = gr.Textbox(lines=3, label="Texto", value="Hola, ¿cómo estás?")
485
+ with gr.Row():
486
+ uni_drop = gr.Checkbox(value=True, label="Omitir artículos (ES/EN→conlang)")
487
+ uni_zero = gr.Checkbox(value=True, label="Cópula cero (presente afirm.) (ES/EN→conlang)")
488
+ uni_out = gr.Textbox(lines=6, label="Traducción")
489
+ gr.Button("Traducir").click(
490
+ universal_translate,
491
+ [uni_text, uni_src, uni_tgt, uni_drop, uni_zero],
492
+ [uni_out]
493
+ )
494
+
495
+ # --- Construir frase (natural → conlang) ---
496
  with gr.Tab("Construir frase (ES/EN → Conlang)"):
497
  with gr.Row():
498
  src_lang = gr.Dropdown(["Español","English"], value="Español", label="Fuente")
 
504
  out = gr.Textbox(lines=6, label="Salida")
505
  gr.Button("Construir").click(build_sentence, [text_in, src_lang, target, drop_articles, zero_copula], [out])
506
 
507
+ # --- Codificar / Decodificar simples ---
508
+ with gr.Tab("Codificar simple (sólo léxico)"):
509
  with gr.Row():
510
  src_lang2 = gr.Dropdown(["Español","English"], value="Español", label="Fuente")
511
  target2 = gr.Dropdown(["Minimax-ASCII","Kōmín-CJK"], value="Minimax-ASCII", label="Conlang")
 
521
  out3 = gr.Textbox(lines=6, label="Salida")
522
  gr.Button("Decodificar").click(decode_simple, [code_in, src_code, tgt_lang], [out3])
523
 
524
+ # --- Round-trip (ida→vuelta) ---
525
+ with gr.Tab("Prueba de reversibilidad / Round-trip"):
526
+ with gr.Row():
527
+ rt_src = gr.Dropdown(["Español","English"], value="Español", label="Fuente (ida y vuelta)")
528
+ rt_tgt = gr.Dropdown(["Minimax-ASCII","Kōmín-CJK"], value="Minimax-ASCII", label="Conlang")
529
+ rt_text = gr.Textbox(lines=3, label="Frase de prueba", value="Hola, ¿cómo estás?")
530
+ with gr.Row():
531
+ rt_drop = gr.Checkbox(value=True, label="Omitir artículos")
532
+ rt_zero = gr.Checkbox(value=True, label="Cópula cero (presente afirm.)")
533
+ rt_out_conlang = gr.Textbox(lines=3, label="Conlang (ida)")
534
+ rt_out_back = gr.Textbox(lines=3, label="Vuelta (lemas en idioma fuente)")
535
+ gr.Button("Probar ida → vuelta", variant="primary").click(
536
+ round_trip,
537
+ [rt_text, rt_src, rt_tgt, rt_drop, rt_zero],
538
+ [rt_out_conlang, rt_out_back]
539
+ )
540
+
541
  if __name__ == "__main__":
542
  demo.launch()
543
 
 
547
 
548
 
549
 
550
+