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}