Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 4 additions & 0 deletions CHANGELOG.md
Original file line number Diff line number Diff line change
Expand Up @@ -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`, `$()`, `</b>`) antes de su apertura. Con argumentos, un «%» suelto que escribió el modelo pasa a «%%».
Expand Down
22 changes: 22 additions & 0 deletions docs/calidad.md
Original file line number Diff line number Diff line change
Expand Up @@ -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

```
Expand Down
12 changes: 12 additions & 0 deletions scripts/medir_calidad.py
Original file line number Diff line number Diff line change
Expand Up @@ -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__)
Expand Down Expand Up @@ -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)

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

P2 Badge Load vanilla usages independently of the embedded glossary

When a measurement bank already contains a juego field and --vanilla is supplied, this guard skips loading usos as well as the already-present game terms. medicion.medir therefore receives no vanilla usage examples and never learns ambiguous-word behavior, so the benchmark does not exercise the feature despite the vanilla files being provided. Load usages whenever --vanilla is set, separately from the optional juego population.

Useful? React with 👍 / 👎.

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]
Expand Down
105 changes: 98 additions & 7 deletions src/traductor_es/nucleo/glosario.py
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand All @@ -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)
Expand Down Expand Up @@ -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():
Expand Down Expand Up @@ -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]:
Expand Down Expand Up @@ -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."""
Expand All @@ -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"(?<![^\W_])" + re.escape(k.lower()) + r"(?![^\W_])"))
Expand All @@ -149,11 +233,18 @@ def _ordenados(self) -> 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
Expand Down
16 changes: 11 additions & 5 deletions src/traductor_es/nucleo/traductor.py
Original file line number Diff line number Diff line change
Expand Up @@ -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,
Expand All @@ -33,6 +33,7 @@
pares_en_orden,
posicionar_argumentos,
separar_bordes,
sin_formato,
)
from .memoria import Memoria

Expand All @@ -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 = (
Expand Down Expand Up @@ -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:
Expand Down Expand Up @@ -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
Expand All @@ -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:
Expand Down
6 changes: 5 additions & 1 deletion src/traductor_es/proceso.py
Original file line number Diff line number Diff line change
Expand Up @@ -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")]:
Expand All @@ -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(
Expand Down Expand Up @@ -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))
Expand Down
Loading
Loading