From 9fc0a1cb97497811982a7d3a05d3ee768bc2b472 Mon Sep 17 00:00:00 2001 From: Cristian Date: Sun, 15 Nov 2026 16:04:12 -0500 Subject: [PATCH 1/2] =?UTF-8?q?feat(memoria):=20cada=20modpack=20con=20lo?= =?UTF-8?q?=20suyo,=20calidad=20guardada=20y=20revalidaci=C3=B3n?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit La memoria guarda cada traducción con su modpack y su calidad. Un pack usa lo suyo y, de otro, solo lo que quedó sin dudas; los nombres del juego mandan sobre la memoria y lo que estaba bien se vuelve a comprobar con el glosario de hoy. La base se migra sola con una copia del archivo viejo y el paquete compartible lleva lo dudoso marcado. --- CHANGELOG.md | 7 ++ README.md | 2 +- src/traductor_es/fuentes/modpack.py | 10 +++ src/traductor_es/nucleo/glosario.py | 30 +++++++ src/traductor_es/nucleo/memoria.py | 130 +++++++++++++++++++++------ src/traductor_es/nucleo/traductor.py | 52 ++++++++--- src/traductor_es/proceso.py | 7 +- src/traductor_es/salida/paquete.py | 23 +++-- tests/test_memoria_por_pack.py | 103 +++++++++++++++++++++ tests/test_paquete.py | 17 +++- 10 files changed, 332 insertions(+), 49 deletions(-) create mode 100644 tests/test_memoria_por_pack.py diff --git a/CHANGELOG.md b/CHANGELOG.md index cc0e277..7a55259 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -56,6 +56,13 @@ Todos los cambios importantes de ModpackES quedan en este archivo. El formato si ### Cambiado +- **La memoria distingue cada modpack y recuerda lo dudoso:** + - Cada traducción se guarda con su modpack y con su calidad: «ok», o el motivo por el que se aceptó con dudas. + - Un modpack siempre usa lo suyo. De otro modpack solo usa lo que quedó bien: un término del glosario que no se cumplió en un pack ya no se copia a todos los demás. + - Los nombres del propio juego mandan sobre la memoria («Lingote de hierro» aunque la memoria diga «Lingote de Hierro»). Por encima solo quedan tus correcciones y tu glosario. + - Lo que la memoria tiene como bueno se vuelve a comprobar con los códigos y el glosario de hoy. Si ya no cumple (por ejemplo, agregaste un término), ese texto se traduce de nuevo una vez. Lo que se aceptó con dudas en el mismo pack no se vuelve a pedir, para no pagar en cada traducción. + - La memoria se actualiza sola la primera vez que se abre: lo de antes queda como «ok» y para todos los packs, y se guarda una copia del archivo viejo (`memoria.sqlite.v1.bak`). + - El paquete compartible (`.modpackes.zip`) lleva marcado lo dudoso; al aplicarlo, eso queda solo para ese modpack. Un paquete viejo sigue sirviendo. - **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»»). diff --git a/README.md b/README.md index 56633d6..5268e96 100644 --- a/README.md +++ b/README.md @@ -33,7 +33,7 @@ y **cualquier lanzador**, y escribe a la vez las siete variantes de español del - **No modifica los jars de los mods.** Lo de los mods va en un resource pack aparte. - **Todo tiene copia de seguridad.** Un botón devuelve el modpack a su texto original. -- **No se paga dos veces.** Lo ya traducido queda en una memoria que se reutiliza, también entre modpacks. +- **No se paga dos veces.** Lo ya traducido queda en una memoria que se reutiliza, también entre modpacks (de otro modpack, solo lo que quedó sin dudas). - **Respeta los formatos.** Colores, enlaces, variables y comandos llegan intactos; lo que no pasa las reglas de calidad se reintenta o queda en inglés antes que romper algo. diff --git a/src/traductor_es/fuentes/modpack.py b/src/traductor_es/fuentes/modpack.py index ebc914b..3a212c0 100644 --- a/src/traductor_es/fuentes/modpack.py +++ b/src/traductor_es/fuentes/modpack.py @@ -99,3 +99,13 @@ def datos_del_modpack(juego: Path) -> DatosModpack: if not nombre: nombre = juego.parent.name if juego.name in (".minecraft", "minecraft") else juego.name return DatosModpack(nombre, version) + + +def identificador(juego: Path) -> str: + """Con qué nombre se guarda el modpack en la memoria: el nombre del pack (sin la versión, para que una + actualización siga usando lo suyo) o, si no se sabe, el de su carpeta.""" + nombre = datos_del_modpack(juego).nombre + if nombre: + return nombre + carpeta = juego.parent if juego.name.lower() in ("minecraft", ".minecraft") else juego + return carpeta.name or "instancia" diff --git a/src/traductor_es/nucleo/glosario.py b/src/traductor_es/nucleo/glosario.py index efde49a..5a436c4 100644 --- a/src/traductor_es/nucleo/glosario.py +++ b/src/traductor_es/nucleo/glosario.py @@ -42,6 +42,7 @@ def __init__(self) -> None: 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 + self._por_palabra: dict[str, list[tuple[str, str, re.Pattern[str]]]] | None = None def __len__(self) -> int: return len(self._terminos) + len(self._fijos) @@ -230,8 +231,37 @@ def _ordenados(self) -> list[tuple[str, str, re.Pattern[str]]]: for k in sorted(todos, key=len, reverse=True) ] self._orden = orden + self._por_palabra = None return orden + def oficial(self, texto: str) -> str | None: + """El nombre del propio juego para ese texto entero («Iron Ingot» → «Lingote de hierro»), si el usuario no + lo cambió.""" + t = texto.strip() + return self._terminos.get(t) if t in self._oficiales and t not in self._fijos else None + + def terminos_en(self, texto: str, maximo: int = 60) -> dict[str, str]: + """Lo mismo que `relevantes([texto])`, rápido para muchos textos sueltos: solo mira los términos que empiezan + con una palabra del texto.""" + orden = self._ordenados() + if self._por_palabra is None: + indice: dict[str, list[tuple[str, str, re.Pattern[str]]]] = {} + for termino in orden: + primera = next(iter(PALABRA.findall(termino[0])), termino[0]) + indice.setdefault(primera, []).append(termino) + self._por_palabra = indice + bajo = sin_formato(texto).lower() + candidatos = [c for p in set(PALABRA.findall(bajo)) for c in self._por_palabra.get(p, ())] + elegidos: dict[str, str] = {} + for termino_bajo, original, patron in sorted(candidatos, key=lambda c: -len(c[0])): + if termino_bajo in bajo and patron.search(bajo): + if self.ambiguo(original) and not uso_como_nombre(original, texto): + continue + elegidos[original] = self._fijos.get(original) or self._terminos[original] + if len(elegidos) >= maximo: + break + return elegidos + 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. diff --git a/src/traductor_es/nucleo/memoria.py b/src/traductor_es/nucleo/memoria.py index aa426e0..8b93b06 100644 --- a/src/traductor_es/nucleo/memoria.py +++ b/src/traductor_es/nucleo/memoria.py @@ -1,11 +1,13 @@ -"""Memoria de traducciones en SQLite: lo traducido una vez se reutiliza en cualquier modpack.""" +"""Memoria de traducciones en SQLite: lo traducido una vez se reutiliza en el mismo modpack y, si quedó bien, en +cualquier otro.""" from __future__ import annotations +import shutil import sqlite3 import threading from collections import Counter -from collections.abc import Iterable +from collections.abc import Iterable, Mapping from dataclasses import dataclass from datetime import UTC, datetime from pathlib import Path @@ -31,6 +33,16 @@ class Fila: ambito: str traduccion: str motor: str + calidad: str = "ok" #: «ok» o por qué se aceptó con dudas + + +#: Pack de lo que no es de ningún modpack en particular (lo de antes del esquema 2, las pruebas, las mediciones). +SIN_PACK = "*" +#: Calidad de una traducción que pasó todas las reglas. +OK = "ok" +_LARGO_CALIDAD = 200 +#: Versión del esquema de la base (PRAGMA user_version). +ESQUEMA = 2 def codigos_iguales(original: str, traduccion: str) -> bool: @@ -44,10 +56,13 @@ def _patron_like(texto: str) -> str: class Memoria: - """Guarda (texto original, dialecto, ámbito) → traducción. + """Guarda (texto original, dialecto, ámbito, pack) → traducción, con su calidad. El ámbito separa el tono: una misión tutea al jugador y un nombre de objeto va en mayúscula inicial, así que el mismo texto puede traducirse distinto en cada ámbito. + + El pack separa los modpacks: una traducción se reutiliza siempre en el pack que la hizo, y en otro pack solo si + pasó todas las reglas (calidad «ok»). Lo aceptado con dudas en un pack no se lleva a los demás. """ def __init__(self, ruta: Path | str) -> None: @@ -63,12 +78,16 @@ def __init__(self, ruta: Path | str) -> None: raise def _crear_tablas(self) -> None: + columnas = [str(c[1]) for c in self._db.execute("PRAGMA table_info(traducciones)")] + if columnas and "pack" not in columnas: + self._migrar_a_v2() self._db.execute( """CREATE TABLE IF NOT EXISTS traducciones ( - origen TEXT NOT NULL, dialecto TEXT NOT NULL, ambito TEXT NOT NULL, - traduccion TEXT NOT NULL, motor TEXT NOT NULL, fecha TEXT NOT NULL, - PRIMARY KEY (origen, dialecto, ambito))""" + origen TEXT NOT NULL, dialecto TEXT NOT NULL, ambito TEXT NOT NULL, pack TEXT NOT NULL, + traduccion TEXT NOT NULL, motor TEXT NOT NULL, fecha TEXT NOT NULL, calidad TEXT NOT NULL, + PRIMARY KEY (origen, dialecto, ambito, pack))""" ) + self._db.execute(f"PRAGMA user_version = {ESQUEMA}") # Correcciones del usuario: un texto, una traducción en todos los ámbitos. Mandan sobre todo lo demás. self._db.execute( """CREATE TABLE IF NOT EXISTS correcciones ( @@ -77,22 +96,67 @@ def _crear_tablas(self) -> None: ) self._db.commit() - def obtener(self, origen: str, dialecto: str, ambito: str) -> str | None: + def _migrar_a_v2(self) -> None: + """Esquema 1 → 2 sin perder nada: guarda una copia del archivo y pasa cada fila al pack «*» con calidad «ok» + (no se sabe con qué pack ni con qué dudas se hizo, y así se sigue usando como antes).""" + if self.ruta is not None and self.ruta.is_file(): + shutil.copy2(self.ruta, self.ruta.with_name(self.ruta.name + ".v1.bak")) + self._db.execute("BEGIN") # una sola transacción, también para el ALTER: o se migra todo o nada + try: + self._db.execute("ALTER TABLE traducciones RENAME TO traducciones_v1") + self._db.execute( + """CREATE TABLE traducciones ( + origen TEXT NOT NULL, dialecto TEXT NOT NULL, ambito TEXT NOT NULL, pack TEXT NOT NULL, + traduccion TEXT NOT NULL, motor TEXT NOT NULL, fecha TEXT NOT NULL, calidad TEXT NOT NULL, + PRIMARY KEY (origen, dialecto, ambito, pack))""" + ) + self._db.execute( + "INSERT INTO traducciones SELECT origen, dialecto, ambito, ?, traduccion, motor, fecha, ? " + "FROM traducciones_v1", + (SIN_PACK, OK), + ) + self._db.execute("DROP TABLE traducciones_v1") + except sqlite3.Error: + self._db.rollback() + raise + self._db.commit() + + def fila(self, origen: str, dialecto: str, ambito: str, pack: str = SIN_PACK) -> tuple[str, str] | None: + """(traducción, calidad) que vale para este pack: la suya; si no tiene, la más reciente de otro que quedó + «ok». None si no hay ninguna.""" with self._lock: fila = self._db.execute( - "SELECT traduccion FROM traducciones WHERE origen=? AND dialecto=? AND ambito=?", - (origen, dialecto, ambito), + "SELECT traduccion, calidad FROM traducciones WHERE origen=? AND dialecto=? AND ambito=? " + "AND (pack=? OR calidad=?) ORDER BY pack=? DESC, fecha DESC LIMIT 1", + (origen, dialecto, ambito, pack, OK, pack), ).fetchone() - return None if fila is None else str(fila[0]) - - def guardar(self, pares: dict[str, str], dialecto: str, ambito: str, motor: str) -> None: + return None if fila is None else (str(fila[0]), str(fila[1])) + + def obtener(self, origen: str, dialecto: str, ambito: str, pack: str = SIN_PACK) -> str | None: + hallada = self.fila(origen, dialecto, ambito, pack) + return None if hallada is None else hallada[0] + + def guardar( + self, + pares: Mapping[str, str], + dialecto: str, + ambito: str, + motor: str, + pack: str = SIN_PACK, + dudas: Mapping[str, str] | None = None, + ) -> None: + """Guarda traducciones del pack; las que están en `dudas` ({original: motivo}) quedan marcadas con su motivo.""" if not pares: return fecha = datetime.now(UTC).isoformat(timespec="seconds") + dudas = dudas or {} with self._lock: self._db.executemany( - "INSERT OR REPLACE INTO traducciones VALUES (?, ?, ?, ?, ?, ?)", - [(o, dialecto, ambito, t, motor, fecha) for o, t in pares.items()], + "INSERT OR REPLACE INTO traducciones VALUES (?, ?, ?, ?, ?, ?, ?, ?)", + [ + (o, dialecto, ambito, pack, t, motor, fecha, (dudas.get(o) or OK)[:_LARGO_CALIDAD]) + for o, t in pares.items() + ], ) self._db.commit() @@ -103,33 +167,40 @@ def recientes(self, dialecto: str, limite: int = 50_000) -> dict[str, str]: "SELECT origen, traduccion FROM traducciones WHERE dialecto=? ORDER BY fecha DESC LIMIT ?", (dialecto, limite), ).fetchall() - salida = {str(o): str(t) for o, t in filas} + salida: dict[str, str] = {} + for o, t in filas: # de la más nueva a la más vieja: si un texto está en varios packs, gana la última + salida.setdefault(str(o), str(t)) salida.update(self.correcciones(dialecto)) return salida - def filas(self, buscadas: Iterable[tuple[str, str]], dialecto: str) -> list[Fila]: - """Las traducciones guardadas de esos pares (original, ámbito), con el motor que las hizo.""" + def filas(self, buscadas: Iterable[tuple[str, str]], dialecto: str, pack: str = SIN_PACK) -> list[Fila]: + """Las traducciones que valen para el pack de esos pares (original, ámbito), con el motor y la calidad.""" salida: list[Fila] = [] with self._lock: for origen, ambito in sorted(set(buscadas)): fila = self._db.execute( - "SELECT traduccion, motor FROM traducciones WHERE origen=? AND dialecto=? AND ambito=?", - (origen, dialecto, ambito), + "SELECT traduccion, motor, calidad FROM traducciones WHERE origen=? AND dialecto=? AND ambito=? " + "AND (pack=? OR calidad=?) ORDER BY pack=? DESC, fecha DESC LIMIT 1", + (origen, dialecto, ambito, pack, OK, pack), ).fetchone() if fila is not None: - salida.append(Fila(origen, ambito, str(fila[0]), str(fila[1]))) + salida.append(Fila(origen, ambito, str(fila[0]), str(fila[1]), str(fila[2]))) return salida - def importar(self, filas: Iterable[Fila], dialecto: str) -> int: - """Guarda traducciones de otra memoria (reemplaza las que ya hubiera). Devuelve cuántas guardó.""" + def importar(self, filas: Iterable[Fila], dialecto: str, pack: str = SIN_PACK) -> int: + """Guarda traducciones de otra memoria en el pack (reemplaza las que ya tuviera). Devuelve cuántas guardó.""" fecha = datetime.now(UTC).isoformat(timespec="seconds") - lista = [(f.origen, dialecto, f.ambito, f.traduccion, f.motor, fecha) for f in filas] + lista = [ + (f.origen, dialecto, f.ambito, pack, f.traduccion, f.motor, fecha, (f.calidad or OK)[:_LARGO_CALIDAD]) + for f in filas + ] with self._lock: - self._db.executemany("INSERT OR REPLACE INTO traducciones VALUES (?, ?, ?, ?, ?, ?)", lista) + self._db.executemany("INSERT OR REPLACE INTO traducciones VALUES (?, ?, ?, ?, ?, ?, ?, ?)", lista) self._db.commit() return len(lista) def olvidar(self, origen: str, dialecto: str, ambito: str) -> None: + """Borra ese texto de la memoria en todos los packs.""" with self._lock: self._db.execute( "DELETE FROM traducciones WHERE origen=? AND dialecto=? AND ambito=?", (origen, dialecto, ambito) @@ -194,9 +265,13 @@ def buscar(self, texto: str, dialecto: str, limite: int = 200) -> list[Coinciden else [] ) vistos: set[str] = set() + pares: set[tuple[str, str]] = set() salida: list[Coincidencia] = [] for o, a, t in filas: origen = str(o) + if (origen, str(a)) in pares: # el mismo texto en varios packs: se muestra una vez + continue + pares.add((origen, str(a))) vistos.add(origen) corregida = corregidas.get(origen) salida.append(Coincidencia(origen, str(a), corregida or str(t), corregida is not None)) @@ -209,8 +284,13 @@ def buscar(self, texto: str, dialecto: str, limite: int = 200) -> list[Coinciden return salida[:limite] def cantidad(self) -> int: + """Cuántos textos distintos hay (el mismo texto en varios packs cuenta una vez).""" with self._lock: - return int(self._db.execute("SELECT COUNT(*) FROM traducciones").fetchone()[0]) + return int( + self._db.execute( + "SELECT COUNT(*) FROM (SELECT DISTINCT origen, dialecto, ambito FROM traducciones)" + ).fetchone()[0] + ) def cerrar(self) -> None: with self._lock: diff --git a/src/traductor_es/nucleo/traductor.py b/src/traductor_es/nucleo/traductor.py index 2fb314e..85ace53 100644 --- a/src/traductor_es/nucleo/traductor.py +++ b/src/traductor_es/nucleo/traductor.py @@ -36,7 +36,7 @@ separar_bordes, sin_formato, ) -from .memoria import Memoria +from .memoria import OK, SIN_PACK, Memoria, codigos_iguales Progreso = Callable[[int, int], None] Registro = Callable[[str], None] @@ -142,6 +142,7 @@ def __init__( ejemplos: Ejemplos | None = None, glosario_estricto: bool = True, controles_de_forma: bool = True, + pack: str = SIN_PACK, ) -> None: if dialecto not in DIALECTOS: raise ValueError(f"Dialecto desconocido: {dialecto}") @@ -166,19 +167,42 @@ def __init__( #: Mayúsculas del glosario, nombres que no se traducen, palabras repetidas y reparación del reintento. #: Solo se apaga para medir cuánto aportan. self.controles_de_forma = controles_de_forma + #: El modpack que se traduce: lo dudoso que se guarda en la memoria solo se reutiliza en él + self.pack = pack self._lock = threading.Lock() # ------------------------------------------------------------------ consulta - def _conocida(self, nucleo: str, ambito: str, correcciones: Mapping[str, str]) -> str | None: - """Lo que el usuario corrigió o fijó manda; después, lo ya traducido; después, los nombres oficiales. + def _conocida( + self, nucleo: str, ambito: str, correcciones: Mapping[str, str], revalidar: bool = False + ) -> str | None: + """Qué manda: la corrección del usuario, su glosario, el nombre del propio juego, la memoria (la de este pack + o, de otro, solo lo que quedó bien) y, al final, los demás términos del glosario. + + Con `revalidar`, lo que la memoria tiene como bueno vuelve a pasar los códigos y el glosario de hoy: si ya no + cumple (el glosario cambió, o se guardó antes de una regla nueva), se traduce de nuevo. Lo aceptado con dudas + en este pack no se vuelve a pedir: ya se intentó y saldría lo mismo. `correcciones` se lee una vez por llamada pública (son pocas): así no se consulta la base por cada texto. """ - return ( - correcciones.get(nucleo) - or self.glosario.fijo(nucleo) - or self.memoria.obtener(nucleo, self.dialecto, ambito) - or self.glosario.exacto(nucleo) + hecho = correcciones.get(nucleo) or self.glosario.fijo(nucleo) or self.glosario.oficial(nucleo) + if hecho: + return hecho + fila = self.memoria.fila(nucleo, self.dialecto, ambito, self.pack) + if fila is not None and (not revalidar or fila[1] != OK or self._sigue_valida(nucleo, fila[0])): + return fila[0] + return None if fila is not None else self.glosario.exacto(nucleo) + + def _sigue_valida(self, nucleo: str, traduccion: str) -> bool: + """¿Una traducción de la memoria pasa hoy las reglas que no dependen del modelo (códigos y glosario)?""" + if not codigos_iguales(nucleo, traduccion): + return False + if not (self.glosario_estricto and self.controles_de_forma): + return True + terminos_del_texto = self.glosario.terminos_en(nucleo) + if not terminos_del_texto: + return True + return not terminos_faltantes( + nucleo, traduccion, terminos_del_texto, self.glosario.ambiguos(terminos_del_texto) ) def pendientes(self, textos: Iterable[str], ambito: str) -> list[str]: @@ -190,7 +214,7 @@ def pendientes(self, textos: Iterable[str], ambito: str) -> list[str]: 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: + if nucleo not in vistos and self._conocida(nucleo, ambito, correcciones, revalidar=True) is None: vistos[nucleo] = None return list(vistos) @@ -345,7 +369,7 @@ def _ronda( raise Cancelado() lote = futuros[fut] buenos = fut.result() - self.memoria.guardar(buenos, self.dialecto, ambito, self.motor.nombre) + self._guardar(buenos, ambito, resultado) fallidos.update(n for n in lote if n not in buenos) hechos += len(lote) progreso(hechos, total) @@ -355,6 +379,12 @@ def _ronda( raise return fallidos + def _guardar(self, buenos: Mapping[str, str], ambito: str, resultado: Resultado) -> None: + """Guarda en la memoria, con el pack y el motivo de lo que se aceptó con dudas.""" + with self._lock: + dudas = {n: resultado.dudosos[n] for n in buenos if n in resultado.dudosos} + self.memoria.guardar(buenos, self.dialecto, ambito, self.motor.nombre, self.pack, dudas) + def _ronda_por_lotes( self, lotes: list[list[str]], @@ -371,7 +401,7 @@ def _ronda_por_lotes( total = sum(len(lote) for lote in lotes) for lote, (pedido, mascaras), salida in zip(lotes, pedidos, salidas, strict=True): buenos = self._procesar(lote, mascaras, salida, resultado, tolerante, pedido.glosario, ambito, pistas) - self.memoria.guardar(buenos, self.dialecto, ambito, self.motor.nombre) + self._guardar(buenos, ambito, resultado) fallidos.update(n for n in lote if n not in buenos) hechos += len(lote) progreso(hechos, total) diff --git a/src/traductor_es/proceso.py b/src/traductor_es/proceso.py index ce32a1f..633829c 100644 --- a/src/traductor_es/proceso.py +++ b/src/traductor_es/proceso.py @@ -15,6 +15,7 @@ from . import configuracion from .fuentes.instancia import Instancia +from .fuentes.modpack import identificador from .modulos import crafttweaker, datos, libros, misiones, mods, runtime, scripts from .modulos.base import Contexto, Modulo, Pieza, Resumen, reunir_pistas from .modulos.cambios import Cambios, Lugar, comparar, indice_de, leer_indice, mezclar, para_la_marca, sin_indice @@ -239,10 +240,12 @@ def __init__( self.instancia, Respaldo(self.instancia.juego), dialecto, variantes, registro, PackSalida(self.instancia) ) limites = fabrica.limites_de_lote(motor) + #: El modpack en la memoria: lo dudoso que se traduce aquí no se reutiliza en otros packs + self.pack = identificador(self.instancia.juego) self.traductor = Traductor( motor, self.memoria, self.glosario, dialecto, hilos, progreso, registro, cancelar, validar, usar_lotes=usar_lotes, contexto=contexto, ejemplos=self.ejemplos, - limite_caracteres=limites[0], limite_entradas=limites[1], + limite_caracteres=limites[0], limite_entradas=limites[1], pack=self.pack, ) # fmt: skip self.motor = motor if isinstance(motor, Compatible): @@ -283,7 +286,7 @@ def _crear_espana(self) -> None: traductor_es = Traductor( self.motor, self.memoria, glosario_es, DIALECTO_ESPANA, t.hilos, t.progreso, t.registro, t.cancelar, validar, usar_lotes=t.usar_lotes, contexto=t.contexto, ejemplos=ejemplos_es, - limite_caracteres=t.limite_caracteres, limite_entradas=t.limite_entradas, + limite_caracteres=t.limite_caracteres, limite_entradas=t.limite_entradas, pack=t.pack, ) # fmt: skip self._espana = _Pasada(ctx_es, glosario_es, ejemplos_es, traductor_es) diff --git a/src/traductor_es/salida/paquete.py b/src/traductor_es/salida/paquete.py index dc92c89..76d9042 100644 --- a/src/traductor_es/salida/paquete.py +++ b/src/traductor_es/salida/paquete.py @@ -30,7 +30,7 @@ from ..modulos.libros import CAMPOS_PATCHOULI from ..nucleo.dialectos import DIALECTOS, VARIANTES from ..nucleo.mascara import es_traducible, separar_bordes -from ..nucleo.memoria import Fila, codigos_iguales +from ..nucleo.memoria import OK, Fila, codigos_iguales if TYPE_CHECKING: from ..proceso import Informe, Proceso @@ -130,7 +130,7 @@ def exportar_paquete(proceso: Proceso, destino: Path, revisado: bool = False) -> """Guarda el paquete del modpack de `proceso` en `destino`.""" dialecto = proceso.ctx.dialecto textos, avisos = textos_del_modpack(proceso) - filas = [f for f in proceso.memoria.filas(textos, dialecto) if f.motor not in _NO_SE_COMPARTE] + filas = [f for f in proceso.memoria.filas(textos, dialecto, proceso.pack) if f.motor not in _NO_SE_COMPARTE] nucleos = {n for n, _ in textos} correcciones = {o: t for o, t in proceso.memoria.correcciones(dialecto).items() if o in nucleos} glosario = configuracion.leer_glosario_usuario() @@ -140,7 +140,7 @@ def exportar_paquete(proceso: Proceso, destino: Path, revisado: bool = False) -> filas_es: list[Fila] = [] correcciones_es: dict[str, str] = {} if dialecto != _ESPANA: # la versión de España, si se tradujo con «Traducir también… para España» - filas_es = [f for f in proceso.memoria.filas(textos, _ESPANA) if f.motor not in _NO_SE_COMPARTE] + filas_es = [f for f in proceso.memoria.filas(textos, _ESPANA, proceso.pack) if f.motor not in _NO_SE_COMPARTE] correcciones_es = {o: t for o, t in proceso.memoria.correcciones(_ESPANA).items() if o in nucleos} modelos = sorted({f.motor for f in (*filas, *filas_es)}) meta: dict[str, Any] = { @@ -173,7 +173,10 @@ def exportar_paquete(proceso: Proceso, destino: Path, revisado: bool = False) -> def _fila_json(f: Fila) -> dict[str, str]: - return {"origen": f.origen, "ambito": f.ambito, "traduccion": f.traduccion, "motor": f.motor} + fila = {"origen": f.origen, "ambito": f.ambito, "traduccion": f.traduccion, "motor": f.motor} + if f.calidad != OK: # lo aceptado con dudas viaja marcado (un paquete viejo no trae el campo: todo «ok») + fila["calidad"] = f.calidad + return fila def _json(datos: object) -> bytes: @@ -244,7 +247,9 @@ def _filas_validas(crudo: object, resumen: ResumenImportacion) -> list[Fila]: if ambito not in _AMBITOS or not isinstance(motor, str) or not _texto_valido(origen, traduccion): resumen.descartados += 1 continue - filas.append(Fila(cast(str, origen), cast(str, ambito), cast(str, traduccion).strip(), motor[:200])) + calidad = d.get("calidad") + calidad = calidad[:200] if isinstance(calidad, str) and calidad.strip() else OK + filas.append(Fila(cast(str, origen), cast(str, ambito), cast(str, traduccion).strip(), motor[:200], calidad)) return filas @@ -319,10 +324,10 @@ def importar_paquete(proceso: Proceso, ruta: Path) -> ResumenImportacion: correcciones_es = _pares_validos(_leer(zf, _CORRECCIONES_ES), _MAX_TEXTO, resumen) if con_espana else {} resumen.avisos = _avisos_de_version(proceso, meta) resumen.modelos = sorted({f.motor for f in (*filas, *filas_es)}) - resumen.memoria = proceso.memoria.importar(filas, dialecto) + resumen.memoria = proceso.memoria.importar(filas, dialecto, proceso.pack) resumen.correcciones = _importar_correcciones(proceso, correcciones, dialecto, resumen) if filas_es or correcciones_es: - resumen.espana = proceso.memoria.importar(filas_es, _ESPANA) + resumen.espana = proceso.memoria.importar(filas_es, _ESPANA, proceso.pack) resumen.correcciones += _importar_correcciones(proceso, correcciones_es, _ESPANA, resumen) terminos = configuracion.leer_glosario_usuario() nuevos = {en: es for en, es in glosario.items() if en not in terminos} @@ -370,8 +375,8 @@ def importar_resource_pack(proceso: Proceso, ruta: Path) -> ResumenImportacion: if not pares and not libros: raise ValueError(f"{ruta.name} no tiene textos en español de los mods de esta instancia.") motor = f"pack:{nombre}" - proceso.memoria.guardar(pares, dialecto, "ui", motor) - proceso.memoria.guardar(libros, dialecto, AMBITO_LIBRO, motor) + proceso.memoria.guardar(pares, dialecto, "ui", motor, proceso.pack) + proceso.memoria.guardar(libros, dialecto, AMBITO_LIBRO, motor, proceso.pack) resumen.memoria, resumen.modelos = len(pares) + len(libros), [motor] return resumen diff --git a/tests/test_memoria_por_pack.py b/tests/test_memoria_por_pack.py new file mode 100644 index 0000000..03125c8 --- /dev/null +++ b/tests/test_memoria_por_pack.py @@ -0,0 +1,103 @@ +"""Memoria con pack y calidad: migración sin pérdidas, lo dudoso no viaja entre packs y lo viejo se revalida.""" + +from __future__ import annotations + +import sqlite3 +from pathlib import Path + +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 Traductor + + +def _memoria_v1(ruta: Path) -> None: + db = sqlite3.connect(ruta) + db.execute( + "CREATE TABLE traducciones (origen TEXT NOT NULL, dialecto TEXT NOT NULL, ambito TEXT NOT NULL, " + "traduccion TEXT NOT NULL, motor TEXT NOT NULL, fecha TEXT NOT NULL, PRIMARY KEY (origen, dialecto, ambito))" + ) + db.execute("INSERT INTO traducciones VALUES ('Hello', 'es_mx', 'ui', 'Hola', 'gemini', '2026-01-01')") + db.commit() + db.close() + + +def test_la_migracion_conserva_todo_y_guarda_una_copia(tmp_path: Path) -> None: + ruta = tmp_path / "memoria.sqlite" + _memoria_v1(ruta) + with Memoria(ruta) as m: + assert m.obtener("Hello", "es_mx", "ui", "Cualquier pack") == "Hola" # lo viejo vale en todos los packs + assert m.cantidad() == 1 + assert m._db.execute("PRAGMA user_version").fetchone()[0] == 2 # pyright: ignore[reportPrivateUsage] + assert (tmp_path / "memoria.sqlite.v1.bak").is_file() + with Memoria(ruta) as m: # abrirla otra vez no vuelve a migrar + assert m.obtener("Hello", "es_mx", "ui") == "Hola" + + +def test_lo_dudoso_de_un_pack_no_se_usa_en_otro() -> None: + with Memoria(":memory:") as m: + m.guardar({"Gear": "Engranaje"}, "es_mx", "ui", "g", "A") + m.guardar({"Lead": "Correa"}, "es_mx", "ui", "g", "A", {"Lead": "terminología: «Lead»"}) + assert m.obtener("Lead", "es_mx", "ui", "A") == "Correa" # en su pack, sí + assert m.obtener("Lead", "es_mx", "ui", "B") is None # en otro, se traduce de nuevo + assert m.obtener("Gear", "es_mx", "ui", "B") == "Engranaje" # lo que quedó bien viaja + m.guardar({"Gear": "Rueda"}, "es_mx", "ui", "g", "B") + assert m.obtener("Gear", "es_mx", "ui", "A") == "Engranaje" # cada pack prefiere lo suyo + assert m.cantidad() == 2 # el mismo texto en dos packs cuenta una vez + assert len(m.buscar("Gear", "es_mx")) == 1 + + +class _Contador: + nombre = "contador" + + def __init__(self, respuestas: dict[str, str]) -> None: + self.respuestas = respuestas + self.pedidos: list[str] = [] + + def traducir_lote(self, lote: Lote) -> dict[str, str]: + self.pedidos += [e.texto for e in lote.entradas] + return {e.id: self.respuestas.get(e.texto, e.texto) for e in lote.entradas} + + +def test_el_nombre_del_juego_manda_sobre_la_memoria() -> None: + glosario = Glosario() + glosario.agregar_pares({"k": "Iron Ingot"}, {"k": "Lingote de hierro"}, fuente="minecraft", oficial=True) + with Memoria(":memory:") as m: + m.guardar({"Iron Ingot": "Lingote de Hierro"}, "es_mx", "ui", "g") + t = Traductor(_Contador({}), m, glosario) + assert t.conocidas(["Iron Ingot"], "ui") == {"Iron Ingot": "Lingote de hierro"} + + +def test_lo_que_la_memoria_tiene_como_bueno_se_revalida_con_el_glosario_de_hoy() -> None: + glosario = Glosario() + glosario.fijar({"Wrench": "Llave inglesa"}) + texto = "Use the Wrench on it" + with Memoria(":memory:") as m: + m.guardar({texto: "Usa la herramienta en él"}, "es_mx", "ui", "g") # de antes del término + motor = _Contador({texto: "Usa la Llave inglesa en él"}) + r = Traductor(motor, m, glosario).traducir([texto], "ui") + assert motor.pedidos == [texto] + assert r.traducciones == {texto: "Usa la Llave inglesa en él"} + + +def test_lo_aceptado_con_dudas_en_el_mismo_pack_no_se_vuelve_a_pedir() -> None: + glosario = Glosario() + glosario.fijar({"Wrench": "Llave inglesa"}) + texto = "Use the Wrench on it" + with Memoria(":memory:") as m: + m.guardar({texto: "Usa la herramienta"}, "es_mx", "ui", "g", "A", {texto: "terminología: «Wrench»"}) + motor = _Contador({}) + Traductor(motor, m, glosario, pack="A").traducir([texto], "ui") + assert motor.pedidos == [] + + +def test_los_terminos_de_un_texto_son_los_mismos_que_relevantes() -> None: + glosario = Glosario() + glosario.agregar_pares( + {"a": "Iron Ingot", "b": "Iron", "c": "Furnace", "d": "Blast Furnace"}, + {"a": "Lingote de hierro", "b": "Hierro", "c": "Horno", "d": "Alto horno"}, + fuente="minecraft", + oficial=True, + ) + for texto in ("Smelt an Iron Ingot in a Blast Furnace", "&4Furnace", "Nothing here", "iron and furnaces"): + assert glosario.terminos_en(texto) == glosario.relevantes([texto]) diff --git a/tests/test_paquete.py b/tests/test_paquete.py index 45b647d..72f504e 100644 --- a/tests/test_paquete.py +++ b/tests/test_paquete.py @@ -97,7 +97,7 @@ def test_importar_aplica_sin_llamar_al_motor(tmp_path: Path) -> None: with Memoria(":memory:") as memoria, Proceso(otra, motor, grupos=["mods"], memoria=memoria) as p: resumen, informe = paquete.aplicar(p, destino) assert memoria.correccion("Wrench", "es_mx") == "Llave inglesa" - assert memoria.obtener("Iron Gear", "es_mx", "ui") == "«ES» Iron Gear" + assert memoria.obtener("Iron Gear", "es_mx", "ui", p.pack) == "«ES» Iron Gear" assert resumen.memoria == 2 and resumen.correcciones == 1 and resumen.glosario == 0 assert resumen.conservados == 1 # «Gear» del usuario se queda como estaba assert configuracion.leer_glosario_usuario() == {"Gear": "Rueda dentada", "Plate": "Placa"} @@ -107,6 +107,21 @@ def test_importar_aplica_sin_llamar_al_motor(tmp_path: Path) -> None: assert 'file/Traduccion_ES"' in (otra / "options.txt").read_text("utf-8") +def test_lo_dudoso_viaja_marcado_y_solo_vale_en_el_pack(tmp_path: Path) -> None: + with Memoria(":memory:") as memoria: + destino = _traducir_y_exportar(tmp_path, memoria) + with zipfile.ZipFile(destino) as z: + filas = {f["origen"]: f for f in json.loads(z.read("memoria.json"))} + assert filas["Iron Gear"]["calidad"].startswith("terminología") # «Gear» del glosario quedó sin cumplir + assert "calidad" not in filas["Copper Plate"] + otra = _instancia(tmp_path / "b", nombre="Otro") + with Memoria(":memory:") as memoria, Proceso(otra, SinLlamadas(), grupos=["mods"], memoria=memoria) as p: + paquete.aplicar(p, destino, activar=False) + assert memoria.obtener("Iron Gear", "es_mx", "ui", p.pack) == "«ES» Iron Gear" + assert memoria.obtener("Iron Gear", "es_mx", "ui", "Un tercer pack") is None + assert memoria.obtener("Copper Plate", "es_mx", "ui", "Un tercer pack") is not None + + def test_importar_avisa_si_el_modpack_o_la_version_no_coinciden(tmp_path: Path) -> None: with Memoria(":memory:") as memoria: destino = _traducir_y_exportar(tmp_path, memoria) From 0502530f432e488972de6298d4accf9bdcfb94d5 Mon Sep 17 00:00:00 2001 From: Cristian Date: Sun, 15 Nov 2026 16:41:42 -0500 Subject: [PATCH 2/2] feat(seleccion): perfiles de calidad con verificador a ciegas MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Toda corrección se queda solo si un juez a ciegas la prefiere en los dos órdenes, también la de la revisión de misiones y libros. El perfil equilibrado (por defecto) corrige una vez lo dudoso; el máximo además traduce tres veces lo corto y elige por mayoría o por promedio de rangos, y revisa misiones y libros. Con Gemini 3.8 Flash el consenso no mejoró de forma medible y queda como opción. --- CHANGELOG.md | 5 + README.md | 13 +- docs/calidad.md | 29 ++++ scripts/medir_calidad.py | 8 + src/traductor_es/__main__.py | 16 +- src/traductor_es/motores/simulador.py | 13 +- src/traductor_es/nucleo/traductor.py | 179 +++++++++++++++++++- src/traductor_es/proceso.py | 33 +++- src/traductor_es/ui/ventana.py | 33 +++- src/traductor_es/validacion/chrf.py | 33 ++++ src/traductor_es/validacion/medicion.py | 33 +--- src/traductor_es/validacion/verificacion.py | 71 ++++++++ tests/test_perfiles.py | 114 +++++++++++++ tests/test_revision.py | 2 +- 14 files changed, 526 insertions(+), 56 deletions(-) create mode 100644 src/traductor_es/validacion/chrf.py create mode 100644 src/traductor_es/validacion/verificacion.py create mode 100644 tests/test_perfiles.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 7a55259..ee35d6b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,11 @@ Todos los cambios importantes de ModpackES quedan en este archivo. El formato si ### Agregado +- **Perfiles de calidad** («Calidad» en la ventana y `--calidad` en `analizar` y `traducir`). El análisis estima el costo de cada uno: + - **Equilibrado** (por defecto): después de traducir, lo que quedó con dudas (cifras distintas, un paréntesis sin cerrar, usted, inglés, un término del glosario…) se corrige una vez explicando qué falló. La corrección se queda solo si pasa las reglas y un juez a ciegas la prefiere en los dos órdenes; si no, queda la primera, marcada. Cuesta cerca de un 5 % más. + - **Máximo:** además, cada texto corto (6 palabras o menos: nombres, botones) se traduce tres veces en lotes distintos. Gana la traducción en que coinciden dos; si no coinciden, gana la de mejor promedio entre tres señales (dudas del control de calidad, términos del glosario y parecido con las otras), y el texto queda marcado para revisarlo. También activa la revisión de misiones y libros. Cuesta un 30 % más, más la revisión. Con Gemini 3.8 Flash no mejoró de forma medible (ver [docs/calidad.md](docs/calidad.md)): queda como opción. + - **Económico:** solo los arreglos automáticos, como hasta ahora. +- **La revisión de misiones y libros ya no acepta a ciegas lo que rehace:** la versión nueva tiene que ganarle a la anterior ante un juez que no sabe cuál es cuál, en los dos órdenes. Un modelo que corrige su propia traducción tiende a cambiar cosas que estaban bien. - **Control de calidad determinista** después de cada traducción, con las ideas de las herramientas de QA de la industria y las convenciones del español de Minecraft: - Se arregla solo lo que no tiene riesgo: espacios dobles o antes de la puntuación, caracteres invisibles, una palabra repetida seguida, «¿» y «¡» que faltan en una frase única, el «:» o los «...» finales que se perdieron (el juego escribe «...», no «…»), las comillas del dialecto (es_es «», es_mx "") si el original las tiene, y meses y días con mayúscula a mitad de frase. Los códigos de formato no se tocan. - Queda como duda, para revisarlo: cifras distintas del original (con tolerancia a «1,000» = «1.000» y a las cifras escritas con letras), paréntesis o corchetes sin pareja, formas de usted (el juego tutea), palabras en inglés que quedaron, y frases que se perdieron. diff --git a/README.md b/README.md index 5268e96..2e9cc3c 100644 --- a/README.md +++ b/README.md @@ -86,10 +86,19 @@ El campo **Ambientación** (opcional) le cuenta al motor de qué va el modpack: amable; “Bells” es la moneda del pueblo». Ayuda con el tono y con los términos propios del pack, y se guarda por instancia. +**Calidad** (en «Opciones avanzadas» y `--calidad`): +- **Equilibrado**, el perfil por defecto: lo que quedó con dudas se corrige una vez. La corrección se queda solo si + un juez a ciegas la prefiere. Cuesta cerca de un 5 % más. +- **Máximo:** además, cada texto corto se traduce tres veces y se elige por consenso, y se revisan misiones y libros. + Cuesta un 30 % más, más la revisión. Con Gemini 3.8 Flash no mejoró de forma medible: es una opción para + modelos que dudan más. +- **Económico:** solo los arreglos automáticos. + **Revisión automática** (opcional, en «Opciones avanzadas», solo misiones y libros): después de traducir, otro pedido al motor juzga cada traducción nueva al estilo de [GEMBA-MQM](https://aclanthology.org/2023.wmt-1.64) (exactitud, terminología, fluidez y estilo, con gravedad leve, grave o crítica) y las graves se vuelven a -traducir indicando el error. La nueva traducción tiene que pasar las mismas reglas; si no, queda la anterior. +traducir indicando el error. La nueva traducción tiene que pasar las mismas reglas y ganarle a la anterior ante +un juez a ciegas, en los dos órdenes; si no, queda la anterior. Tus correcciones nunca se revisan. Sube el costo de esos textos (el análisis lo incluye) y sus marcas no son infalibles: sirven para decidir qué rehacer, no como nota de calidad. @@ -224,7 +233,7 @@ Desde el código fuente (ver [Desarrollo](#desarrollo)): uv run modpackes instancias uv run modpackes analizar "RUTA DE LA INSTANCIA" uv run modpackes cambios "RUTA" [--json] # qué cambió desde la última traducción y cuánto cuesta (solo lee) -uv run modpackes traducir "RUTA" [--dialecto es_es | --tambien-es-es] [--solo misiones,libros] [--lotes] [--modelo gemini-3.5-flash-lite] [--contexto "granja acogedora"] [--revisar] +uv run modpackes traducir "RUTA" [--dialecto es_es | --tambien-es-es] [--solo misiones,libros] [--lotes] [--modelo gemini-3.5-flash-lite] [--contexto "granja acogedora"] [--revisar] [--calidad economico|equilibrado|maximo] uv run modpackes restaurar "RUTA" uv run modpackes cobertura "RUTA" [--java] # qué queda en inglés y por qué (solo lee) uv run modpackes glosario listar | agregar "Death Knights" "Caballeros de la Muerte" | quitar "Fluix" | importar terminos.json diff --git a/docs/calidad.md b/docs/calidad.md index 38b8775..ab0fa10 100644 --- a/docs/calidad.md +++ b/docs/calidad.md @@ -518,6 +518,35 @@ Para medirlo, una copia del banco de interfaz lleva las pistas nuevas, calculada - **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. +## 15 de noviembre de 2026 · perfiles de calidad: corregir lo dudoso y el consenso de lo corto + +Hay tres perfiles: económico, equilibrado y máximo. En los perfiles equilibrado y máximo, toda corrección se queda +solo si un juez a ciegas (el mismo modelo, tarea «comparar», con los códigos enmascarados) prefiere la versión nueva +en los dos órdenes (`validacion/verificacion.py`). Eso vale también para la revisión de misiones y libros, que antes +aceptaba lo rehecho sin juzgarlo. + +**Equilibrado** (corrige una vez lo dudoso): en la interfaz no hubo nada dudoso. En misiones actuó en un texto por +corrida: +- en una corrida, el juez prefirió la corrección («ítem» como el es_mx del juego, y la misma cifra que el original); +- en la otra, se quedó la primera. + +El costo extra fueron unos 3 pedidos chicos por banco. + +**Máximo** (tres traducciones de cada texto de 6 palabras o menos, elegidas por consenso). Gemini 3.8 Flash, dos +corridas, US$ 0,11: + +| | Interfaz | +|---|---| +| chrF, económico contra máximo | 75,6 contra 75,7: +0,09 (IC −0,38 a +0,60), no se distingue del ruido | +| Textos que cambiaron | 41 y 42 de 390 | +| Juez a ciegas en los dos órdenes | gana el máximo 37 veces, el económico 32 y 14 empates (p ≈ 0,6 y 0,19) | +| Costo de la traducción | 1,2 veces el económico | + +- Con este modelo, las tres traducciones casi siempre coinciden. Cuando no coinciden, la elegida cambia la + redacción («adyacente» por «contiguo», «Unificador» por «Convergente») y no el sentido. +- Coincide con la investigación: elegir entre salidas ayuda sobre todo cuando el modelo duda más. Por eso el + máximo queda como opción y el perfil por defecto es el equilibrado. + ## Cómo repetirlo ``` diff --git a/scripts/medir_calidad.py b/scripts/medir_calidad.py index e63633a..54a905a 100644 --- a/scripts/medir_calidad.py +++ b/scripts/medir_calidad.py @@ -22,6 +22,7 @@ from traductor_es.motores.grabadora import MotorGrabado from traductor_es.motores.simulador import Simulador from traductor_es.nucleo.ejemplos import CANTIDAD_EN_LA_APP +from traductor_es.nucleo.traductor import ECONOMICO, PERFILES from traductor_es.validacion import medicion RAIZ = Path(__file__).resolve().parent.parent @@ -111,6 +112,12 @@ def main(argv: list[str] | None = None) -> int: help="corridas independientes (cada una con su grabación); la salida lleva _1, _2… en el nombre", ) ap.add_argument("--simular", action="store_true", help="sin API: solo comprueba que todo funcione") + ap.add_argument( + "--calidad", + choices=PERFILES, + default=ECONOMICO, + help="perfil de calidad (por defecto economico, para comparar con las mediciones anteriores)", + ) ap.add_argument("--banco", type=Path, default=RAIZ / "tests" / "datos" / "referencia_es.json") ap.add_argument("--salida", type=Path, default=RAIZ / "build" / "medicion.json") args = ap.parse_args(argv) @@ -148,6 +155,7 @@ def main(argv: list[str] | None = None) -> int: hilos=args.hilos or (1 if args.carga_segura else 4), cantidad_ejemplos=args.n_ejemplos, controles_de_forma=not args.sin_controles, + perfil=args.calidad, ) for m in resultados: print(m.tabla(), end="\n\n") diff --git a/src/traductor_es/__main__.py b/src/traductor_es/__main__.py index ea27a7c..00456b6 100644 --- a/src/traductor_es/__main__.py +++ b/src/traductor_es/__main__.py @@ -23,6 +23,7 @@ from .motores.simulador import Simulador from .nucleo.dialectos import DIALECTOS from .nucleo.memoria import Memoria +from .nucleo.traductor import PERFIL_POR_DEFECTO, PERFILES from .proceso import GRUPOS, Informe, Proceso from .registro import LOGGER, configurar from .salida import exportar, mod_apoyo, paquete @@ -52,7 +53,7 @@ def _mostrar(informe: Informe, args: argparse.Namespace) -> None: linea = f" {m.nombre}: {m.descripcion} — {m.textos} textos, {m.a_traducir} para el motor ({m.caracteres} car.)" _escribir(linea + (f"\n {m.resumen}" if m.resumen else "")) modelo, lotes = _modelo(args), args.lotes - costo = informe.costo(modelo, lotes, args.motor, args.revisar) + costo = informe.costo(modelo, lotes, args.motor, args.revisar, getattr(args, "calidad", PERFIL_POR_DEFECTO)) _escribir(f"Total para el motor: {informe.a_traducir} textos, {informe.caracteres} caracteres") if costo is not None: _escribir(f"Costo estimado con {modelo}{' (por lotes)' if lotes else ''}: US$ {costo:.2f}") @@ -93,6 +94,16 @@ def comunes(p: argparse.ArgumentParser) -> None: p.add_argument("--lotes", action="store_true", help="usar la Batch API de Gemini (mitad de precio, tarda más)") p.add_argument("--contexto", default="", help="ambientación del modpack para el tono y los términos") p.add_argument("--revisar", action="store_true", help="revisión automática de misiones y libros (cuesta más)") + p.add_argument( + "--calidad", + choices=PERFILES, + default=PERFIL_POR_DEFECTO, + help=( + "economico: solo arreglos automáticos; equilibrado (por defecto): además corrige lo dudoso si un " + "juez a ciegas lo prefiere (≈ +5 %%); maximo: además traduce tres veces lo corto y revisa misiones " + "y libros (≈ +30 %% más la revisión)" + ), + ) p.add_argument( "--exhaustivo", action="store_true", @@ -177,6 +188,7 @@ def _traducir_o_analizar(args: argparse.Namespace) -> None: Proceso( args.carpeta, motor, args.dialecto, grupos, memoria=memoria, registro=_escribir, hilos=getattr(args, "hilos", 4), usar_lotes=args.lotes, contexto=args.contexto, revisar=args.revisar, + calidad=getattr(args, "calidad", PERFIL_POR_DEFECTO), texto_java=args.java, scripts_exhaustivo=args.exhaustivo, tambien_es_es=args.tambien_es_es, ) as p, @@ -296,7 +308,7 @@ def _cambios(args: argparse.Namespace) -> None: cambios = informe.cambios or Cambios() diferencia = informe.diferencia modelo = _modelo(args) - costo = diferencia.costo(modelo, args.lotes, args.motor, args.revisar) + costo = diferencia.costo(modelo, args.lotes, args.motor, args.revisar, getattr(args, "calidad", PERFIL_POR_DEFECTO)) if args.json: datos = { "base": cambios.base, "fecha": cambios.fecha, "nuevas": cambios.nuevas, "cambiadas": cambios.cambiadas, diff --git a/src/traductor_es/motores/simulador.py b/src/traductor_es/motores/simulador.py index e6bed25..9ca19db 100644 --- a/src/traductor_es/motores/simulador.py +++ b/src/traductor_es/motores/simulador.py @@ -1,7 +1,7 @@ """Motor falso para probar todo sin gastar: antepone «ES» y, si se pide, daña textos a propósito. Para probar la revisión: marca como «grave» las traducciones de `marcar` y, cuando una pista pide corregir, antepone -«ES*» en vez de «ES». +«ES*» en vez de «ES». Como juez («comparar»), con `marcar` prefiere la versión corregida («ES*»); si no, dice «igual». """ from __future__ import annotations @@ -35,6 +35,17 @@ def traducir_lote(self, lote: Lote) -> dict[str, str]: e.id: "grave|exactitud|marcado por la prueba" if e.traduccion in self.marcar else "OK" for e in lote.entradas } + if lote.tarea == "comparar": + return { + e.id: "igual" + if not self.marcar + else "A" + if "«ES*»" in e.traduccion + else "B" + if "«ES*»" in e.alternativa + else "igual" + for e in lote.entradas + } salida: dict[str, str] = {} for e in lote.entradas: prefijo = "«ES*» " if "revisión" in e.pista else self.prefijo diff --git a/src/traductor_es/nucleo/traductor.py b/src/traductor_es/nucleo/traductor.py index 85ace53..2760e5e 100644 --- a/src/traductor_es/nucleo/traductor.py +++ b/src/traductor_es/nucleo/traductor.py @@ -2,6 +2,7 @@ from __future__ import annotations +import random import re import threading from collections import Counter @@ -11,7 +12,7 @@ from typing import cast from ..motores.base import Cancelado, Entrada, Lote, Motor, MotorPorLotes -from ..validacion import qa +from ..validacion import qa, verificacion from ..validacion.calidad import ( ajustar_mayusculas, palabra_repetida, @@ -19,6 +20,7 @@ sin_traducir, terminos_faltantes, ) +from ..validacion.chrf import chrf from . import terminos from .dialectos import DIALECTO_POR_DEFECTO, DIALECTOS from .ejemplos import Ejemplos @@ -54,6 +56,26 @@ 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: " +#: Perfiles de calidad: cuánto se verifica después de traducir (ver `Traductor.perfil`). +ECONOMICO, EQUILIBRADO, MAXIMO = "economico", "equilibrado", "maximo" +PERFILES = (ECONOMICO, EQUILIBRADO, MAXIMO) +#: El de la app: una corrección verificada solo de lo dudoso. +PERFIL_POR_DEFECTO = EQUILIBRADO +#: En el perfil máximo, los textos de hasta estas palabras se traducen tres veces y se elige por consenso. +PALABRAS_CORTO = 6 +#: Cuántas traducciones más se piden de cada texto corto en el perfil máximo. +MUESTRAS_EXTRA = 2 +#: Lo que se marca cuando las tres traducciones de un texto corto no coinciden. +MOTIVO_INCIERTO = "incierto: las traducciones no coinciden" +#: Lo que se le explica al motor al corregir un texto que el control de calidad marcó. +_EXPLICACION_QA = { + "numeros": "las cifras no coinciden con las del original", + "pareja": "un paréntesis, corchete o comilla quedó sin su pareja", + "usted": "usa «usted»; el juego tutea al jugador", + "ingles": "quedaron palabras en inglés sin traducir", + "omision": "parece que falta una parte del original", + "signo_apertura": "falta el signo de apertura ¿ o ¡", +} #: 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." @@ -64,6 +86,21 @@ _FRASE = re.compile(r"[^.!?\n]*[.!?]?") +def _explicar(motivo: str) -> str: + """El motivo de una duda en palabras para el motor («control de calidad: numeros» → «las cifras no…»).""" + if motivo.startswith(MOTIVO_QA): + codigos = [c.strip() for c in motivo.removeprefix(MOTIVO_QA).split(",")] + return "; ".join(_EXPLICACION_QA.get(c, c) for c in codigos) + return motivo + + +def _rango(valores: list[float] | list[int], i: int) -> float: + """El rango (1 = mejor, el valor más bajo) de `valores[i]`; los empates comparten el rango promedio.""" + menores = sum(1 for v in valores if v < valores[i]) + iguales = sum(1 for v in valores if v == valores[i]) + return menores + (iguales + 1) / 2 + + 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.""" @@ -121,6 +158,10 @@ class Resultado: dudosos: dict[str, str] = field(default_factory=dict[str, str]) #: Arreglos automáticos del control de calidad (código → cuántos), p. ej. «signo_apertura»: 3 arreglos: Counter[str] = field(default_factory=Counter[str]) + #: Textos que se cambiaron después de traducir porque un juez a ciegas prefirió la versión nueva + corregidos: int = 0 + #: Textos cortos en que se cambió la primera traducción por la del consenso (perfil máximo) + elegidos: int = 0 class Traductor: @@ -143,9 +184,12 @@ def __init__( glosario_estricto: bool = True, controles_de_forma: bool = True, pack: str = SIN_PACK, + perfil: str = ECONOMICO, ) -> None: if dialecto not in DIALECTOS: raise ValueError(f"Dialecto desconocido: {dialecto}") + if perfil not in PERFILES: + raise ValueError(f"Perfil de calidad desconocido: {perfil}") self.motor = motor self.memoria = memoria self.glosario = glosario @@ -169,6 +213,10 @@ def __init__( self.controles_de_forma = controles_de_forma #: El modpack que se traduce: lo dudoso que se guarda en la memoria solo se reutiliza en él self.pack = pack + #: «economico»: solo los arreglos deterministas. «equilibrado»: además, una corrección de lo dudoso que se + #: queda solo si un juez a ciegas la prefiere. «maximo»: además, los textos cortos se traducen tres veces + #: y se elige por consenso. + self.perfil = perfil self._lock = threading.Lock() # ------------------------------------------------------------------ consulta @@ -261,6 +309,10 @@ def traducir(self, textos: Iterable[str], ambito: str, pistas: Mapping[str, str] if resultado.rechazados: n = len(resultado.rechazados) self.registro(f"{n} textos se quedan en inglés porque no pasaron la validación.") + if self.perfil == MAXIMO and not self.cancelar.is_set(): + self._consenso_de_cortos(resultado, ambito, pistas) + if self.perfil != ECONOMICO and resultado.dudosos and not self.cancelar.is_set(): + self._corregir_dudosos(resultado, ambito, pistas) if resultado.dudosos: self.registro(f"{len(resultado.dudosos)} textos se aceptaron con dudas (términos o repeticiones).") resultado.traducciones = self.conocidas(unicos, ambito) @@ -349,8 +401,10 @@ def _ronda( informar: bool = True, por_lotes: bool = True, tolerante: bool = False, + guardar: bool = True, ) -> set[str]: - """Traduce una ronda. Devuelve los núcleos que fallaron.""" + """Traduce una ronda. Devuelve los núcleos que fallaron. Sin `guardar`, lo traducido no va a la memoria + (para elegir antes entre varias versiones).""" fallidos: set[str] = set() hechos = 0 total = len(nucleos) @@ -369,7 +423,8 @@ def _ronda( raise Cancelado() lote = futuros[fut] buenos = fut.result() - self._guardar(buenos, ambito, resultado) + if guardar: + self._guardar(buenos, ambito, resultado) fallidos.update(n for n in lote if n not in buenos) hechos += len(lote) progreso(hechos, total) @@ -554,18 +609,124 @@ def _reparar( return final, motivo # ------------------------------------------------------------------ revisión - def rehacer(self, motivos: Mapping[str, tuple[str, str]], ambito: str, pistas: Mapping[str, str]) -> dict[str, str]: + def rehacer( + self, motivos: Mapping[str, tuple[str, str]], ambito: str, pistas: Mapping[str, str], verificar: bool = True + ) -> dict[str, str]: """Vuelve a traducir núcleos que una revisión marcó, aunque estén en la memoria. `motivos` es {núcleo: (traducción anterior, motivo)}. La nueva traducción reemplaza a la anterior en la - memoria solo si pasa las mismas reglas; si no, queda la anterior. Devuelve las que cambiaron. + memoria solo si pasa las mismas reglas y, con `verificar`, si un juez a ciegas la prefiere en los dos órdenes; + si no, queda la anterior. Devuelve las que cambiaron. """ + return self._rehacer(motivos, ambito, pistas, verificar)[0] + + def _rehacer( + self, motivos: Mapping[str, tuple[str, str]], ambito: str, pistas: Mapping[str, str], verificar: bool = True + ) -> tuple[dict[str, str], Resultado]: + resultado = Resultado() if not motivos: - return {} + return {}, resultado pistas_nuevas: dict[str, str] = {} for n, (anterior, motivo) in motivos.items(): aviso = f"Una revisión marcó la traducción anterior («{anterior}»): {motivo}. Corrígela." pistas_nuevas[n] = f"{pistas[n]} · {aviso}" if pistas.get(n) else aviso - resultado = Resultado() - self._ronda(sorted(motivos), ambito, pistas_nuevas, (1500, 10), resultado, informar=False, por_lotes=False) - return {n: t for n, t in resultado.nuevas.items() if t != motivos[n][0]} + self._ronda( + sorted(motivos), + ambito, + pistas_nuevas, + (1500, 10), + resultado, + informar=False, + por_lotes=False, + guardar=False, + ) + cambiadas = {n: t for n, t in resultado.nuevas.items() if t != motivos[n][0]} + if verificar and cambiadas: + casos = [(n, pistas.get(n, ""), motivos[n][0], t) for n, t in cambiadas.items()] + ganan = verificacion.gana_la_nueva( + self.motor, self.dialecto, ambito, casos, self.glosario.relevantes(cambiadas), self.contexto, self.hilos + ) + cambiadas = {caso[0]: caso[3] for caso, gana in zip(casos, ganan, strict=True) if gana} + self._guardar(cambiadas, ambito, resultado) + return cambiadas, resultado + + def _corregir_dudosos(self, resultado: Resultado, ambito: str, pistas: Mapping[str, str]) -> None: + """Perfil equilibrado: una sola corrección de lo que se aceptó con dudas, explicando qué falló. Se queda solo + si pasa las reglas y un juez a ciegas la prefiere; si no, queda la primera (marcada).""" + candidatos = { + n: (resultado.nuevas[n], _explicar(m)) + for n, m in resultado.dudosos.items() + if n in resultado.nuevas and m not in (MOTIVO_NOMBRE, MOTIVO_INCIERTO) + } + if not candidatos: + return + self.registro( + f"Corrigiendo {len(candidatos)} textos dudosos (solo se cambian si un juez a ciegas lo prefiere)…" + ) + cambiadas, nuevo = self._rehacer(candidatos, ambito, pistas) + for n, t in cambiadas.items(): + resultado.nuevas[n] = t + if n in nuevo.dudosos: + resultado.dudosos[n] = nuevo.dudosos[n] + else: + resultado.dudosos.pop(n, None) + resultado.corregidos += len(cambiadas) + if cambiadas: + self.registro(f"{len(cambiadas)} textos dudosos quedaron corregidos.") + + def _consenso_de_cortos(self, resultado: Resultado, ambito: str, pistas: Mapping[str, str]) -> None: + """Perfil máximo: los textos cortos (nombres, botones) se traducen dos veces más, en otro orden, y se elige. + + Si dos de las tres coinciden, gana esa. Si no, gana la de mejor promedio de rangos entre tres señales (dudas + del control de calidad, términos del glosario que faltan y parecido con las otras dos), nunca una sola, y el + texto queda marcado como incierto para revisarlo. + """ + cortos = [n for n in resultado.nuevas if len(n.split()) <= PALABRAS_CORTO and n not in resultado.dudosos] + if not cortos: + return + self.registro(f"Traduciendo {len(cortos)} textos cortos dos veces más para elegir por consenso…") + muestras: list[Resultado] = [] + for k in range(MUESTRAS_EXTRA): + orden = list(cortos) + random.Random(k + 1).shuffle(orden) # otro orden: otros vecinos en el lote y otra muestra del modelo + muestra = Resultado() + self._ronda( + orden, ambito, pistas, (self.limite_caracteres, self.limite_entradas), muestra, + informar=False, por_lotes=False, guardar=False, + ) # fmt: skip + muestras.append(muestra) + cambiadas: dict[str, str] = {} + dudas: dict[str, str] = {} + for n in cortos: + opciones = [resultado.nuevas[n], *(m.nuevas[n] for m in muestras if n in m.nuevas)] + if len(opciones) < 2: + continue + elegida, hay_mayoria = self._elegir(n, opciones) + if not hay_mayoria: + dudas[n] = MOTIVO_INCIERTO + if elegida != resultado.nuevas[n]: + cambiadas[n] = elegida + resultado.nuevas.update(cambiadas) + resultado.dudosos.update(dudas) + resultado.elegidos += len(cambiadas) + self.memoria.guardar( + {n: resultado.nuevas[n] for n in {*cambiadas, *dudas}}, self.dialecto, ambito, self.motor.nombre, + self.pack, {n: resultado.dudosos[n] for n in {*cambiadas, *dudas} if n in resultado.dudosos}, + ) # fmt: skip + + def _elegir(self, original: str, opciones: list[str]) -> tuple[str, bool]: + """La traducción de la mayoría, o la de mejor promedio de rangos si no hay mayoría. (elegida, hubo mayoría).""" + conteo = Counter(opciones) + mas_votada, votos = conteo.most_common(1)[0] + if votos >= 2: + return mas_votada, True + terminos = self.glosario.terminos_en(original) + ambiguos = self.glosario.ambiguos(terminos) + senales = [ + [len(qa.dudas(qa.revisar(original, o, dialecto=self.dialecto)[1])) for o in opciones], + [len(terminos_faltantes(original, o, terminos, ambiguos)) for o in opciones], + [-sum(chrf(o, otra) for otra in opciones if otra is not o) for o in opciones], + ] + promedio = [sum(_rango(senal, i) for senal in senales) / len(senales) for i in range(len(opciones))] + mejor = min(range(len(opciones)), key=lambda i: (promedio[i], i)) # empate: la primera traducción + return opciones[mejor], False diff --git a/src/traductor_es/proceso.py b/src/traductor_es/proceso.py index 633829c..874a60c 100644 --- a/src/traductor_es/proceso.py +++ b/src/traductor_es/proceso.py @@ -30,7 +30,7 @@ from .nucleo.glosario import Glosario from .nucleo.mascara import separar_bordes from .nucleo.memoria import Memoria -from .nucleo.traductor import Resultado, Traductor +from .nucleo.traductor import ECONOMICO, EQUILIBRADO, MAXIMO, PERFIL_POR_DEFECTO, Resultado, Traductor from .nucleo.vocabulario import agregar_vocabulario, preparar_sustituciones from .salida import opciones as opciones_salida from .salida.copias import Respaldo @@ -93,8 +93,18 @@ def a_traducir(self) -> int: def caracteres(self) -> int: return sum(m.caracteres for m in self.modulos) - def costo(self, modelo: str, por_lotes: bool, motor: str = fabrica.GEMINI, revisar: bool = False) -> float | None: - """Costo estimado en US$: 0 con un motor en el PC; None si no se conoce el precio del modelo.""" + def costo( + self, + modelo: str, + por_lotes: bool, + motor: str = fabrica.GEMINI, + revisar: bool = False, + calidad: str = ECONOMICO, + ) -> float | None: + """Costo estimado en US$: 0 con un motor en el PC; None si no se conoce el precio del modelo. + + `calidad` es el perfil (ver `Traductor.perfil`): el máximo incluye la revisión de misiones y libros. + """ if fabrica.es_local(motor): return 0.0 precio = PRECIOS.get(modelo) if motor == fabrica.GEMINI else None @@ -102,7 +112,8 @@ def costo(self, modelo: str, por_lotes: bool, motor: str = fabrica.GEMINI, revis return None total = _costo_traduccion(self.caracteres, self.a_traducir, precio) total = total / 2 if por_lotes else total - if revisar: # la revisión va en modo normal aunque la traducción vaya por lotes + total *= _COSTO_DEL_PERFIL.get(calidad, 1.0) + if revisar or calidad == MAXIMO: # la revisión va en modo normal aunque la traducción vaya por lotes revisados = [m for m in self.modulos if m.grupo in GRUPOS_REVISADOS] caracteres = sum(m.caracteres for m in revisados) textos = sum(m.a_traducir for m in revisados) @@ -113,6 +124,11 @@ def costo(self, modelo: str, por_lotes: bool, motor: str = fabrica.GEMINI, revis return total +#: Cuánto más cuesta la traducción con cada perfil, medido con Gemini 3.8 Flash: lo dudoso es poco, y el máximo +#: traduce tres veces lo corto (que pesa poco). La revisión de misiones y libros del máximo se suma aparte. +_COSTO_DEL_PERFIL = {ECONOMICO: 1.0, EQUILIBRADO: 1.05, MAXIMO: 1.3} + + def _grupo_del_indice(grupo: str, modulo: Modulo) -> str: """El grupo con que el módulo va al índice. El texto del código de los mods es opcional (`--java`): va aparte, para que una ejecución sin `--java` no lo borre del índice ni lo cuente como borrado.""" @@ -222,9 +238,12 @@ def __init__( texto_java: bool = False, scripts_exhaustivo: bool = False, tambien_es_es: bool = False, + calidad: str = PERFIL_POR_DEFECTO, ) -> None: self.instancia = Instancia(carpeta) - self.revisar = revisar + #: Perfil de calidad (ver `Traductor.perfil`); el máximo incluye la revisión de misiones y libros + self.calidad = calidad + self.revisar = revisar or calidad == MAXIMO self.texto_java = texto_java self.scripts_exhaustivo = scripts_exhaustivo self.registro = registro @@ -245,7 +264,7 @@ def __init__( self.traductor = Traductor( motor, self.memoria, self.glosario, dialecto, hilos, progreso, registro, cancelar, validar, usar_lotes=usar_lotes, contexto=contexto, ejemplos=self.ejemplos, - limite_caracteres=limites[0], limite_entradas=limites[1], pack=self.pack, + limite_caracteres=limites[0], limite_entradas=limites[1], pack=self.pack, perfil=calidad, ) # fmt: skip self.motor = motor if isinstance(motor, Compatible): @@ -286,7 +305,7 @@ def _crear_espana(self) -> None: traductor_es = Traductor( self.motor, self.memoria, glosario_es, DIALECTO_ESPANA, t.hilos, t.progreso, t.registro, t.cancelar, validar, usar_lotes=t.usar_lotes, contexto=t.contexto, ejemplos=ejemplos_es, - limite_caracteres=t.limite_caracteres, limite_entradas=t.limite_entradas, pack=t.pack, + limite_caracteres=t.limite_caracteres, limite_entradas=t.limite_entradas, pack=t.pack, perfil=t.perfil, ) # fmt: skip self._espana = _Pasada(ctx_es, glosario_es, ejemplos_es, traductor_es) diff --git a/src/traductor_es/ui/ventana.py b/src/traductor_es/ui/ventana.py index 772ade8..81333d3 100644 --- a/src/traductor_es/ui/ventana.py +++ b/src/traductor_es/ui/ventana.py @@ -56,7 +56,7 @@ from ..motores.compatible import Compatible from ..motores.gemini import MODELO_POR_DEFECTO, PRECIOS from ..motores.simulador import Simulador -from ..nucleo.traductor import LARGO_CONTEXTO +from ..nucleo.traductor import ECONOMICO, EQUILIBRADO, LARGO_CONTEXTO, MAXIMO, PERFIL_POR_DEFECTO from ..proceso import DIALECTO_ESPANA, ETIQUETA_ESPANA, GRUPOS, Informe, Proceso from ..salida import exportar, mod_apoyo, paquete from . import correcciones, iconos, tema @@ -76,6 +76,13 @@ from .instancias import Lector, ListaInstancias, traducida from .motor import DialogoMotor +#: Los perfiles de calidad como se ven en la ventana. +_PERFILES = { + EQUILIBRADO: "Equilibrado (recomendado): corrige lo dudoso", + MAXIMO: "Máximo: traduce lo corto tres veces y revisa misiones y libros (cuesta más)", + ECONOMICO: "Económico: solo los arreglos automáticos", +} + #: (motor, clave, modelo, dirección) → motor listo para traducir FabricaMotor = Callable[[str, str | None, str, str], Motor] #: grupo → (título, ícono, qué abarca) @@ -172,6 +179,7 @@ def ejecutar(self) -> None: usar_lotes=self.opciones["lotes"], contexto=self.opciones["contexto"], revisar=self.opciones["revisar"], + calidad=self.opciones["calidad"], texto_java=self.opciones["texto_java"], scripts_exhaustivo=self.opciones["exhaustivo"], tambien_es_es=self.opciones["tambien_es_es"], @@ -292,6 +300,7 @@ def _construir(self) -> None: for senal in ( self.c_lotes.toggled, self.c_revisar.toggled, + self.c_calidad.currentIndexChanged, self.c_activar.toggled, self.c_java.toggled, self.c_exhaustivo.toggled, @@ -490,6 +499,18 @@ def _opciones_avanzadas(self) -> QWidget: self.c_lotes.setToolTip("Usa la Batch API de Google: solo con Gemini") self.c_lotes.setChecked(bool(self._preferencias.get("lotes", False))) formulario.addRow("", self.c_lotes) + self.c_calidad = QComboBox() + for perfil, texto in _PERFILES.items(): + self.c_calidad.addItem(texto, perfil) + self.c_calidad.setToolTip( + "Equilibrado: después de traducir, lo que quedó con dudas se corrige una vez y la corrección se queda solo " + "si un juez a ciegas la prefiere (cuesta un poco más). Máximo: además, los textos cortos se traducen " + "tres veces y se elige por consenso, y se revisan misiones y libros (cuesta un 30 % más y la revisión). " + "Económico: solo los arreglos automáticos." + ) + indice = self.c_calidad.findData(self._preferencias.get("calidad", PERFIL_POR_DEFECTO)) + self.c_calidad.setCurrentIndex(max(0, indice)) + formulario.addRow("Calidad:", self.c_calidad) self.c_revisar = QCheckBox("Revisar misiones y libros, y rehacer lo que tenga errores graves") self.c_revisar.setToolTip( "Otro pedido al motor juzga cada traducción nueva de misiones y libros; las que tengan errores graves se " @@ -856,7 +877,7 @@ def _texto_costo(self) -> str: con_espana = any(m.nombre.endswith(ETIQUETA_ESPANA) for m in informe.modulos) if o["tambien_es_es"] and not con_espana: texto += " Vuelve a analizar para sumar la versión de España." - costo = informe.costo(o["modelo"], o["lotes"], o["motor"], o["revisar"]) + costo = informe.costo(o["modelo"], o["lotes"], o["motor"], o["revisar"], o["calidad"]) if fabrica.es_local(o["motor"]): texto += " Sin costo: el modelo corre en tu PC." elif costo is not None: @@ -873,7 +894,7 @@ def _texto_traducir(self) -> str: if informe is None or not informe.a_traducir: return "Aplicar la traducción (ya está en la memoria)" o = self.opciones() - costo = informe.costo(o["modelo"], o["lotes"], o["motor"], o["revisar"]) + costo = informe.costo(o["modelo"], o["lotes"], o["motor"], o["revisar"], o["calidad"]) precio = "" if costo is None else " · gratis" if costo == 0 else f" · {_dinero(costo)}" return f"Traducir {_miles(informe.a_traducir)} textos{precio}" @@ -927,6 +948,7 @@ def opciones(self) -> dict[str, Any]: "idioma": self.c_activar.isChecked(), "contexto": self.e_contexto.text().strip(), "revisar": self.c_revisar.isChecked(), + "calidad": str(self.c_calidad.currentData() or PERFIL_POR_DEFECTO), "texto_java": self.c_java.isChecked(), "exhaustivo": self.c_exhaustivo.isChecked(), "tambien_es_es": self.c_espana.isChecked() and self.c_espana.isEnabled(), @@ -945,7 +967,7 @@ def _confirmar_traducir(self) -> None: informe = self.informe_elegido() if informe is not None: o = self.opciones() - costo = informe.costo(o["modelo"], o["lotes"], o["motor"], o["revisar"]) + costo = informe.costo(o["modelo"], o["lotes"], o["motor"], o["revisar"], o["calidad"]) if costo is not None: texto = f"Costo estimado: {_dinero(costo)}.\n\n" + texto if self._preguntar("Traducir", texto): @@ -1327,7 +1349,8 @@ def _guardar_preferencias(self, carpeta: str) -> None: "carpeta": carpeta, "dialecto": o["dialecto"], "grupos": o["grupos"], "motor": o["motor"], "modelo": modelos.get(fabrica.GEMINI, MODELO_POR_DEFECTO), "modelos": modelos, "direcciones": direcciones, "lotes": o["lotes"], "hilos": o["hilos"], "contextos": contextos, - "revisar": o["revisar"], "texto_java": o["texto_java"], "exhaustivo": o["exhaustivo"], + "revisar": o["revisar"], "calidad": o["calidad"], "texto_java": o["texto_java"], + "exhaustivo": o["exhaustivo"], "tambien_es_es": self.c_espana.isChecked(), "avisar_version": self.c_avisar.isChecked(), "tema": self._preferencias.get("tema", "sistema"), diff --git a/src/traductor_es/validacion/chrf.py b/src/traductor_es/validacion/chrf.py new file mode 100644 index 0000000..d5fe757 --- /dev/null +++ b/src/traductor_es/validacion/chrf.py @@ -0,0 +1,33 @@ +"""chrF de una oración (Popović, 2015): parecido entre dos textos por n-gramas de caracteres.""" + +from __future__ import annotations + +import re +from collections import Counter + +_N_MAXIMO, _BETA = 6, 2.0 + + +def _ngramas(texto: str, n: int) -> Counter[str]: + sin_espacios = re.sub(r"\s+", "", texto) + return Counter(sin_espacios[i : i + n] for i in range(len(sin_espacios) - n + 1)) + + +def chrf(hipotesis: str, referencia: str) -> float: + """chrF de una oración (0 a 100): F-beta (beta 2) de n-gramas de caracteres de 1 a 6, sin espacios.""" + precisiones: list[float] = [] + recalls: list[float] = [] + for n in range(1, _N_MAXIMO + 1): + h, r = _ngramas(hipotesis, n), _ngramas(referencia, n) + if not h or not r: + continue + comunes = sum((h & r).values()) + precisiones.append(comunes / sum(h.values())) + recalls.append(comunes / sum(r.values())) + if not precisiones: + return 100.0 if hipotesis.strip() == referencia.strip() else 0.0 + p, r = sum(precisiones) / len(precisiones), sum(recalls) / len(recalls) + if p == 0 and r == 0: + return 0.0 + b2 = _BETA**2 + return 100 * (1 + b2) * p * r / (b2 * p + r) diff --git a/src/traductor_es/validacion/medicion.py b/src/traductor_es/validacion/medicion.py index 549880f..98359ca 100644 --- a/src/traductor_es/validacion/medicion.py +++ b/src/traductor_es/validacion/medicion.py @@ -28,13 +28,12 @@ from ..nucleo.glosario import Glosario from ..nucleo.mascara import sin_formato from ..nucleo.memoria import Memoria -from ..nucleo.traductor import MOTIVO_QA, Traductor +from ..nucleo.traductor import ECONOMICO, MOTIVO_QA, Traductor from ..nucleo.vocabulario import agregar_vocabulario, preparar_sustituciones from ..proceso import Informe, InformeModulo from . import revision from .calidad import sale_el_termino, validar - -_N_MAXIMO, _BETA = 6, 2.0 +from .chrf import chrf @dataclass(frozen=True, slots=True) @@ -79,31 +78,6 @@ def leer(cls, ruta: Path) -> Banco: ) -def _ngramas(texto: str, n: int) -> Counter[str]: - sin_espacios = re.sub(r"\s+", "", texto) - return Counter(sin_espacios[i : i + n] for i in range(len(sin_espacios) - n + 1)) - - -def chrf(hipotesis: str, referencia: str) -> float: - """chrF de una oración (0 a 100): F-beta (beta 2) de n-gramas de caracteres de 1 a 6, sin espacios.""" - precisiones: list[float] = [] - recalls: list[float] = [] - for n in range(1, _N_MAXIMO + 1): - h, r = _ngramas(hipotesis, n), _ngramas(referencia, n) - if not h or not r: - continue - comunes = sum((h & r).values()) - precisiones.append(comunes / sum(h.values())) - recalls.append(comunes / sum(r.values())) - if not precisiones: - return 100.0 if hipotesis.strip() == referencia.strip() else 0.0 - p, r = sum(precisiones) / len(precisiones), sum(recalls) / len(recalls) - if p == 0 and r == 0: - return 0.0 - b2 = _BETA**2 - return 100 * (1 + b2) * p * r / (b2 * p + r) - - def _sin_tildes(texto: str) -> str: return "".join(c for c in unicodedata.normalize("NFD", texto.casefold()) if unicodedata.category(c) != "Mn") @@ -357,6 +331,7 @@ def medir( hilos: int = 4, cantidad_ejemplos: int = CANTIDAD_EN_LA_APP, controles_de_forma: bool = True, + perfil: str = ECONOMICO, ) -> list[Medicion]: """Traduce el banco con el motor (memoria vacía) y devuelve la medición; con `revisar`, también la de después.""" glosario = Glosario() @@ -376,7 +351,7 @@ def medir( traductor = Traductor( motor, memoria, glosario, banco.dialecto, hilos, validador=validar, ejemplos=ejemplos, glosario_estricto=glosario_estricto, limite_caracteres=limites[0], limite_entradas=limites[1], - controles_de_forma=controles_de_forma, + controles_de_forma=controles_de_forma, perfil=perfil, ) # fmt: skip por_ambito: dict[str, list[str]] = {} pistas: dict[str, str] = {} diff --git a/src/traductor_es/validacion/verificacion.py b/src/traductor_es/validacion/verificacion.py new file mode 100644 index 0000000..6280a22 --- /dev/null +++ b/src/traductor_es/validacion/verificacion.py @@ -0,0 +1,71 @@ +"""Verificador a ciegas: decide si una traducción nueva es mejor que la anterior antes de reemplazarla. + +Un modelo que corrige su propia traducción tiende a cambiar cosas que estaban bien. Por eso una corrección (de la +revisión, de un texto dudoso o de una muestra elegida) solo se queda si otro pedido al motor, sin saber cuál es la +nueva, la prefiere en los dos órdenes (A contra B y B contra A). Así no cuenta el sesgo de posición, y un empate o +un juez que se contradice deja la anterior. +""" + +from __future__ import annotations + +from collections.abc import Mapping, Sequence +from concurrent.futures import ThreadPoolExecutor + +from ..motores.base import Cancelado, Entrada, Lote, Motor +from ..nucleo.dialectos import DIALECTOS +from ..nucleo.mascara import enmascarar + +#: Pares por pedido al juez. +POR_LOTE = 20 + + +def veredictos( + motor: Motor, + dialecto: str, + ambito: str, + casos: Sequence[tuple[str, str, str, str]], + glosario: Mapping[str, str] | None = None, + contexto: str = "", + hilos: int = 4, +) -> list[str]: + """Para cada (original, pista, A, B), «A», «B» o «igual» según el juez. Los códigos van enmascarados: el juez no + los evalúa (ya se comprobaron) y así no se distrae con ellos.""" + lotes = [list(casos[i : i + POR_LOTE]) for i in range(0, len(casos), POR_LOTE)] + + def un_lote(lote: list[tuple[str, str, str, str]]) -> list[str]: + entradas = tuple( + Entrada(str(j), enmascarar(o).texto, pista, traduccion=enmascarar(a).texto, alternativa=enmascarar(b).texto) + for j, (o, pista, a, b) in enumerate(lote) + ) + pedido = Lote(entradas, ambito, DIALECTOS[dialecto], dict(glosario or {}), contexto, tarea="comparar") + try: + salida = motor.traducir_lote(pedido) + except Cancelado: + raise + except Exception: # sin juez no se cambia nada: queda la traducción anterior + return ["igual"] * len(lote) + votos: list[str] = [] + for j in range(len(lote)): + v = str(salida.get(str(j), "")).strip().upper() + votos.append("A" if v.startswith("A") else "B" if v.startswith("B") else "igual") + return votos + + with ThreadPoolExecutor(max(1, hilos)) as ex: + return [v for grupo in ex.map(un_lote, lotes) for v in grupo] + + +def gana_la_nueva( + motor: Motor, + dialecto: str, + ambito: str, + casos: Sequence[tuple[str, str, str, str]], + glosario: Mapping[str, str] | None = None, + contexto: str = "", + hilos: int = 4, +) -> list[bool]: + """Para cada (original, pista, anterior, nueva), si el juez prefiere la nueva en los dos órdenes.""" + if not casos: + return [] + directo = veredictos(motor, dialecto, ambito, casos, glosario, contexto, hilos) + inverso = veredictos(motor, dialecto, ambito, [(o, p, b, a) for o, p, a, b in casos], glosario, contexto, hilos) + return [d == "B" and i == "A" for d, i in zip(directo, inverso, strict=True)] diff --git a/tests/test_perfiles.py b/tests/test_perfiles.py new file mode 100644 index 0000000..7193252 --- /dev/null +++ b/tests/test_perfiles.py @@ -0,0 +1,114 @@ +"""Perfiles de calidad: verificador a ciegas en dos órdenes, corrección de lo dudoso y consenso de lo corto.""" + +from __future__ import annotations + +from collections.abc import Callable + +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 ECONOMICO, EQUILIBRADO, MAXIMO, MOTIVO_INCIERTO, Traductor +from traductor_es.proceso import Informe, InformeModulo +from traductor_es.validacion.verificacion import gana_la_nueva + + +class _Motor: + """Traduce con `traducir(texto, n)` (n = cuántas veces se pidió ese texto) y juzga con `juzgar(a, b)`.""" + + nombre = "falso" + + def __init__(self, traducir: Callable[[str, int], str], juzgar: Callable[[str, str], str]) -> None: + self._traducir, self._juzgar = traducir, juzgar + self.veces: dict[str, int] = {} + self.comparaciones = 0 + + def traducir_lote(self, lote: Lote) -> dict[str, str]: + if lote.tarea == "comparar": + self.comparaciones += len(lote.entradas) + return {e.id: self._juzgar(e.traduccion, e.alternativa) for e in lote.entradas} + salida: dict[str, str] = {} + for e in lote.entradas: + n = self.veces.get(e.texto, 0) + self.veces[e.texto] = n + 1 + salida[e.id] = self._traducir(e.texto, n) + return salida + + +def _prefiere(palabra: str) -> Callable[[str, str], str]: + return lambda a, b: "A" if palabra in a else "B" if palabra in b else "igual" + + +def test_la_nueva_gana_solo_si_el_juez_la_prefiere_en_los_dos_ordenes() -> None: + casos = [("Cost: 64", "", "Costo: 32", "Costo: 64")] + assert gana_la_nueva(_Motor(lambda t, n: t, _prefiere("64")), "es_mx", "ui", casos) == [True] + assert gana_la_nueva(_Motor(lambda t, n: t, lambda a, b: "A"), "es_mx", "ui", casos) == [False] # sesgo de orden + assert gana_la_nueva(_Motor(lambda t, n: t, lambda a, b: "igual"), "es_mx", "ui", casos) == [False] + + +def _cifras(texto: str, n: int) -> str: + """La primera vez cambia la cifra (duda del control de calidad); al corregir, la pone bien.""" + return "Cuesta 32 monedas" if n == 0 else "Cuesta 64 monedas" + + +def test_equilibrado_corrige_lo_dudoso_si_el_juez_lo_prefiere() -> None: + motor = _Motor(_cifras, _prefiere("64")) + with Memoria(":memory:") as m: + r = Traductor(motor, m, Glosario(), perfil=EQUILIBRADO).traducir(["Costs 64 coins"], "ui") + assert r.traducciones == {"Costs 64 coins": "Cuesta 64 monedas"} + assert not r.dudosos and r.corregidos == 1 + assert m.obtener("Costs 64 coins", "es_mx", "ui") == "Cuesta 64 monedas" # y quedó «ok» en la memoria + + +def test_equilibrado_deja_la_primera_si_el_juez_no_prefiere_la_correccion() -> None: + motor = _Motor(_cifras, _prefiere("32")) + with Memoria(":memory:") as m: + r = Traductor(motor, m, Glosario(), perfil=EQUILIBRADO).traducir(["Costs 64 coins"], "ui") + assert r.traducciones == {"Costs 64 coins": "Cuesta 32 monedas"} + assert "Costs 64 coins" in r.dudosos and r.corregidos == 0 + assert m.obtener("Costs 64 coins", "es_mx", "ui", "*") == "Cuesta 32 monedas" + + +def test_economico_no_pide_nada_mas() -> None: + motor = _Motor(_cifras, _prefiere("64")) + with Memoria(":memory:") as m: + r = Traductor(motor, m, Glosario(), perfil=ECONOMICO).traducir(["Costs 64 coins"], "ui") + assert r.traducciones == {"Costs 64 coins": "Cuesta 32 monedas"} and motor.comparaciones == 0 + + +def test_maximo_elige_por_mayoria_entre_tres_traducciones() -> None: + opciones = {"Iron Gear": ["Engrane de hierro", "Engranaje de hierro", "Engranaje de hierro"]} + motor = _Motor(lambda t, n: opciones[t][n], _prefiere("Engranaje")) + with Memoria(":memory:") as m: + r = Traductor(motor, m, Glosario(), perfil=MAXIMO).traducir(["Iron Gear"], "ui") + assert r.traducciones == {"Iron Gear": "Engranaje de hierro"} and r.elegidos == 1 + assert not r.dudosos + assert m.obtener("Iron Gear", "es_mx", "ui") == "Engranaje de hierro" + + +def test_maximo_sin_mayoria_elige_por_rangos_y_marca_incierto() -> None: + # La tercera tiene una duda del control de calidad («usted»); entre las otras dos, gana la más parecida al resto + opciones = {"Place the block": ["Pon el bloque", "Coloca el bloque", "Coloque el bloque"]} + motor = _Motor(lambda t, n: opciones[t][n], lambda a, b: "igual") + with Memoria(":memory:") as m: + r = Traductor(motor, m, Glosario(), perfil=MAXIMO).traducir(["Place the block"], "ui") + assert r.traducciones["Place the block"] in ("Pon el bloque", "Coloca el bloque") + assert r.dudosos == {"Place the block": MOTIVO_INCIERTO} + + +def test_maximo_no_toca_los_textos_largos() -> None: + largo = "This machine slowly crushes ores into dust over time" + motor = _Motor( + lambda t, n: "Esta máquina tritura despacio los minerales hasta hacerlos polvo", lambda a, b: "igual" + ) + with Memoria(":memory:") as m: + Traductor(motor, m, Glosario(), perfil=MAXIMO).traducir([largo], "ui") + assert motor.veces[largo] == 1 + + +def test_el_costo_estimado_sube_con_el_perfil() -> None: + informe = Informe(modulos=[InformeModulo("mods", "Mods", "", 100, 100, 5000)]) + economico = informe.costo("gemini-3.8-flash", False, calidad=ECONOMICO) + equilibrado = informe.costo("gemini-3.8-flash", False, calidad=EQUILIBRADO) + maximo = informe.costo("gemini-3.8-flash", False, calidad=MAXIMO) + assert economico is not None and equilibrado is not None and maximo is not None + assert economico < equilibrado < maximo diff --git a/tests/test_revision.py b/tests/test_revision.py index 9c40a63..1d67ce5 100644 --- a/tests/test_revision.py +++ b/tests/test_revision.py @@ -67,7 +67,7 @@ def test_marca_y_rehace_lo_grave(memoria: Memoria) -> None: assert memoria.obtener("Build a house", "es_mx", "mision") == "«ES» Build a house" pedido = next(lote for lote in motor.lotes_recibidos if lote.tarea == "revisar") assert {e.traduccion for e in pedido.entradas} == {"«ES» Find iron ore", "«ES» Build a house"} - rehecho = motor.lotes_recibidos[-1].entradas[0] + rehecho = next(lote for lote in reversed(motor.lotes_recibidos) if lote.tarea == "traducir").entradas[0] assert "marcado por la prueba" in rehecho.pista and "«ES» Find iron ore" in rehecho.pista assert "1 quedaron corregidos" in str(resumen)