From 0e443b33d284e9f1fe7c45924a1d7f8bdec76250 Mon Sep 17 00:00:00 2001 From: Cristian Date: Sun, 15 Nov 2026 14:51:04 -0500 Subject: [PATCH 1/2] =?UTF-8?q?fix(glosario):=20t=C3=A9rminos=20con=20otro?= =?UTF-8?q?=20sentido,=20traducciones=20a=20medias=20y=20g=C3=A9nero?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Un término de una palabra que el juego y los mods casi nunca traducen igual en minúscula («target», «power», «lead») solo se manda y se exige cuando el texto lo usa como nombre. Se descartan los términos de un mod a medio traducir, el artículo sigue al género del término que reemplaza al inglés y una frase que vuelve en inglés ya no se guarda en la memoria. --- CHANGELOG.md | 4 + docs/calidad.md | 22 ++++ scripts/medir_calidad.py | 12 +++ src/traductor_es/nucleo/glosario.py | 105 +++++++++++++++++-- src/traductor_es/nucleo/traductor.py | 16 ++- src/traductor_es/proceso.py | 6 +- src/traductor_es/validacion/calidad.py | 116 ++++++++++++++++++-- src/traductor_es/validacion/medicion.py | 7 ++ tests/test_glosario_preciso.py | 134 ++++++++++++++++++++++++ 9 files changed, 399 insertions(+), 23 deletions(-) create mode 100644 tests/test_glosario_preciso.py diff --git a/CHANGELOG.md b/CHANGELOG.md index a333e8c..52f02ea 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -78,6 +78,10 @@ Todos los cambios importantes de ModpackES quedan en este archivo. El formato si ### Corregido +- **El glosario exigía términos donde la palabra tenía otro sentido:** «lead the way» pedía «Correa», «the power signal» pedía «Poder» y «the target» pedía «Diana». Ahora la app mira en el inglés y el español del juego y de los mods cómo se traduce cada palabra cuando va en minúscula. Si casi nunca sale con el término del glosario, ese término solo se manda y se exige cuando el texto lo usa como nombre: es todo el texto, va con mayúscula a mitad de frase o el texto es un nombre en estilo título. Las palabras que sí se traducen igual («fire» → «fuego») se siguen exigiendo, y los términos del usuario siempre. +- **Términos de un mod a medio traducir** («Almacen Portable de Energía», «slot de los Muslos») ya no entran en el glosario: se descarta el término que deja en español una palabra inglesa que no sale en ningún texto en español del juego ni de los mods. Los nombres de los mods de la instancia («estilo Create») no cuentan. +- **Artículo con el género equivocado** al cambiar un término que quedó en inglés: «Usa el Wrench» pasa a «Usa la Llave inglesa», no a «el Llave inglesa». Si no se sabe el género, no se cambia y queda como duda. +- **Frases que volvían en inglés después del reintento** se guardaban en la memoria como si fueran la traducción. Ahora solo se acepta lo que parece un nombre propio («Bronze Dungeons»), marcado para revisarlo; el resto queda sin traducir y se vuelve a intentar en la próxima traducción. - **Argumentos al revés:** si el modelo cambiaba de orden dos `%s` («%s was slain by %s» → «… mató a …»), el juego ponía los valores al revés sin aviso. Ahora, en los archivos de idioma se numeran (`%2$s mató a %1$s`), como hace el propio español de Minecraft; en scripts, misiones y libros el texto se rechaza y se reintenta. - **Escapes `\uXXXX` en scripts de KubeJS y CraftTweaker:** el modelo veía «⟦0⟧00a7cWarning» y podía romper el escape. Ahora los de caracteres visibles se decodifican («§cWarning», «éxito») y los de control quedan protegidos enteros. - **Códigos que el modelo inventa o desordena:** se rechaza la traducción que trae un código que no estaba («§a», «%s») o que deja el cierre de un formato (`§r`, `$()`, ``) antes de su apertura. Con argumentos, un «%» suelto que escribió el modelo pasa a «%%». diff --git a/docs/calidad.md b/docs/calidad.md index b75837f..85cb791 100644 --- a/docs/calidad.md +++ b/docs/calidad.md @@ -467,6 +467,28 @@ queda como duda en el CSV de dudosos. («Vidrio a prueba de Wither», «Nivel III»), así que solo se informan y no se cambian. - Cada control tiene pruebas con textos correctos del español del juego que no deben marcarse (`tests/test_qa.py`). +## 15 de noviembre de 2026 · términos de una palabra con otro sentido + +El glosario exigía «Diana» en «the position of the target», «Poder» en «other power solutions» y «Cambiante» en +«without changing the filter». La app ahora mira cómo traducen el juego y los mods cada palabra en minúscula. En el +español del juego, «target» en minúscula nunca es «Diana» (sale «objetivo») y «power» casi nunca es «Poder» (sale +«energía», «potencia»). Esas palabras solo se mandan y se exigen como término cuando el texto las usa como nombre. +Las que el juego sí traduce siempre igual («fire» → «fuego», «clock» → «reloj») se siguen exigiendo. + +Con Gemini 3.8 Flash y dos corridas grabadas (US$ 0,12), cambiaron los términos de 6 textos de interfaz y 9 de +misiones: + +| | chrF de los 6 textos de interfaz (corridas 1 y 2) | +|---|---| +| Antes | 68,6 · 67,1 | +| Ahora | 75,2 · 75,4 | + +- Interfaz: «la diana» pasó a «el objetivo» en los tres textos. Ninguno empeoró. +- Misiones (sin referencia): «Otras soluciones de Poder» pasó a «de energía» y «sin hacerla Cambiante» a «sin + cambiar»; los demás quedaron igual. +- En todo el banco de interfaz, el chrF quedó en 74,8 · 73,8 (antes 74,8 · 73,3): el cambio toca pocos textos y el + ruido del modelo es mayor. + ## Cómo repetirlo ``` diff --git a/scripts/medir_calidad.py b/scripts/medir_calidad.py index 313ea78..e63633a 100644 --- a/scripts/medir_calidad.py +++ b/scripts/medir_calidad.py @@ -43,6 +43,17 @@ def nombres_del_juego(carpeta: Path, dialecto: str) -> dict[str, str]: return salida +def usos_del_juego(carpeta: Path, dialecto: str) -> list[tuple[dict[str, str], dict[str, str]]]: + """El archivo completo del juego en inglés y en el dialecto, para ver cómo se usan las palabras en minúscula.""" + ruta = carpeta / f"{dialecto}.json" + if not ruta.is_file(): + ruta = carpeta / "es_mx.json" + if not ruta.is_file(): + return [] + ingles: dict[str, str] = json.loads((carpeta / "en_us.json").read_text(encoding="utf-8")) + return [(ingles, json.loads(ruta.read_text(encoding="utf-8")))] + + def main(argv: list[str] | None = None) -> int: sys.stdout.reconfigure(encoding="utf-8", errors="replace") # pyright: ignore[reportAttributeAccessIssue] ap = argparse.ArgumentParser(description=__doc__) @@ -114,6 +125,7 @@ def main(argv: list[str] | None = None) -> int: banco = medicion.Banco.leer(args.banco) if args.vanilla is not None and not banco.juego: banco.juego = nombres_del_juego(args.vanilla, banco.dialecto) + banco.usos = usos_del_juego(args.vanilla, banco.dialecto) print(f"Nombres del juego: {len(banco.juego)}") if args.sin_vecindad: banco.casos = [medicion.Caso(c.ambito, c.original, c.referencia, quitar_vecindad(c.pista)) for c in banco.casos] diff --git a/src/traductor_es/nucleo/glosario.py b/src/traductor_es/nucleo/glosario.py index 7812ee4..efde49a 100644 --- a/src/traductor_es/nucleo/glosario.py +++ b/src/traductor_es/nucleo/glosario.py @@ -5,14 +5,20 @@ import re from collections.abc import Iterable, Mapping +from ..validacion.calidad import PALABRA, sale_el_termino, uso_como_nombre from .mascara import es_traducible, sin_formato _MAX_LARGO = 48 #: Un nombre propio que no se traduce tiene pocas palabras, y todas las largas empiezan con mayúscula. _MAX_PALABRAS_NOMBRE = 3 +#: Textos en español que se guardan por cada palabra inglesa en minúscula, para ver cómo se traduce. +_MAX_USOS = 30 +#: Hace falta ver una palabra en minúscula al menos estas veces para decir que tiene otro sentido. +_MIN_USOS = 2 -def _parece_nombre_propio(texto: str) -> bool: +def parece_nombre_propio(texto: str) -> bool: + """Pocas palabras, la primera con mayúscula y las largas también («Arachnarch», «Bronze Dungeons»).""" palabras = texto.split() if not palabras or len(palabras) > _MAX_PALABRAS_NOMBRE or not any(c.isalpha() for c in texto): return False @@ -31,6 +37,11 @@ def __init__(self) -> None: #: el glosario del usuario no se toca self._sustituciones: list[tuple[re.Pattern[str], str]] = [] self._descubiertos: dict[str, str] = {} #: lo que se decidió en esta ejecución (términos y nombres) + #: Palabra inglesa en minúscula → textos en español donde sale (del juego y los mods ya traducidos) + self._usos: dict[str, list[str]] = {} + self._palabras_es: set[str] = set() #: palabras del español de esos textos (sin mayúsculas) + self._ambiguos: dict[tuple[str, str], bool] = {} + self._marcas: set[str] = set() #: nombres de mods («create»): no son inglés a medio traducir def __len__(self) -> int: return len(self._terminos) + len(self._fijos) @@ -61,10 +72,76 @@ def agregar_pares( en, es = valor_en.strip(), valor_es.strip() if not (3 <= len(en) <= _MAX_LARGO and es and es_traducible(en) and "%" not in en): continue - if en != es or (proteger_iguales and _parece_nombre_propio(en)): + if en != es or (proteger_iguales and parece_nombre_propio(en)): self._agregar(en, es, fuente, oficial) self._orden = None + def aprender_usos(self, ingles: Mapping[str, object], traducido: Mapping[str, object]) -> None: + """Aprende de un archivo en inglés y su traducción cómo se usan las palabras en minúscula. + + Sirve para saber cuándo un término de una palabra tiene otro sentido: «lead» en «lead the way» no es la + «Rienda» del juego. Si en estos textos la palabra en minúscula casi nunca sale traducida con el término, en + minúscula se trata como palabra común (ver `ambiguo`). + """ + for clave, valor_en in ingles.items(): + valor_es = traducido.get(clave) + if not isinstance(valor_en, str) or not isinstance(valor_es, str) or valor_en.strip() == valor_es.strip(): + continue + limpio = sin_formato(valor_es) + self._palabras_es.update(p.casefold() for p in PALABRA.findall(limpio)) + for palabra in {p for p in PALABRA.findall(sin_formato(valor_en)) if p.islower() and len(p) >= 3}: + usos = self._usos.setdefault(palabra, []) + if len(usos) < _MAX_USOS: + usos.append(limpio) + self._ambiguos.clear() + self._orden = None + + def ambiguo(self, termino: str) -> bool: + """¿Un término de una palabra que, escrito en minúscula, suele tener otro sentido? + + Se mira en los textos aprendidos con `aprender_usos`: si la palabra sale en minúscula al menos dos veces y + en menos de la mitad la traducción usa el término, es una palabra común («string», «lead»). Las del usuario + nunca son ambiguas: mandan siempre. + """ + if termino in self._fijos or " " in termino.strip(): + return False + traduccion = self._terminos.get(termino) + usos = self._usos.get(termino.casefold()) + if not traduccion or not usos or len(usos) < _MIN_USOS: + return False + clave = (termino, traduccion) + if clave not in self._ambiguos: + aciertos = sum(1 for es in usos if sale_el_termino(traduccion, es)) + self._ambiguos[clave] = aciertos < len(usos) / 2 + return self._ambiguos[clave] + + def ambiguos(self, terminos: Iterable[str]) -> frozenset[str]: + """Los términos de una palabra que en minúscula tienen otro sentido (ver `ambiguo`).""" + return frozenset(t for t in terminos if self.ambiguo(t)) + + def proteger_nombres(self, nombres: Iterable[str]) -> None: + """Nombres de mods y marcas («create», «mekanism»): que salgan en español no es una traducción a medias.""" + self._marcas.update(n.casefold() for n in nombres) + self._orden = None + + def _a_medias(self, en: str, es: str) -> bool: + """¿Una traducción de un mod a medio hacer («Iron Gear» → «Engranaje de Iron»)? + + Lo es si comparte con el inglés una palabra de 4 letras o más que en inglés se escribe en minúscula y que no + sale en ningún texto en español aprendido. «Redstone» sí sale en el español del juego, así que «Motor de + redstone» vale; «iron» no. + """ + if not self._usos or en == es: + return False + ingles = {p.casefold() for p in PALABRA.findall(en) if len(p) >= 4} + return any( + p.casefold() in ingles + and p.casefold() in self._usos + and p.casefold() not in self._palabras_es + and p.casefold() not in self._marcas + for p in PALABRA.findall(es) + ) + def sustituir(self, palabras: Mapping[str, str]) -> None: """Cambia esas palabras (sin distinguir mayúsculas) en lo que se agregue después, salvo lo del usuario.""" for vieja, nueva in palabras.items(): @@ -98,9 +175,13 @@ def _agregar(self, en: str, es: str, fuente: str, oficial: bool) -> None: del self._fuente[en] self._en_conflicto.add(en) + def _validos(self) -> dict[str, str]: + """Los términos de los mods sin los que quedaron a medio traducir; los del juego y del usuario, todos.""" + return {en: es for en, es in self._terminos.items() if en in self._oficiales or not self._a_medias(en, es)} + def todos(self) -> dict[str, str]: """Todos los términos que se mandarían al motor ({inglés: español}); los del usuario mandan.""" - return {**self._terminos, **self._fijos} + return {**self._validos(), **self._fijos} @property def en_conflicto(self) -> frozenset[str]: @@ -130,7 +211,10 @@ def del_juego(self, termino: str) -> bool: def exacto(self, texto: str) -> str | None: t = texto.strip() - return self._fijos.get(t) or self._terminos.get(t) + if t in self._fijos: + return self._fijos[t] + es = self._terminos.get(t) + return es if es is not None and (t in self._oficiales or not self._a_medias(t, es)) else None def fijo(self, texto: str) -> str | None: """Solo los términos del usuario: mandan incluso sobre lo que ya está en la memoria.""" @@ -139,7 +223,7 @@ def fijo(self, texto: str) -> str | None: def _ordenados(self) -> list[tuple[str, str, re.Pattern[str]]]: orden = self._orden if orden is None: - todos = {**self._terminos, **self._fijos} + todos = {**self._validos(), **self._fijos} # Cada patrón se compila una sola vez; luego se reutiliza en todos los lotes. orden = [ (k.lower(), k, re.compile(r"(? list[tuple[str, str, re.Pattern[str]]]: return orden def relevantes(self, textos: Iterable[str], maximo: int = 60) -> dict[str, str]: - """Términos que aparecen como palabra completa en los textos, priorizando los más largos.""" - bloque = sin_formato("\n".join(textos)).lower() # «&4Arachnarch» también cuenta + """Términos que aparecen como palabra completa en los textos, priorizando los más largos. + + Un término de una palabra con otro sentido en minúscula («lead the way») solo cuenta si algún texto lo + usa como nombre (ver `ambiguo`). + """ + lista = list(textos) + bloque = sin_formato("\n".join(lista)).lower() # «&4Arachnarch» también cuenta elegidos: dict[str, str] = {} for bajo, original, patron in self._ordenados(): if bajo in bloque and patron.search(bloque): + if self.ambiguo(original) and not any(uso_como_nombre(original, t) for t in lista): + continue elegidos[original] = self._fijos.get(original) or self._terminos[original] if len(elegidos) >= maximo: break diff --git a/src/traductor_es/nucleo/traductor.py b/src/traductor_es/nucleo/traductor.py index 8f3b265..d74f1a0 100644 --- a/src/traductor_es/nucleo/traductor.py +++ b/src/traductor_es/nucleo/traductor.py @@ -21,7 +21,7 @@ from . import terminos from .dialectos import DIALECTO_POR_DEFECTO, DIALECTOS from .ejemplos import Ejemplos -from .glosario import Glosario +from .glosario import Glosario, parece_nombre_propio from .mascara import ( Enmascarado, codigos_inventados, @@ -33,6 +33,7 @@ pares_en_orden, posicionar_argumentos, separar_bordes, + sin_formato, ) from .memoria import Memoria @@ -52,6 +53,8 @@ MOTIVO_QA = "control de calidad: " #: Prefijo del motivo de rechazo cuando la traducción repite una palabra que el original no repite. MOTIVO_REPETIDA = "palabra repetida: " +#: Lo que vuelve igual al original en el reintento y parece un nombre propio: se acepta, pero se revisa +MOTIVO_NOMBRE = "sin traducir (¿nombre propio?)" AVISO_TERMINO = "Término que se repite en los nombres de este modpack: tradúcelo suelto, como se diría de un objeto." #: Lo que se le dice al motor de un nombre propio que se repite en las misiones o los libros. AVISO_NOMBRE = ( @@ -390,6 +393,9 @@ def _procesar( final = ajustar_mayusculas(n, final, self._con_mayusculas(glosario)) motivo = self._motivo_de_forma(n, final, glosario) if motivo and tolerante: # segundo intento: se arregla lo que se pueda y se acepta, marcado + if self.controles_de_forma and motivo == "sin traducir" and not parece_nombre_propio(sin_formato(n)): + rechazados[n] = motivo # una frase en inglés no se guarda en la memoria como si fuera la traducción + continue if self.controles_de_forma: final, motivo = self._reparar(n, final, glosario, motivo) if motivo: @@ -448,7 +454,7 @@ def _motivo_de_forma(self, original: str, final: str, glosario: Mapping[str, str return "sin traducir" if glosario and self.glosario_estricto: exigidos = glosario if self.controles_de_forma else {en: es for en, es in glosario.items() if en != es} - faltan = terminos_faltantes(original, final, exigidos) + faltan = terminos_faltantes(original, final, exigidos, self.glosario.ambiguos(exigidos)) if faltan: return MOTIVO_TERMINOLOGIA + "; ".join(f"«{en}» = «{es}»" for en, es in faltan.items()) repetida = palabra_repetida(original, final) if self.controles_de_forma else None @@ -465,12 +471,12 @@ def _reparar( """Arreglo determinista en el reintento: un término del glosario que quedó en inglés se cambia por el suyo. Devuelve la traducción y el motivo que sigue sin resolverse (None si quedó bien). Lo que vuelve igual al - original en el reintento se acepta sin marcar: es un nombre propio. + original en el reintento (y parece un nombre propio) se acepta, marcado para revisarlo. """ if motivo == "sin traducir": - return final, None + return final, MOTIVO_NOMBRE if motivo.startswith(MOTIVO_TERMINOLOGIA) and glosario: - faltan = terminos_faltantes(original, final, glosario) + faltan = terminos_faltantes(original, final, glosario, self.glosario.ambiguos(glosario)) final, siguen = reemplazar_en_ingles(final, faltan, original) final = ajustar_mayusculas(original, final, self._con_mayusculas(glosario)) if not siguen: diff --git a/src/traductor_es/proceso.py b/src/traductor_es/proceso.py index 6f32890..77da990 100644 --- a/src/traductor_es/proceso.py +++ b/src/traductor_es/proceso.py @@ -303,6 +303,7 @@ def _preparar(self, pasada: _Pasada) -> None: glosario.fijar(configuracion.leer_glosario_usuario()) preparar_sustituciones(glosario) tabla = self.instancia.tabla_idiomas() + glosario.proteger_nombres(tabla.datos) # los namespaces: «Create» en «estilo Create» no es inglés orden = [dialecto, *(v for v in ("es_mx", "es_es", *VARIANTES) if v != dialecto)] vocabulario_listo = False for ns in ["minecraft", *sorted(n for n in tabla.datos if n != "minecraft")]: @@ -311,6 +312,9 @@ def _preparar(self, pasada: _Pasada) -> None: vocabulario_listo = True ingles = {k: v for k, v in tabla.textos(ns, "en_us").items() if es_nombre(k)} todo_ingles = tabla.textos(ns, "en_us") + # Cómo se traducen las palabras en minúscula («lead the way» no es la «Rienda»): con el primer español + if traducido := next((t for v in orden if (t := tabla.textos(ns, v))), None): + glosario.aprender_usos(todo_ingles, traducido) for variante in dict.fromkeys(orden): oficial = ns == "minecraft" # los nombres del juego que no se traducen («Creeper») se protegen glosario.agregar_pares( @@ -484,7 +488,7 @@ def ejecutar(self, activar: bool = True, poner_idioma: bool = True, solo_memoria if tradujo_el_motor and self.motor.nombre not in _SIN_CREDITO and self.ctx.pack is not None: self.ctx.pack.anotar_motores([self.motor.nombre]) relevantes = self.glosario.relevantes(todas, maximo=500) - informe.revision = revisar_glosario(todas, relevantes, relevantes) + informe.revision = revisar_glosario(todas, relevantes, relevantes, self.glosario.ambiguos(relevantes)) if informe.dudosos: informe.archivo_dudosos = guardar_dudosos(informe.dudosos, self.instancia.juego) informe.avisos.append(aviso_de_dudosos(informe.dudosos, informe.archivo_dudosos)) diff --git a/src/traductor_es/validacion/calidad.py b/src/traductor_es/validacion/calidad.py index 51f4357..7199b1e 100644 --- a/src/traductor_es/validacion/calidad.py +++ b/src/traductor_es/validacion/calidad.py @@ -6,12 +6,13 @@ import re import unicodedata -from collections.abc import Iterable, Mapping +from collections.abc import Container, Iterable, Mapping from dataclasses import dataclass, field from ..nucleo.mascara import sin_formato -_PALABRA = re.compile(r"[^\W\d_]+") +PALABRA = re.compile(r"[^\W\d_]+") +_PALABRA = PALABRA #: Palabras muy comunes del inglés que casi nunca aparecen en un texto en español. _INGLES = frozenset({ "the", "and", "with", "your", "you", "this", "that", "from", "have", "will", "which", "when", "into", "are", @@ -126,12 +127,33 @@ def _con_mayuscula(termino: str, original: str) -> bool: return False -def terminos_faltantes(original: str, traduccion: str, glosario: Mapping[str, str]) -> dict[str, str]: +def uso_como_nombre(termino: str, original: str) -> bool: + """¿El original usa el término de una palabra como nombre, y no como palabra común? + + Sí si es todo el texto («Lead»), si va con mayúscula a mitad de frase («Tie it with a Lead») o si el texto es un + nombre en estilo título («Lead Block»). «Lead the way» al empezar la frase o «lead» en minúscula, no. + """ + original = sin_formato(original) + if original.strip(" .:!?¡¿\"'").casefold() == termino.casefold(): + return True + for m in _patron_palabra(termino, re.IGNORECASE).finditer(original): + if m.group(0)[:1].isupper() and ( + not _inicio_de_frase(original, m.start()) or _en_estilo_titulo(original, termino) + ): + return True + return False + + +def terminos_faltantes( + original: str, traduccion: str, glosario: Mapping[str, str], ambiguos: Container[str] = frozenset() +) -> dict[str, str]: """{inglés: traducción esperada} de los términos del glosario que salen en el original y no en la traducción. Se tolera que la palabra venga en plural o con otra terminación: es una red contra olvidos, no un corrector de estilo. Un término que queda igual en los dos idiomas («Creeper», un jefe, un mod) solo se exige cuando - el original lo escribe como nombre propio: así no se obliga a dejar en inglés una palabra común. + el original lo escribe como nombre propio: así no se obliga a dejar en inglés una palabra común. Un término de + `ambiguos` (una palabra que en minúscula tiene otro sentido, como «lead» en «lead the way») solo se exige si el + original lo usa como nombre. """ original = sin_formato(original) # «&4Arachnarch»: el código pegado no deja ver la palabra minusculas = original.casefold() @@ -145,6 +167,8 @@ def terminos_faltantes(original: str, traduccion: str, glosario: Mapping[str, st if not patron.search(minusculas): continue minusculas = patron.sub(lambda m: " " * len(m.group(0)), minusculas) + if ingles in ambiguos and not uso_como_nombre(ingles, original): + continue if _sin_tildes(ingles) == _sin_tildes(esperado) and not _con_mayuscula(ingles, original): continue if not sale_el_termino(esperado, traduccion): @@ -202,14 +226,81 @@ def reemplazar_en_ingles(traduccion: str, faltan: Mapping[str, str], original: s return traduccion, dict(faltan) siguen: dict[str, str] = {} for ingles, esperado in faltan.items(): - patron = _patron_palabra(ingles, re.IGNORECASE) - if patron.search(traduccion): - traduccion = patron.sub(lambda _m, e=esperado: e, traduccion) - else: + cambiada = _reemplazar_con_articulo(traduccion, _patron_palabra(ingles, re.IGNORECASE), esperado) + if cambiada is None: siguen[ingles] = esperado + else: + traduccion = cambiada return traduccion, siguen +#: Sustantivos que no siguen la regla de la terminación. +_MASCULINOS = frozenset({ + "día", "mapa", "planeta", "sistema", "problema", "tema", "idioma", "programa", "clima", "poema", "esquema", + "prisma", "aroma", "cometa", "portal", "altar", "panel", "nivel", "metal", "cristal", "cofre", "tridente", + "lingote", "diamante", "bloque", "puente", "motor", "generador", "reactor", "tanque", "imán", "tubo", "cable", + "maná", +}) # fmt: skip +_FEMENINOS = frozenset({ + "mano", "radio", "foto", "moto", "llave", "red", "torre", "nave", "base", "fuente", "piel", "miel", "sal", + "luz", "cruz", "voz", "raíz", "nuez", "flor", "mesa", "lanza", "hacha", "espada", "pala", "azada", "gema", +}) # fmt: skip +#: Artículo → (género, el mismo artículo en el otro género) +_ARTICULOS = { + "el": ("m", "la"), "la": ("f", "el"), "un": ("m", "una"), "una": ("f", "un"), "del": ("m", "de la"), + "de la": ("f", "del"), "al": ("m", "a la"), "a la": ("f", "al"), "los": ("m", "las"), "las": ("f", "los"), + "unos": ("m", "unas"), "unas": ("f", "unos"), +} # fmt: skip +_ARTICULO_ANTES = re.compile(r"(? str | None: + """Género del término en español por su primera palabra («Llave inglesa» → «f»), o None si no se sabe.""" + palabras = _PALABRA.findall(termino) + if not palabras: + return None + nucleo = palabras[0].casefold() + singular = nucleo[:-1] if nucleo.endswith("s") and len(nucleo) > 4 else nucleo + for forma in dict.fromkeys((nucleo, singular)): + if forma in _MASCULINOS: + return "m" + if forma in _FEMENINOS: + return "f" + if singular.endswith(("ción", "sión", "dad", "tad", "tud", "umbre")): + return "f" + if singular.endswith(("ma", "pa")) and len(singular) > 4: + return None # «sistema», «mapa»: muchas excepciones que no están en la lista + if singular.endswith("a"): + return "f" + if singular.endswith(("o", "or", "aje", "ón", "án")): + return "m" + return None + + +def _reemplazar_con_articulo(traduccion: str, patron: re.Pattern[str], esperado: str) -> str | None: + """Cambia cada aparición por `esperado` y ajusta el artículo de delante a su género («el Wrench» → «la Llave»). + + None si no aparece o si hay un artículo delante y no se sabe el género: mejor avisar que dejar «el Llave». + """ + apariciones = list(patron.finditer(traduccion)) + if not apariciones: + return None + nuevo_genero = genero(esperado) + for m in reversed(apariciones): + antes, despues = traduccion[: m.start()], traduccion[m.end() :] + articulo = _ARTICULO_ANTES.search(antes) + if articulo is not None: + if nuevo_genero is None: + return None + palabra = articulo.group(1) + actual, otro = _ARTICULOS[palabra.casefold()] + if actual != nuevo_genero: + otro = otro[0].upper() + otro[1:] if palabra[0].isupper() else otro + antes = antes[: articulo.start()] + otro + articulo.group(2) + traduccion = antes + esperado + despues + return traduccion + + #: Largo mínimo de una palabra para comparar raíces al buscar repeticiones, y largo de la raíz. _RAIZ_REPETIDA = 5 #: Solo se buscan repeticiones en textos cortos (nombres, botones): en una frase larga repetir es normal. @@ -256,7 +347,12 @@ def __str__(self) -> str: return "Términos del glosario no respetados: " + ", ".join(f"{t} ({n})" for t, n in peores) -def revisar_glosario(traducciones: Mapping[str, str], glosario: Mapping[str, str], terminos: Iterable[str]) -> Revision: +def revisar_glosario( + traducciones: Mapping[str, str], + glosario: Mapping[str, str], + terminos: Iterable[str], + ambiguos: Container[str] = frozenset(), +) -> Revision: """Cuenta las veces que un término del glosario aparece en el original pero su traducción no sale. Usa la misma regla que el rechazo de cada traducción (`terminos_faltantes`): tolera tildes, mayúsculas y plurales. @@ -264,6 +360,6 @@ def revisar_glosario(traducciones: Mapping[str, str], glosario: Mapping[str, str revision = Revision() elegidos = {t: glosario[t] for t in terminos if glosario.get(t)} for original, traducida in traducciones.items(): - for termino in terminos_faltantes(original, traducida, elegidos): + for termino in terminos_faltantes(original, traducida, elegidos, ambiguos): revision.inconsistentes[termino] = revision.inconsistentes.get(termino, 0) + 1 return revision diff --git a/src/traductor_es/validacion/medicion.py b/src/traductor_es/validacion/medicion.py index cfa94c9..549880f 100644 --- a/src/traductor_es/validacion/medicion.py +++ b/src/traductor_es/validacion/medicion.py @@ -55,6 +55,11 @@ class Banco: #: Nombres del propio juego ({inglés: español}, también los que no se traducen): entran como oficiales, #: igual que en la app. Vacío en los bancos viejos. juego: dict[str, str] = field(default_factory=dict[str, str]) + #: Archivos completos del juego ({clave: inglés}, {clave: español}) para aprender cómo se usan las palabras + #: en minúscula (ver `Glosario.aprender_usos`); no se guardan en el banco + usos: list[tuple[dict[str, str], dict[str, str]]] = field( + default_factory=list[tuple[dict[str, str], dict[str, str]]] + ) @classmethod def leer(cls, ruta: Path) -> Banco: @@ -362,6 +367,8 @@ def medir( ) agregar_vocabulario(glosario) glosario.agregar_pares({k: k for k in banco.glosario}, banco.glosario, fuente="banco") + for ingles, traducido in banco.usos: + glosario.aprender_usos(ingles, traducido) with Memoria(":memory:") as memoria: ejemplos = Ejemplos(cantidad=cantidad_ejemplos) ejemplos.agregar_pares(banco.ejemplos) diff --git a/tests/test_glosario_preciso.py b/tests/test_glosario_preciso.py new file mode 100644 index 0000000..882d04a --- /dev/null +++ b/tests/test_glosario_preciso.py @@ -0,0 +1,134 @@ +"""Glosario preciso: palabras con otro sentido en minúscula, traducciones a medias, género y textos sin traducir.""" + +from __future__ import annotations + +from traductor_es.motores.base import Lote +from traductor_es.nucleo.glosario import Glosario +from traductor_es.nucleo.memoria import Memoria +from traductor_es.nucleo.traductor import MOTIVO_NOMBRE, Traductor +from traductor_es.validacion.calidad import genero, reemplazar_en_ingles, terminos_faltantes, uso_como_nombre + +# Lo que dice el juego: «lead» y «string» en minúscula casi nunca son la correa o el hilo; «fire» sí es el fuego +_EN = { + "a": "Show them the way and lead the group", + "b": "Mobs follow the lead of their leader", + "c": "Set fire to the block", + "d": "The fire spreads fast", + "e": "Craft a Redstone Torch", + "f": "Powered by a redstone signal", +} +_ES = { + "a": "Muéstrales el camino y guía al grupo", + "b": "Las criaturas siguen el ejemplo de su líder", + "c": "Prende fuego al bloque", + "d": "El fuego se propaga rápido", + "e": "Fabrica una antorcha de redstone", + "f": "Funciona con una señal de redstone", +} + + +def _glosario() -> Glosario: + g = Glosario() + g.agregar_pares( + {"lead": "Lead", "fire": "Fire"}, {"lead": "Correa", "fire": "Fuego"}, fuente="minecraft", oficial=True + ) + g.aprender_usos(_EN, _ES) + return g + + +def test_una_palabra_con_otro_sentido_en_minuscula_es_ambigua() -> None: + g = _glosario() + assert g.ambiguo("Lead") # 0 de 2 textos dicen «Correa» + assert not g.ambiguo("Fire") # 2 de 2 dicen «fuego»: se sigue exigiendo + g.fijar({"Lead": "Plomo"}) + assert not g.ambiguo("Lead") # lo del usuario manda siempre + + +def test_solo_se_exige_cuando_el_original_la_usa_como_nombre() -> None: + glosario = {"Lead": "Correa"} + ambiguos = frozenset({"Lead"}) + assert not terminos_faltantes("Lead the way to the village", "Abre el camino", glosario, ambiguos) + assert not terminos_faltantes("Follow the lead", "Sigue el ejemplo", glosario, ambiguos) + assert terminos_faltantes("Tie the cow with a Lead", "Ata la vaca", glosario, ambiguos) + assert terminos_faltantes("Lead", "Plomo", glosario, ambiguos) + assert terminos_faltantes("Follow the lead", "Sigue el ejemplo", glosario) # sin saber que es ambigua, se exige + + +def test_uso_como_nombre() -> None: + assert uso_como_nombre("Lead", "Lead") + assert uso_como_nombre("Lead", "Tie it with a Lead.") + assert uso_como_nombre("Lead", "Lead Block") # nombre en estilo título + assert not uso_como_nombre("Lead", "Lead the way to the village") + assert not uso_como_nombre("Lead", "follow the lead") + + +def test_el_motor_no_recibe_el_termino_si_tiene_otro_sentido() -> None: + g = _glosario() + assert "Lead" not in g.relevantes(["Lead the way to the village"]) + assert g.relevantes(["Tie the cow with a Lead"]) == {"Lead": "Correa"} + assert g.relevantes(["The fire spreads"]) == {"Fire": "Fuego"} + + +def test_no_se_usan_las_traducciones_a_medias_de_un_mod() -> None: + g = _glosario() + g.agregar_pares( + {"x": "Iron Gear", "y": "Redstone Engine"}, {"x": "Engranaje de Iron", "y": "Motor de redstone"}, fuente="mod" + ) + g.aprender_usos({"z": "Smelt the iron ore"}, {"z": "Funde el mineral de hierro"}) + assert "Iron Gear" not in g.todos() and g.exacto("Iron Gear") is None # «iron» no es español + assert g.todos()["Redstone Engine"] == "Motor de redstone" # el juego dice «redstone» en español + + +def test_el_nombre_de_un_mod_no_es_una_traduccion_a_medias() -> None: + g = _glosario() + g.aprender_usos({"z": "You can create a new world"}, {"z": "Puedes crear un mundo nuevo"}) + g.agregar_pares({"x": "Create Train"}, {"x": "Tren de Create"}, fuente="mod") + assert "Create Train" not in g.todos() + g.proteger_nombres(["create"]) + assert g.todos()["Create Train"] == "Tren de Create" + + +def test_el_articulo_sigue_al_genero_del_termino() -> None: + assert reemplazar_en_ingles("Usa el Wrench para girarlo", {"Wrench": "Llave inglesa"}) == ( + "Usa la Llave inglesa para girarlo", + {}, + ) + assert reemplazar_en_ingles("Saca la Gear del cofre", {"Gear": "Engranaje"})[0] == "Saca el Engranaje del cofre" + assert reemplazar_en_ingles("Ponlo al Altar", {"Altar": "Altar"})[0] == "Ponlo al Altar" + assert reemplazar_en_ingles("Ve a la Forge", {"Forge": "Forja"})[0] == "Ve a la Forja" + assert reemplazar_en_ingles("Usa del Mana", {"Mana": "Maná"})[0] == "Usa del Maná" + # Con artículo delante y sin saber el género, no se cambia: queda como duda + assert reemplazar_en_ingles("Usa el Zorp", {"Zorp": "Zarpel"}) == ("Usa el Zorp", {"Zorp": "Zarpel"}) + assert reemplazar_en_ingles("Zorp listo", {"Zorp": "Zarpel"})[0] == "Zarpel listo" # sin artículo, sí + + +def test_genero() -> None: + assert genero("Llave inglesa") == "f" + assert genero("Engranaje de hierro") == "m" + assert genero("Mesa de trabajo") == "f" + assert genero("Firma rúnica") is None # «-ma» fuera de la lista: muchas excepciones + assert genero("Sistema de tuberías") == "m" + assert genero("Día") == "m" + assert genero("Generación") == "f" + assert genero("Xyzzy") is None + + +class _Terco: + nombre = "terco" + + def traducir_lote(self, lote: Lote) -> dict[str, str]: + return {e.id: e.texto for e in lote.entradas} + + +def test_una_frase_que_sigue_en_ingles_no_se_guarda_en_la_memoria() -> None: + with Memoria(":memory:") as mem: + r = Traductor(_Terco(), mem, Glosario()).traducir(["Place them in the slots"], "mision") + assert not r.traducciones and "Place them in the slots" in r.rechazados + assert mem.obtener("Place them in the slots", "es_mx", "mision") is None + + +def test_un_nombre_que_sigue_igual_se_acepta_para_revisarlo() -> None: + with Memoria(":memory:") as mem: + r = Traductor(_Terco(), mem, Glosario()).traducir(["Bronze Dungeons"], "mision") + assert r.traducciones == {"Bronze Dungeons": "Bronze Dungeons"} + assert r.dudosos == {"Bronze Dungeons": MOTIVO_NOMBRE} From ee96354a097269efc4c79de73596d960b2c8f7ab Mon Sep 17 00:00:00 2001 From: Cristian Date: Sun, 15 Nov 2026 15:28:58 -0500 Subject: [PATCH 2/2] =?UTF-8?q?feat(contexto):=20orden=20del=20archivo,=20?= =?UTF-8?q?objeto=20de=20cada=20tooltip=20y=20vecinas=20de=20men=C3=BA?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Los textos van al motor en el orden del archivo; un tooltip dice de qué objeto habla, un texto corto de menú va con sus claves vecinas y lo que ya traduce el juego va en la pista. Los nombres y términos que se deciden primero llevan una o dos frases donde aparecen, las pistas de textos que solo difieren en espacios se juntan y la versión de España recibe más referencia. En el banco de interfaz el chrF sube 1,37 (IC 0,35 a 2,30). --- CHANGELOG.md | 8 +++ docs/calidad.md | 29 +++++++++ scripts/armar_banco_local.py | 12 +++- src/traductor_es/modulos/mods.py | 92 +++++++++++++++++++++++++++- src/traductor_es/nucleo/traductor.py | 57 ++++++++++++++--- src/traductor_es/proceso.py | 2 +- tests/test_contexto_barato.py | 72 ++++++++++++++++++++++ 7 files changed, 259 insertions(+), 13 deletions(-) create mode 100644 tests/test_contexto_barato.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 52f02ea..cc0e277 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -56,6 +56,14 @@ Todos los cambios importantes de ModpackES quedan en este archivo. El formato si ### Cambiado +- **Más contexto en los textos de los mods, sin costo extra:** + - Los textos van al motor en el orden del archivo y no en orden alfabético, así que un lote junta el nombre de un objeto con su tooltip y el título de una misión con su descripción. + - Un tooltip o una descripción dice de qué objeto habla («habla de «Teleporter»»). + - Un texto corto de un menú («Any», «Left») va con las claves vecinas del archivo («junto a «Source Only», «None»»). + - Si el inglés es igual a un texto del juego, la pista dice cómo lo traduce el juego («en el juego: «Alternar»»), para seguir el español de Minecraft. + - Al decidir un nombre propio o un término que se repite, el motor recibe una o dos frases donde aparece. + - Si el mismo texto sale con y sin espacios en los bordes, sus pistas se juntan en vez de pisarse. + - La versión de España recibe hasta 1.500 caracteres de la traducción latinoamericana como referencia (antes 400), así que también los párrafos largos de los libros conservan las mismas decisiones. - **Controles de forma sin depender del modelo.** Atacan lo que más se corrigió en la revisión humana de 100 textos: - Mayúsculas: un término del glosario que el original escribe como nombre propio («the Quantum Ring») sale con las mayúsculas del glosario («el Anillo Cuántico»). Los nombres del juego («Lingote de hierro», «Cofre») siguen en minúscula en medio de una frase. - Nombres que no se traducen: los del juego («Creeper», «Redstone») y los de una palabra que el modelo dejó igual al traducir los mods («Arachnarch») se protegen. Si una misión los traduce, se reintenta. diff --git a/docs/calidad.md b/docs/calidad.md index 85cb791..38b8775 100644 --- a/docs/calidad.md +++ b/docs/calidad.md @@ -489,6 +489,35 @@ misiones: - En todo el banco de interfaz, el chrF quedó en 74,8 · 73,8 (antes 74,8 · 73,3): el cambio toca pocos textos y el ruido del modelo es mayor. +## 15 de noviembre de 2026 · contexto barato en la interfaz + +Sin cambiar el prompt ni agregar pedidos: +- los textos van al motor en el orden del archivo y no en orden alfabético; +- un tooltip dice de qué objeto habla; +- un texto corto de un menú va con sus claves vecinas; +- si el inglés es igual a un texto del juego, la pista dice cómo lo traduce el juego. + +Para medirlo, una copia del banco de interfaz lleva las pistas nuevas, calculadas con los mismos archivos del corpus +(41 de 399 textos cambian de pista). Gemini 3.8 Flash, dos corridas por condición (US$ 0,09 la condición nueva): + +| | chrF (corridas 1 y 2) | +|---|---| +| Antes (ola 3) | 74,8 · 73,8 | +| Con el contexto | 75,6 · 75,8 | +| Diferencia pareada | **+1,37** (IC 95 %: +0,35 a +2,30) → mejora | + +| Textos | Cuántos | chrF antes | chrF ahora | +|---|---|---|---| +| Con sus vecinas del menú («junto a…») | 26 | 66,8 | 69,6 | +| Con el nombre de su objeto («habla de…») | 8 | 83,6 | 85,0 | +| Igual a un texto del juego | 7 | 100 | 100 | +| Sin pista nueva (solo cambia el orden) | 350 | 74,1 | 75,3 | + +- **Banco de libros:** solo cambia el orden de los lotes y las frases que acompañan a los nombres que se deciden + primero. Dio 67,1 contra 67,5: −0,46 (IC −1,14 a +0,21), no se distingue del ruido. +- **Descripciones de FTB Quests:** traducirlas como un bloque y no línea por línea queda para la ola de segmentación, + porque cambia cómo se escriben los archivos. + ## Cómo repetirlo ``` diff --git a/scripts/armar_banco_local.py b/scripts/armar_banco_local.py index 7b36360..9fe3a3e 100644 --- a/scripts/armar_banco_local.py +++ b/scripts/armar_banco_local.py @@ -25,7 +25,7 @@ import descargar_corpus as dc from traductor_es.formatos import lang_json, lang_legacy -from traductor_es.modulos.mods import Mods, es_nombre +from traductor_es.modulos.mods import es_nombre, pista_con_contexto, textos_del_juego from traductor_es.nucleo import terminos from traductor_es.nucleo.glosario import Glosario from traductor_es.nucleo.mascara import es_traducible @@ -153,6 +153,14 @@ def main() -> int: en_el_banco = {p.ingles for p in elegidos} ejemplos = {p.ingles: p.castellano for p in todos if p.jar not in medir and p.ingles not in en_el_banco} glosario = glosario_del_banco(todos, medir, args.glosario_ingenuo) + # Las pistas como las manda la app: con el objeto de un tooltip, las vecinas de un menú y lo que dice el juego + archivos = {(r.parts[-5], r.parts[-3]): _leer(r) for r in dc.RAIZ.glob("*/langs/*/assets/*/lang/en_[uU][sS].*")} + vanilla = dc.RAIZ / "vanilla" + juego = ( + textos_del_juego(_leer(vanilla / "en_us.json"), _leer(vanilla / "es_mx.json")) + if (vanilla / "es_mx.json").is_file() + else {} + ) banco: dict[str, Any] = { "descripcion": "Pares reales en/es de mods libres, solo para uso local (no se publica).", "dialecto": "es_mx", @@ -163,7 +171,7 @@ def main() -> int: "original": p.ingles, "referencia": p.castellano, "jar": p.jar, - "pista": Mods.pista(p.namespace, p.clave), + "pista": pista_con_contexto(p.namespace, p.clave, archivos.get((p.jar, p.namespace), {}), juego), } for p in elegidos ], diff --git a/src/traductor_es/modulos/mods.py b/src/traductor_es/modulos/mods.py index 6eedfb0..8d1b440 100644 --- a/src/traductor_es/modulos/mods.py +++ b/src/traductor_es/modulos/mods.py @@ -78,6 +78,87 @@ def es_nombre(clave: str) -> bool: return clave.startswith(_CLAVES_DE_NOMBRES) and not clave.endswith((".desc", ".description", ".tooltip", ".info")) +#: Hasta cuántos caracteres de un texto vecino van en la pista, y cuántas claves hermanas. +_LARGO_EN_PISTA = 60 +_HERMANAS = 2 +#: Un texto de menú de hasta estas palabras («Left», «Mode») es ambiguo sin sus hermanas. +_PALABRAS_CORTO = 3 +_PREFIJOS_DE_MENU = ("gui.", "key.", "screen.", "container.", "config.", "options.", "button.", "tooltip.") +_SUFIJOS_DE_DESCRIPCION = (".desc", ".description", ".tooltip", ".info", ".lore") + + +def _corto(texto: str) -> str: + plano = " ".join(texto.split()) + return plano if len(plano) <= _LARGO_EN_PISTA else plano[: _LARGO_EN_PISTA - 1] + "…" + + +def _nombre_del_objeto(clave: str, textos: Mapping[str, str]) -> str | None: + """El nombre del objeto o bloque del que habla una descripción: «item.m.wrench.tooltip.0» → «item.m.wrench»; + «tooltip.m.wrench» → «item.m.wrench» o «block.m.wrench».""" + partes = clave.split(".") + for i in range(len(partes) - 1, 1, -1): + candidata = ".".join(partes[:i]) + if candidata != clave and es_nombre(candidata) and textos.get(candidata): + return textos[candidata] + if partes[0] in ("tooltip", "desc", "description") and len(partes) >= 3: + for prefijo in ("item", "block"): + for i in range(len(partes), 2, -1): + candidata = ".".join((prefijo, *partes[1:i])) + if textos.get(candidata): + return textos[candidata] + return None + + +def _hermanas(clave: str, textos: Mapping[str, str]) -> list[str]: + """Los textos de las claves vecinas en el archivo con el mismo padre («gui.m.mode.left» junto a + «gui.m.mode.right»): la de antes y la de después.""" + padre = clave.rsplit(".", 1)[0] + "." + claves = list(textos) + if clave not in textos: + return [] + i = claves.index(clave) + vecinas = [k for k in (claves[i - 1] if i else None, claves[i + 1] if i + 1 < len(claves) else None) if k] + return [ + _corto(textos[k]) for k in vecinas if k.startswith(padre) and "." not in k[len(padre) :] and textos[k].strip() + ][:_HERMANAS] + + +def textos_del_juego(ingles: Mapping[str, str], traducido: Mapping[str, str]) -> dict[str, str]: + """{inglés: español} de los textos del juego que no son nombres y tienen una sola traducción («Done» → «Listo»).""" + vistos: dict[str, set[str]] = {} + for clave, en in ingles.items(): + es = traducido.get(clave) + if es is not None and en.strip() and es.strip() and en != es and not es_nombre(clave): + vistos.setdefault(en.strip(), set()).add(es.strip()) + return {en: next(iter(es)) for en, es in vistos.items() if len(es) == 1} + + +def pista_con_contexto( + namespace: str, clave: str, textos: Mapping[str, str], juego: Mapping[str, str] | None = None +) -> str: + """La pista de `Mods.pista` y, si ayuda a elegir el sentido, un poco de contexto barato: + + - una descripción o tooltip lleva el nombre de su objeto («de «Llave inglesa»»); + - un texto corto de un menú lleva una o dos claves hermanas («junto a «Right»»); + - si el inglés es igual a un texto del juego, cómo lo dice el juego («en el juego: «Listo»»). + """ + partes = [Mods.pista(namespace, clave)] + ingles = textos.get(clave, "") + bajo = clave.lower() + if not es_nombre(clave) and (bajo.endswith(_SUFIJOS_DE_DESCRIPCION) or bajo.split(".")[0] in ("tooltip", "desc")): + if (nombre := _nombre_del_objeto(clave, textos)) is not None: + partes.append(f"habla de «{_corto(nombre)}»") + elif ( + bajo.startswith(_PREFIJOS_DE_MENU) + and 0 < len(ingles.split()) <= _PALABRAS_CORTO + and (hermanas := _hermanas(clave, textos)) + ): + partes.append("junto a " + ", ".join(f"«{h}»" for h in hermanas)) + if juego and (del_juego := juego.get(ingles.strip())): + partes.append(f"en el juego: «{_corto(del_juego)}»") + return " · ".join(partes) + + def _salto_nuevo(original: str, traduccion: str) -> bool: return any(c in traduccion and c not in original for c in ("\r", "\n")) @@ -103,7 +184,16 @@ def recolectar(self) -> list[Pieza]: copiados = sum(1 for p in self._pendientes if p.existente is not None) if copiados: self.ctx.registro(f"{copiados} textos se copian de otra variante de español, sin gastar") - return [Pieza(p.ingles, self.pista(p.namespace, p.clave)) for p in self._pendientes if p.existente is None] + juego = textos_del_juego(tabla.textos("minecraft", "en_us"), tabla.textos("minecraft", self.ctx.dialecto)) + por_mod: dict[str, Mapping[str, str]] = {} + piezas: list[Pieza] = [] + for p in self._pendientes: + if p.existente is None: + textos = por_mod.get(p.namespace) + if textos is None: + textos = por_mod[p.namespace] = tabla.textos(p.namespace, "en_us") + piezas.append(Pieza(p.ingles, pista_con_contexto(p.namespace, p.clave, textos, juego))) + return piezas def lugares(self) -> list[Lugar]: """Por mod (espacio de nombres), {clave: inglés} de lo que la app traduce (tras `recolectar`).""" diff --git a/src/traductor_es/nucleo/traductor.py b/src/traductor_es/nucleo/traductor.py index d74f1a0..2fb314e 100644 --- a/src/traductor_es/nucleo/traductor.py +++ b/src/traductor_es/nucleo/traductor.py @@ -2,6 +2,7 @@ from __future__ import annotations +import re import threading from collections import Counter from collections.abc import Callable, Iterable, Mapping @@ -57,6 +58,43 @@ MOTIVO_NOMBRE = "sin traducir (¿nombre propio?)" AVISO_TERMINO = "Término que se repite en los nombres de este modpack: tradúcelo suelto, como se diría de un objeto." #: Lo que se le dice al motor de un nombre propio que se repite en las misiones o los libros. +#: Cuántas apariciones de un nombre o término se mandan al decidirlo, y cuánto de cada una. +_APARICIONES = 2 +_LARGO_APARICION = 120 +_FRASE = re.compile(r"[^.!?\n]*[.!?]?") + + +def por_nucleo(pistas: Mapping[str, str]) -> dict[str, str]: + """Las pistas por núcleo (sin espacios de borde), igual que la memoria. Si dos textos solo difieren en esos + espacios, sus pistas se juntan en vez de pisarse.""" + salida: dict[str, list[str]] = {} + for texto, pista in pistas.items(): + if pista: + vistas = salida.setdefault(separar_bordes(texto)[1], []) + if pista not in vistas: + vistas.append(pista) + return {n: " | ".join(v) for n, v in salida.items()} + + +def con_apariciones(aviso: str, termino: str, textos: Iterable[str]) -> str: + """El aviso y una o dos frases donde aparece el término («aparece en: «Defeat the Arachnarch…»»), para decidir + con el sentido que tiene en el pack y no en el vacío.""" + patron = re.compile(r"(?= _APARICIONES: + break + if not vistas: + return aviso + return f"{aviso} Aparece en: " + "; ".join(f"«{v}»" for v in vistas) + + AVISO_NOMBRE = ( "Nombre propio que se repite en los textos de este modpack: decide una sola traducción para todos. El nombre " "de un jefe, una criatura única, una dimensión o un mod se deja igual; un lugar, objeto o grupo con nombre " @@ -144,15 +182,17 @@ def _conocida(self, nucleo: str, ambito: str, correcciones: Mapping[str, str]) - ) def pendientes(self, textos: Iterable[str], ambito: str) -> list[str]: - """Núcleos únicos que habría que mandar al motor (lo demás sale de memoria o glosario).""" + """Núcleos únicos que habría que mandar al motor (lo demás sale de memoria o glosario), en el orden en que + llegan: así un lote junta lo que va junto en el archivo (el nombre de un objeto y su tooltip, el título de una + misión y su descripción) y cada texto le da contexto a sus vecinos.""" correcciones = self.memoria.correcciones(self.dialecto) - vistos: set[str] = set() + vistos: dict[str, None] = {} for t in textos: if es_traducible(t): nucleo = separar_bordes(t)[1] if nucleo not in vistos and self._conocida(nucleo, ambito, correcciones) is None: - vistos.add(nucleo) - return sorted(vistos) + vistos[nucleo] = None + return list(vistos) def conocidas(self, textos: Iterable[str], ambito: str) -> dict[str, str]: """{texto: traducción} de lo que ya se sabe (corrección, glosario o memoria), sin pedir nada al motor.""" @@ -168,10 +208,9 @@ def conocidas(self, textos: Iterable[str], ambito: str) -> dict[str, str]: # ------------------------------------------------------------------ traducción def traducir(self, textos: Iterable[str], ambito: str, pistas: Mapping[str, str] | None = None) -> Resultado: """Traduce y devuelve {texto original: traducción}. Lo que no se pudo traducir con garantías no aparece.""" - # Las pistas se buscan por el núcleo (sin espacios de borde), igual que la memoria - pistas = {separar_bordes(k)[1]: v for k, v in (pistas or {}).items()} + pistas = por_nucleo(pistas or {}) resultado = Resultado() - unicos = {t for t in textos if es_traducible(t)} + unicos = list(dict.fromkeys(t for t in textos if es_traducible(t))) faltan = self.pendientes(unicos, ambito) if faltan and ambito == "ui" and self._unificar_terminos(faltan, ambito): faltan = self.pendientes(unicos, ambito) @@ -232,7 +271,7 @@ def _unificar_terminos(self, faltan: list[str], ambito: str) -> bool: if not candidatos or self.cancelar.is_set(): return False parcial = Resultado() - pistas = dict.fromkeys(candidatos, AVISO_TERMINO) + pistas = {t: con_apariciones(AVISO_TERMINO, t, faltan) for t in candidatos} self._ronda(candidatos, ambito, pistas, (1500, 40), parcial, informar=False, por_lotes=False) hallados = {t: parcial.nuevas[t] for t in candidatos if t in parcial.nuevas} if hallados: @@ -251,7 +290,7 @@ def _unificar_nombres(self, faltan: list[str], ambito: str) -> None: if not candidatos or self.cancelar.is_set(): return parcial = Resultado() - pistas = dict.fromkeys(candidatos, AVISO_NOMBRE) + pistas = {n: con_apariciones(AVISO_NOMBRE, n, faltan) for n in candidatos} self._ronda(candidatos, ambito, pistas, (1500, 40), parcial, informar=False, por_lotes=False, tolerante=True) hallados = {n: parcial.nuevas[n] for n in candidatos if n in parcial.nuevas} if hallados: diff --git a/src/traductor_es/proceso.py b/src/traductor_es/proceso.py index 77da990..ce32a1f 100644 --- a/src/traductor_es/proceso.py +++ b/src/traductor_es/proceso.py @@ -189,7 +189,7 @@ def lugares_de(modulo: Modulo, piezas: list[Pieza]) -> list[Lugar]: #: Lo que se agrega al nombre de un módulo en la segunda pasada. ETIQUETA_ESPANA = " (España)" #: Largo máximo de la traducción principal que acompaña a cada texto en la versión de España. -LARGO_VERSION_PRINCIPAL = 400 +LARGO_VERSION_PRINCIPAL = 1500 @dataclass(slots=True) diff --git a/tests/test_contexto_barato.py b/tests/test_contexto_barato.py new file mode 100644 index 0000000..c39d0fe --- /dev/null +++ b/tests/test_contexto_barato.py @@ -0,0 +1,72 @@ +"""Contexto barato: orden del archivo, pistas de interfaz con su objeto y sus vecinas, y nombres con su frase.""" + +from __future__ import annotations + +from traductor_es.modulos.mods import pista_con_contexto, textos_del_juego +from traductor_es.motores.base import Lote +from traductor_es.motores.simulador import Simulador +from traductor_es.nucleo.glosario import Glosario +from traductor_es.nucleo.memoria import Memoria +from traductor_es.nucleo.traductor import Traductor, con_apariciones, por_nucleo + +_TEXTOS = { + "item.m.wrench": "Wrench", + "item.m.wrench.tooltip": "Rotates blocks", + "tooltip.m.wrench.shift": "Sneak to dismantle", + "gui.m.mode.left": "Left", + "gui.m.mode.right": "Right", + "gui.m.mode.up": "Up", + "gui.m.title": "Wrench Settings", +} + + +def test_un_tooltip_lleva_el_nombre_de_su_objeto() -> None: + assert "habla de «Wrench»" in pista_con_contexto("m", "item.m.wrench.tooltip", _TEXTOS) + assert "habla de «Wrench»" in pista_con_contexto("m", "tooltip.m.wrench.shift", _TEXTOS) + assert "habla de" not in pista_con_contexto("m", "item.m.wrench", _TEXTOS) # el nombre mismo, no + + +def test_un_texto_corto_de_menu_lleva_sus_vecinas_del_archivo() -> None: + pista = pista_con_contexto("m", "gui.m.mode.right", _TEXTOS) + assert "junto a «Left», «Up»" in pista + assert "junto a" not in pista_con_contexto("m", "gui.m.title", _TEXTOS) # su vecina es de otro padre + + +def test_lo_que_ya_dice_el_juego_va_en_la_pista() -> None: + juego = textos_del_juego( + {"gui.done": "Done", "gui.left": "Left", "options.left": "Left", "item.minecraft.stick": "Stick"}, + {"gui.done": "Listo", "gui.left": "Izquierda", "options.left": "Izq.", "item.minecraft.stick": "Palo"}, + ) + assert juego == {"Done": "Listo"} # «Left» tiene dos traducciones y «Stick» es un nombre: no + assert "en el juego: «Listo»" in pista_con_contexto("m", "gui.m.done", {"gui.m.done": "Done"}, juego) + + +def test_las_pistas_de_textos_que_solo_difieren_en_espacios_se_juntan() -> None: + assert por_nucleo({"Done": "gui.a", " Done ": "gui.b", "Back": ""}) == {"Done": "gui.a | gui.b"} + + +def test_un_nombre_se_decide_con_las_frases_donde_aparece() -> None: + pista = con_apariciones( + "Aviso.", "Arachnarch", ["Defeat the &4Arachnarch in its lair. Then rest.", "Arachnarch", "Nothing here"] + ) + assert pista == "Aviso. Aparece en: «Defeat the Arachnarch in its lair.»" + assert con_apariciones("Aviso.", "Zorp", ["Nothing"]) == "Aviso." + + +class _Anotador: + nombre = "anotador" + + def __init__(self) -> None: + self.lotes: list[Lote] = [] + + def traducir_lote(self, lote: Lote) -> dict[str, str]: + self.lotes.append(lote) + return Simulador().traducir_lote(lote) + + +def test_los_lotes_siguen_el_orden_del_archivo() -> None: + motor = _Anotador() + textos = ["Zebra Saddle", "Apple Pie", "Mango Juice"] + with Memoria(":memory:") as mem: + Traductor(motor, mem, Glosario()).traducir(textos, "ui") + assert [e.texto for e in motor.lotes[0].entradas] == textos