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)