diff --git a/CHANGELOG.md b/CHANGELOG.md index 2e2dade..a333e8c 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 +- **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. + - Las mayúsculas de título en un nombre («Espada de Diamante») solo se informan: medido sobre las respuestas grabadas, bajarlas acertaba 3 veces y fallaba 10 (nombres propios como «Wither»). + - Al terminar, la lista completa de lo dudoso se guarda en un CSV (`informes/dudosos--.csv` en la carpeta de datos) y el registro dice cuántos arreglos de forma se hicieron. - **Importar un resource pack también trae sus libros de Patchouli:** cada archivo del libro en español se empareja con el mismo archivo en inglés del mod, campo por campo, y solo si los dos tienen la misma forma. - **Pista para las escenas de Ponder** (Create): las claves `*.ponder.*` llegan al motor como «texto de una escena de Ponder», para que traduzca frases cortas que explican lo que se ve. - **Scripts de CraftTweaker** (`scripts/*.zs`): tooltips (`addTooltip`, `addShiftTooltip`), nombres (`displayName`, `setDisplayName`), descripciones de JEI (`addDescription` en 1.12, `addInfo` desde 1.16) y el texto de `game.setLocalization`. Ids, claves, comparaciones y comentarios no se tocan; queda copia de seguridad. @@ -57,7 +62,7 @@ Todos los cambios importantes de ModpackES quedan en este archivo. El formato si - Palabras repetidas: un nombre corto que repite una palabra que el original no repite («Mejora de Salud mejorada») se reintenta. - Reintento acotado: el segundo intento recibe la primera traducción y se le pide corregir solo lo que falló. Si el término sigue en inglés, se cambia por el del glosario; lo que no se puede arreglar se acepta y se avisa como «aceptado con dudas». - **Lo que el español del juego ya traduce manda.** Los nombres del juego se cargan antes que cualquier otro término, y cada dialecto sigue al suyo (es_mx dice «ítem» y es_es «objeto»). Un vocabulario base completa solo lo que el juego no trae suelto («Netherite» → «Netherita»), y una palabra que no es del juego («inframundita») se corrige en los términos de los mods. Un término corto dentro de uno largo («Item» en «Item Frame») ya no se exige aparte. -- **Aviso de lo aceptado con dudas:** al terminar, el informe dice cuántos textos se aceptaron sin cumplir el glosario o con una palabra repetida, con ejemplos, para revisarlos en «Más ▸ Correcciones…». +- **Aviso de lo aceptado con dudas:** al terminar, el informe dice cuántos textos se aceptaron sin cumplir el glosario, con una palabra repetida o con un aviso del control de calidad, con ejemplos y la ruta del CSV con la lista completa, para revisarlos en «Más ▸ Correcciones…». - **Gemini 3.5 Flash-Lite, 3.6 Flash y posteriores ya no reciben `temperature`.** Google la ignora en esos modelos y anunció que las próximas generaciones la rechazarán. Además, cada modelo recibe un nivel de razonamiento que admite (la familia 4 no acepta «minimal»). - **El glosario ya no deja que un mod imponga su traducción a todo el modpack.** Los nombres del propio juego (primero es_mx, después es_es) mandan sobre los de un mod, y si dos mods traducen distinto el mismo término no se usa ninguno. Antes un mod que llamaba «Acechador de medianoche» a la vaca hacía que todo el modpack la tradujera así. - **Motores en tu PC (LM Studio, Ollama o un servidor en localhost):** los pedidos son más chicos (12 textos o 1.800 caracteres en vez de 60 o 5.000), porque un modelo pequeño se equivoca más con pedidos largos. Para medir sin saturar la GPU hay una «carga segura» en las herramientas de desarrollo (`medir_calidad.py --carga-segura`: pausas entre pedidos y espera si la GPU pasa de 80 °C). @@ -73,6 +78,9 @@ Todos los cambios importantes de ModpackES quedan en este archivo. El formato si ### Corregido +- **Argumentos al revés:** si el modelo cambiaba de orden dos `%s` («%s was slain by %s» → «… mató a …»), el juego ponía los valores al revés sin aviso. Ahora, en los archivos de idioma se numeran (`%2$s mató a %1$s`), como hace el propio español de Minecraft; en scripts, misiones y libros el texto se rechaza y se reintenta. +- **Escapes `\uXXXX` en scripts de KubeJS y CraftTweaker:** el modelo veía «⟦0⟧00a7cWarning» y podía romper el escape. Ahora los de caracteres visibles se decodifican («§cWarning», «éxito») y los de control quedan protegidos enteros. +- **Códigos que el modelo inventa o desordena:** se rechaza la traducción que trae un código que no estaba («§a», «%s») o que deja el cierre de un formato (`§r`, `$()`, ``) antes de su apertura. Con argumentos, un «%» suelto que escribió el modelo pasa a «%%». - **Se colaba un ejemplo en cada pedido** aunque la app no manda ejemplos (`CANTIDAD_EN_LA_APP = 0`): el tope se miraba después de agregar el primero. Los ejemplos de otros textos empeoraban la calidad y, como salían de lo traducido en esa misma ejecución, el mismo pedido cambiaba según el orden en que terminaban los hilos. - **El glosario no veía los términos pegados a un código de color** («Defeat the &4Arachnarch», «&eBronze Dungeons»): no se mandaban al modelo ni se exigían. Ahora los códigos se quitan antes de buscar términos, en el original y en la traducción. - **El pack no se activaba en una instancia nueva.** Si en `options.txt` solo estaban los packs internos (`["vanilla"]` o `["vanilla","mod_resources"]`), se escribía `Traduccion_ES` sin el prefijo `file/` que usa Minecraft desde 1.13, y el juego lo ignoraba. Ahora el formato sale de la versión de la instancia (también en 1.12, que no usa el prefijo). diff --git a/docs/calidad.md b/docs/calidad.md index c67cd99..b75837f 100644 --- a/docs/calidad.md +++ b/docs/calidad.md @@ -436,6 +436,37 @@ Gemini 3.8 Flash, tres corridas por condición (unos US$ 0,04 cada una): sección de nombres propios coherentes). - Los 116 textos pasaron las reglas: ninguno quedó en inglés ni perdió códigos de formato (`$(bold)`, `$(item)`…). +## 15 de noviembre de 2026 · respuestas grabadas y control de calidad determinista + +Entre dos corridas iguales Gemini solo devuelve lo mismo en un 67 % de los textos, y ese ruido tapa los cambios del +post-proceso. Ahora `medir_calidad.py --grabacion RUTA` guarda cada respuesta del motor (la clave es el pedido +exacto y el número de repetición) y `--solo-grabado` las vuelve a usar sin llamar a la API. Así un cambio que solo +toca lo que pasa después del modelo se mide gratis y sin ruido. Al grabar apareció un error: se colaba un ejemplo en +cada pedido aunque la app no manda ejemplos, y el pedido cambiaba según el orden de los hilos. + +Base grabada (tres repeticiones, US$ 0,43 en total): interfaz 74,8 · 73,3 · 74,4; libros 67,9 · 67,1 · 67,6. + +**Argumentos y códigos.** Con las mismas respuestas, numerar los `%s` que el modelo cambia de orden, decodificar los +`\uXXXX` y rechazar los códigos inventados no rechazó ningún texto de más en los tres bancos. + +**Control de calidad** (`validacion/qa.py`). Sigue la idea de las herramientas de QA de la industria (cifras, +parejas, espacios, puntuación), adaptada al español de Minecraft. Solo arregla lo que no tiene riesgo; lo demás +queda como duda en el CSV de dudosos. + +| Banco | chrF con el control (corridas 1 a 3) | Arreglos por corrida | Dudas por corrida | +|---|---|---|---| +| Interfaz | 74,8 · 73,3 · 74,5 | 1 (comillas) | 0 | +| Misiones | sin referencia | 0–1 (comillas) | 2 (cifras, paréntesis) | +| Libros | 67,9 · 67,1 · 67,6 | 0 | 0 | + +- Ningún arreglo empeoró un texto. Sobre las 2.145 traducciones grabadas, los 4 arreglos de comillas subieron el + chrF en 3 casos y no lo bajaron en ninguno. +- Gemini 3.8 Flash ya cuida casi toda la forma, así que el control casi no actúa con él. Sirve de red para modelos + más chicos y para lo que no sale en un banco. +- **Mayúsculas de título en nombres** («Espada de Diamante»): bajarlas de forma automática acertó 3 veces y falló 10 + («Vidrio a prueba de Wither», «Nivel III»), así que solo se informan y no se cambian. +- Cada control tiene pruebas con textos correctos del español del juego que no deben marcarse (`tests/test_qa.py`). + ## Cómo repetirlo ``` diff --git a/src/traductor_es/formatos/javascript.py b/src/traductor_es/formatos/javascript.py index 98412dc..ef0e04f 100644 --- a/src/traductor_es/formatos/javascript.py +++ b/src/traductor_es/formatos/javascript.py @@ -47,6 +47,26 @@ def nombre(self) -> str: return f"{base}:{self.primera}" if self.primera is not None else base +_HEX = frozenset("0123456789abcdefABCDEF") + + +def _escape_visible(crudo: str, i: int) -> tuple[str, int] | None: + """(carácter, largo del escape) si en `i` empieza un `\\uXXXX` o `\\xXX` de un carácter visible; si no, None. + + Los de control (`\\u0000`, `\\x1b`…) no se decodifican: quedan como escape crudo y la máscara los protege enteros. + """ + largo = {"u": 4, "x": 2}.get(crudo[i + 1] if i + 1 < len(crudo) else "") + if largo is None: + return None + cifras = crudo[i + 2 : i + 2 + largo] + if len(cifras) != largo or not set(cifras) <= _HEX: + return None + caracter = chr(int(cifras, 16)) + if not caracter.isprintable() or 0xD800 <= ord(caracter) <= 0xDFFF: + return None + return caracter, 2 + largo + + def des_escapar(crudo: str) -> str: salida: list[str] = [] i = 0 @@ -54,6 +74,12 @@ def des_escapar(crudo: str) -> str: c = crudo[i] if c == "\\" and i + 1 < len(crudo): sig = crudo[i + 1] + visible = _escape_visible(crudo, i) + if visible is not None: # «é» → «é»: el modelo ve la palabra entera; «§» → «§», un color + caracter, largo = visible + salida.append(caracter) + i += largo + continue salida.append(_ESCAPES.get(sig, ESCAPE_CRUDO + sig)) i += 2 else: diff --git a/src/traductor_es/nucleo/mascara.py b/src/traductor_es/nucleo/mascara.py index e04f9cc..3487283 100644 --- a/src/traductor_es/nucleo/mascara.py +++ b/src/traductor_es/nucleo/mascara.py @@ -6,6 +6,7 @@ from __future__ import annotations import re +from collections import Counter from dataclasses import dataclass from typing import Final @@ -13,7 +14,8 @@ ESCAPE_CRUDO: Final = chr(0xE000) _PATRONES: Final[tuple[str, ...]] = ( - ESCAPE_CRUDO + r"[\s\S]", # escapes del formato de origen (\n en SNBT, etc.), incluido barra + salto real + # escapes del formato de origen (\n en SNBT, etc.), incluido barra + salto real; uno de control, entero + ESCAPE_CRUDO + r"(?:u[0-9a-fA-F]{4}|x[0-9a-fA-F]{2}|[\s\S])", r"\$\([^)]*\)", # macros de Patchouli: $(l) $(item) $(l:ruta) $() r"\$\{[^{}\n]*\}", # expresiones de plantillas de JavaScript: ${precio} r"\{[^{}\n]*\}", # FTB Quests {image:..} {@pagebreak} {clave}, {0} de Java @@ -88,3 +90,83 @@ def sin_formato(texto: str) -> str: «Defeat the &4Arachnarch»: con el código, el «4» va pegado al nombre y «Arachnarch» no es una palabra completa. """ return _CODIGO_DE_FORMATO.sub("", texto) + + +# ---------------------------------------------------------------- argumentos y pares de formato +#: Un argumento printf que recibe un valor (no `%%` ni `%n`): %s %d %1$s %.1f +_ARGUMENTO: Final = re.compile(r"%(?:(\d+)\$)?[-#+0,(]*\d*(?:\.\d+)?[sdfxXcbeEgGoh]") +#: Códigos que cierran un formato: §r, $() de Patchouli, $(/l), +_CIERRE: Final = re.compile(r"[§&][rR]|\$\(\)|\$\(/[a-z]*\)|") +#: Códigos que no abren nada: saltos y listas de Patchouli, teclas,
y etiquetas que se cierran solas +_NEUTRO: Final = re.compile(r"\$\((?:br2?|li|p|k:[^)]*)\)||<[^<>]*/>") +#: Códigos que abren un formato que luego se cierra: colores y estilos, macros de Patchouli, etiquetas +_APERTURA: Final = re.compile(r"[§&][0-9a-fk-oA-FK-O]|\$\([^)]+\)|<[A-Za-z][^<>]*>") + + +def _orden(traducido: str) -> list[int]: + """Los marcadores en el orden en que los escribió el modelo.""" + return [int(n) for n in TOKEN.findall(_MARCADOR_CON_ESPACIOS.sub(lambda m: f"⟦{m.group(1)}⟧", traducido))] + + +def es_argumento(token: str) -> bool: + return _ARGUMENTO.fullmatch(token) is not None + + +def posicionar_argumentos(traducido: str, tokens: tuple[str, ...]) -> tuple[tuple[str, ...], bool] | None: + """Si el modelo cambió el orden de los argumentos sin posición («%s … %s»), los numera según el original. + + «%s was slain by %s» → «⟦1⟧ fue asesinado por ⟦0⟧»: sin numerar, el juego pondría los valores al revés. Con + `%1$s` y `%2$s` (que Minecraft admite y usa en su propio español) cada valor va a su sitio. + Devuelve (tokens, si cambiaron), o None si no se puede arreglar: el original mezcla argumentos con y sin número. + """ + argumentos = [i for i, t in enumerate(tokens) if es_argumento(t)] + if len(argumentos) < 2: + return tokens, False + elegidos = set(argumentos) + orden = [i for i in _orden(traducido) if i in elegidos] + if orden == argumentos: + return tokens, False + sin_numero = [i for i in argumentos if (m := _ARGUMENTO.fullmatch(tokens[i])) and m.group(1) is None] + if not sin_numero: # ya están numerados: cambiarlos de orden es válido + return tokens, False + if len(sin_numero) != len(argumentos): + return None + nuevos = list(tokens) + for numero, i in enumerate(argumentos, 1): + nuevos[i] = tokens[i].replace("%", f"%{numero}$", 1) + return tuple(nuevos), True + + +def escapar_porcentajes(traducido: str) -> str: + """Un «%» que escribió el modelo («50 %») pasa a «%%»: con argumentos, un «%» suelto rompe el formato.""" + return traducido.replace("%", "%%") + + +def pares_en_orden(traducido: str, tokens: tuple[str, ...]) -> bool: + """¿Cada código que abre un formato (§l, $(l), ) sigue antes del que lo cierra (§r, $(), )? + + Mover un par entero es válido («the §aIron§r §bSword§r» → «la §bEspada§r de §aHierro§r»); lo que no vale es + dejar el cierre antes de su apertura, que pinta otras palabras. + """ + posicion = {indice: lugar for lugar, indice in enumerate(_orden(traducido))} + abiertos: list[int] = [] + for indice, token in enumerate(tokens): + if _CIERRE.fullmatch(token): + cierre = posicion.get(indice) + if cierre is not None and any(posicion.get(a, -1) > cierre for a in abiertos): + return False + abiertos = [] + elif _APERTURA.fullmatch(token) and not _NEUTRO.fullmatch(token): + abiertos.append(indice) + return True + + +def codigos_inventados(restaurado: str, tokens: tuple[str, ...], porcentajes: int = 0) -> bool: + """¿La traducción trae códigos que no vienen de los marcadores (un «§a» o un «%s» que escribió el modelo)? + + `porcentajes` son los «%%» que se agregaron a propósito con `escapar_porcentajes`. + """ + esperados = Counter(tokens) + if porcentajes: + esperados["%%"] += porcentajes + return Counter(enmascarar(restaurado).tokens) != esperados diff --git a/src/traductor_es/nucleo/traductor.py b/src/traductor_es/nucleo/traductor.py index 4276393..8f3b265 100644 --- a/src/traductor_es/nucleo/traductor.py +++ b/src/traductor_es/nucleo/traductor.py @@ -3,12 +3,14 @@ from __future__ import annotations import threading +from collections import Counter from collections.abc import Callable, Iterable, Mapping from concurrent.futures import Future, ThreadPoolExecutor, as_completed from dataclasses import dataclass, field from typing import cast from ..motores.base import Cancelado, Entrada, Lote, Motor, MotorPorLotes +from ..validacion import qa from ..validacion.calidad import ( ajustar_mayusculas, palabra_repetida, @@ -20,7 +22,18 @@ from .dialectos import DIALECTO_POR_DEFECTO, DIALECTOS from .ejemplos import Ejemplos from .glosario import Glosario -from .mascara import Enmascarado, desenmascarar, enmascarar, es_traducible, separar_bordes +from .mascara import ( + Enmascarado, + codigos_inventados, + desenmascarar, + enmascarar, + es_argumento, + es_traducible, + escapar_porcentajes, + pares_en_orden, + posicionar_argumentos, + separar_bordes, +) from .memoria import Memoria Progreso = Callable[[int, int], None] @@ -35,6 +48,8 @@ ) #: Prefijo del motivo de rechazo cuando falta un término del glosario; lo que sigue es «inglés=español; …». MOTIVO_TERMINOLOGIA = "terminología: " +#: Prefijo del motivo de una traducción aceptada con dudas del control de calidad (números, usted, inglés…). +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: " AVISO_TERMINO = "Término que se repite en los nombres de este modpack: tradúcelo suelto, como se diría de un objeto." @@ -63,6 +78,8 @@ class Resultado: borradores: dict[str, str] = field(default_factory=dict[str, str]) #: Lo que se aceptó en el reintento sin cumplir todas las reglas (núcleo → motivo): conviene revisarlo 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]) class Traductor: @@ -311,7 +328,7 @@ def _ronda_por_lotes( hechos = 0 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) + buenos = self._procesar(lote, mascaras, salida, resultado, tolerante, pedido.glosario, ambito, pistas) self.memoria.guardar(buenos, self.dialecto, ambito, self.motor.nombre) fallidos.update(n for n in lote if n not in buenos) hechos += len(lote) @@ -335,7 +352,8 @@ def _lote( if self.cancelar.is_set(): return {} pedido, mascaras = self._pedido(lote, ambito, pistas) - return self._procesar(lote, mascaras, self.motor.traducir_lote(pedido), resultado, tolerante, pedido.glosario) + salida = self.motor.traducir_lote(pedido) + return self._procesar(lote, mascaras, salida, resultado, tolerante, pedido.glosario, ambito, pistas) def _procesar( self, @@ -345,8 +363,11 @@ def _procesar( resultado: Resultado, tolerante: bool = False, glosario: Mapping[str, str] | None = None, + ambito: str = "ui", + pistas: Mapping[str, str] | None = None, ) -> dict[str, str]: buenos: dict[str, str] = {} + arreglos: Counter[str] = Counter() rechazados: dict[str, str] = {} borradores: dict[str, str] = {} dudosos: dict[str, str] = {} @@ -355,9 +376,9 @@ def _procesar( if not isinstance(crudo, str) or not crudo.strip(): rechazados[n] = "sin respuesta" continue - final = desenmascarar(crudo.strip(), m.tokens) + final, motivo_codigos = self._restaurar(crudo.strip(), m.tokens, ambito) if final is None: - rechazados[n] = "códigos dañados" + rechazados[n] = motivo_codigos continue motivo = self.validador(n, final) if self.validador else None if motivo: @@ -377,6 +398,12 @@ def _procesar( rechazados[n] = motivo borradores[n] = final continue + if self.controles_de_forma: # control de calidad: arreglos seguros y dudas + rol = "nombre" if "nombre de un" in (pistas or {}).get(n, "") else "" + final, hallazgos = qa.revisar(n, final, ambito=ambito, dialecto=self.dialecto, rol=rol) + arreglos.update(qa.arreglos(hallazgos)) + if (codigos := qa.dudas(hallazgos)) and n not in dudosos: + dudosos[n] = MOTIVO_QA + ", ".join(codigos) buenos[n] = final self.ejemplos.agregar_pares(buenos) # lo que ya se tradujo guía a los lotes que faltan with self._lock: @@ -384,9 +411,37 @@ def _procesar( resultado.rechazados.update(rechazados) resultado.borradores.update(borradores) resultado.dudosos.update(dudosos) + resultado.arreglos.update(arreglos) resultado.nuevas.update(buenos) return buenos + @staticmethod + def _restaurar(crudo: str, tokens: tuple[str, ...], ambito: str) -> tuple[str | None, str]: + """Devuelve los códigos a su sitio. (traducción, "") si quedó bien; (None, motivo) si no. + + - Si el modelo cambió el orden de los «%s», en los archivos de idioma se numeran (`%1$s`, `%2$s`); en scripts, + misiones y libros no se puede, y el texto se rechaza (mejor en inglés que con los valores al revés). + - Con argumentos, un «%» que escribió el modelo pasa a «%%» (si no, el formato falla). + - Cada código que abre un formato tiene que seguir antes del que lo cierra. + - La traducción no puede traer códigos que no estaban («§a», «%s» escritos por el modelo). + """ + posicionados = posicionar_argumentos(crudo, tokens) + if posicionados is None or (posicionados[1] and ambito != "ui"): + return None, "orden de argumentos" + tokens = posicionados[0] + porcentajes = 0 + if ambito == "ui" and any(es_argumento(t) for t in tokens) and "%" in crudo: + porcentajes = crudo.count("%") + crudo = escapar_porcentajes(crudo) + if not pares_en_orden(crudo, tokens): + return None, "formato fuera de orden" + final = desenmascarar(crudo, tokens) + if final is None: + return None, "códigos dañados" + if codigos_inventados(final, tokens, porcentajes): + return None, "códigos inventados" + return final, "" + def _motivo_de_forma(self, original: str, final: str, glosario: Mapping[str, str] | None) -> str | None: """Reglas que un reintento puede arreglar: sin traducir, términos del glosario y palabras repetidas.""" if sin_traducir(original, final): diff --git a/src/traductor_es/proceso.py b/src/traductor_es/proceso.py index 3a2cc2e..6f32890 100644 --- a/src/traductor_es/proceso.py +++ b/src/traductor_es/proceso.py @@ -2,6 +2,8 @@ from __future__ import annotations +import csv +import re import sqlite3 import threading from collections.abc import Callable, Mapping, Sequence @@ -72,6 +74,10 @@ class Informe: modulos_cambios: list[InformeModulo] = field(default_factory=list[InformeModulo]) #: Lo que se aceptó sin cumplir todas las reglas tras el reintento: original → (traducción, motivo) dudosos: dict[str, tuple[str, str]] = field(default_factory=dict[str, tuple[str, str]]) + #: Arreglos automáticos del control de calidad (código → cuántos) + arreglos: dict[str, int] = field(default_factory=dict[str, int]) + #: Lista completa de lo dudoso, para revisarla con calma (None si no hubo nada o no se pudo guardar) + archivo_dudosos: Path | None = None @property def diferencia(self) -> Informe: @@ -120,15 +126,43 @@ def _textos(lugar: Lugar) -> list[str]: _EJEMPLOS_DUDOSOS = 3 -def aviso_de_dudosos(dudosos: Mapping[str, tuple[str, str]]) -> str: +#: Nombres de los arreglos del control de calidad para el registro +_NOMBRES_QA = { + "espacios": "espacios", "ancho_cero": "caracteres invisibles", "palabra_doble": "palabras repetidas", + "signo_apertura": "¿ y ¡", "puntuacion_final": "puntuación final", "comillas": "comillas", + "mes_dia": "meses y días", +} # fmt: skip + + +def guardar_dudosos(dudosos: Mapping[str, tuple[str, str]], juego: Path) -> Path | None: + """Guarda la lista completa de lo dudoso en un CSV (original, traducción, motivo) en la carpeta de datos.""" + try: + carpeta = configuracion.carpeta_datos() / "informes" + carpeta.mkdir(parents=True, exist_ok=True) + fecha = datetime.now().strftime("%Y%m%d-%H%M%S") + nombre = re.sub(r"[^\w.-]+", "_", juego.parent.name if juego.name == "minecraft" else juego.name).strip("_") + ruta = carpeta / f"dudosos-{nombre or 'instancia'}-{fecha}.csv" + with ruta.open("w", encoding="utf-8-sig", newline="") as f: # con BOM: Excel lo abre con tildes + escritor = csv.writer(f) + escritor.writerow(["original", "traduccion", "motivo"]) + for original, (traduccion, motivo) in sorted(dudosos.items()): + escritor.writerow([original, traduccion, motivo]) + except OSError: + return None + return ruta + + +def aviso_de_dudosos(dudosos: Mapping[str, tuple[str, str]], archivo: Path | None = None) -> str: """Resumen de lo que se aceptó con dudas, con unos ejemplos para revisar a mano.""" ejemplos = "; ".join( f"«{original}» → «{traduccion}» ({motivo.split(':')[0]})" for original, (traduccion, motivo) in sorted(dudosos.items())[:_EJEMPLOS_DUDOSOS] ) + lista = f" La lista completa está en {archivo}." if archivo is not None else "" return ( - f"{len(dudosos)} textos se aceptaron con dudas (un término del glosario que no salió o una palabra repetida); " - f"conviene revisarlos en «Más ▸ Correcciones…». Por ejemplo: {ejemplos}" + f"{len(dudosos)} textos se aceptaron con dudas (un término del glosario, una repetición o un aviso del control " + f"de calidad: cifras, usted, inglés, omisión…); conviene revisarlos en «Más ▸ Correcciones…».{lista} " + f"Por ejemplo: {ejemplos}" ) @@ -452,7 +486,13 @@ def ejecutar(self, activar: bool = True, poner_idioma: bool = True, solo_memoria relevantes = self.glosario.relevantes(todas, maximo=500) informe.revision = revisar_glosario(todas, relevantes, relevantes) if informe.dudosos: - informe.avisos.append(aviso_de_dudosos(informe.dudosos)) + informe.archivo_dudosos = guardar_dudosos(informe.dudosos, self.instancia.juego) + informe.avisos.append(aviso_de_dudosos(informe.dudosos, informe.archivo_dudosos)) + if informe.arreglos: + self.registro( + "Arreglos automáticos de forma: " + + ", ".join(f"{_NOMBRES_QA.get(c, c)} {n}" for c, n in sorted(informe.arreglos.items())) + ) informe.avisos.extend(self._avisos()) self._guardar_indice(traducidos, informe) if activar and (self.ctx.pack is not None and (self.ctx.pack.raiz / "pack.mcmeta").is_file()): @@ -505,6 +545,8 @@ def _traducir_pasada( informe.revision_automatica.sumar(hecha) if hecha.corregidos: # lo rehecho ya está en la memoria: se vuelve a juntar sin pedir nada resultado.traducciones = traductor.conocidas(textos, modulo.ambito) + for codigo, cuantos in resultado.arreglos.items(): + informe.arreglos[codigo] = informe.arreglos.get(codigo, 0) + cuantos informe.dudosos.update( {n: (resultado.nuevas[n], motivo) for n, motivo in resultado.dudosos.items() if n in resultado.nuevas} ) diff --git a/src/traductor_es/validacion/medicion.py b/src/traductor_es/validacion/medicion.py index b7549e5..cfa94c9 100644 --- a/src/traductor_es/validacion/medicion.py +++ b/src/traductor_es/validacion/medicion.py @@ -28,7 +28,7 @@ from ..nucleo.glosario import Glosario from ..nucleo.mascara import sin_formato from ..nucleo.memoria import Memoria -from ..nucleo.traductor import Traductor +from ..nucleo.traductor import MOTIVO_QA, Traductor from ..nucleo.vocabulario import agregar_vocabulario, preparar_sustituciones from ..proceso import Informe, InformeModulo from . import revision @@ -207,6 +207,8 @@ class Medicion: terminos_respetados_lema: int = 0 #: como `terminos_respetados`, aceptando plurales y otras formas (WMT25) tokens_reales: tuple[int, int] | None = None #: (entrada, salida) que facturó el motor en esta medición costo_real: float | None = None #: US$ según `tokens_reales` y la tabla de precios (lo grabado no cuesta) + qa: dict[str, int] = field(default_factory=dict[str, int]) #: dudas del control de calidad por código + arreglos: dict[str, int] = field(default_factory=dict[str, int]) #: arreglos automáticos por código @property def porcentaje(self) -> float: @@ -252,6 +254,11 @@ def tabla(self) -> str: if self.rechazos else [] ), + *( + (etiqueta, ", ".join(f"{c} {n}" for c, n in sorted(conteo.items(), key=lambda x: -x[1]))) + for etiqueta, conteo in (("Arreglos de forma", self.arreglos), ("Dudas del control", self.qa)) + if conteo + ), ("Costo estimado", "desconocido" if self.costo_estimado is None else f"US$ {self.costo_estimado:.3f}"), *( [ @@ -383,6 +390,16 @@ def medir( hechas = {(a, o): t for a, r in resultados.items() for o, t in r.traducciones.items()} mediciones = [_medir(nombre or motor.nombre, banco, hechas, informe.costo(modelo, False, motor_id), segundos)] mediciones[0].tokens_reales, mediciones[0].costo_real = _gasto(motor, uso_antes, modelo) + mediciones[0].arreglos = dict(sum((r.arreglos for r in resultados.values()), Counter[str]())) + mediciones[0].qa = dict( + Counter( + c.strip() + for r in resultados.values() + for m in r.dudosos.values() + if m.startswith(MOTIVO_QA) + for c in m.removeprefix(MOTIVO_QA).split(",") + ) + ) mediciones[0].rechazos = dict( Counter(m.split(":")[0] for r in resultados.values() for m in r.rechazados.values()) ) diff --git a/src/traductor_es/validacion/qa.py b/src/traductor_es/validacion/qa.py new file mode 100644 index 0000000..b85157a --- /dev/null +++ b/src/traductor_es/validacion/qa.py @@ -0,0 +1,276 @@ +"""Control de calidad determinista: lo que una herramienta de QA de localización revisaría en cada traducción. + +Cada control arregla solo lo que es seguro arreglar sin entender la frase (espacios, ¿¡, puntuación final que +se perdió, comillas del dialecto, meses con mayúscula) y marca como duda lo demás (números distintos, paréntesis +sin pareja, usted en vez de tú, palabras en inglés, omisiones). Nada de esto llama al modelo. + +Los arreglos se hacen sobre el texto con los códigos protegidos (⟦n⟧), así que nunca tocan un `§a`, un `%s`, un +`$(l)` ni una etiqueta. Las ideas vienen de los controles de herramientas como Weblate, Translate Toolkit +(pofilter), Xbench y memoQ, y de las convenciones del español del propio Minecraft (tú, ¿¡, `...`); el código es +propio. +""" + +from __future__ import annotations + +import re +from collections import Counter +from dataclasses import dataclass +from typing import Final, Literal + +from ..nucleo.mascara import TOKEN, desenmascarar, enmascarar + +Gravedad = Literal["bloquea", "duda", "info"] + + +@dataclass(frozen=True, slots=True) +class Hallazgo: + codigo: str + gravedad: Gravedad + detalle: str = "" + arreglado: bool = False + + +_MARCADOR: Final = r"⟦\d+⟧" +_PALABRA: Final = re.compile(r"[^\W\d_]+") +_ANCHO_CERO: Final = re.compile("[\u200b‌‍⁠]") +_PALABRA_DOBLE: Final = re.compile(r"\b([^\W\d_]{2,})(\s+)\1\b", re.IGNORECASE) +_ESPACIO_ANTES: Final = re.compile(r"(?<=\S) +(?=[,.;:!?)\]»])") +_ESPACIO_DESPUES: Final = re.compile(r"([¿¡(\[«]) +") +#: Inicio de la frase: se salta lo que va antes de la primera letra (códigos, guiones, comillas, paréntesis) +_INICIO: Final = re.compile(rf"^(?:{_MARCADOR}|[\s\"'«“(\[\-–—*•])*") +_TERMINOS_DE_FRASE: Final = re.compile(r"[.!?…](?=\s|$|⟦)") +_MESES_Y_DIAS: Final = frozenset({ + "enero", "febrero", "marzo", "abril", "mayo", "junio", "julio", "agosto", "septiembre", "setiembre", + "octubre", "noviembre", "diciembre", "lunes", "martes", "miércoles", "jueves", "viernes", "sábado", "domingo", +}) # fmt: skip +#: Formas de usted que el español del juego no usa (tutea en es_mx y en es_es) +_USTED: Final = re.compile( + r"\b(usted|haga|coloque|utilice|asegúrese|presione|pulse|seleccione|elija|intente|introduzca|" + r"mantenga|compruebe|verifique|tenga en cuenta)\b", + re.IGNORECASE, +) +#: Palabras del inglés que no existen en español: si sobreviven, quedó inglés a medio traducir +_INGLES: Final = frozenset({ + "the", "and", "with", "your", "you", "this", "that", "from", "have", "will", "which", "when", "into", "are", + "is", "of", "to", "for", "it", "can", "be", "an", "or", "not", "on", "by", "its", "they", "there", "their", + "click", "right", "left", "using", "use", "while", "item", "items", "block", "blocks", +}) # fmt: skip +_NUMERO: Final = re.compile(r"\d+(?:[.,]\d+)*") +_PAREJAS: Final = (("(", ")"), ("[", "]"), ("«", "»"), ("“", "”")) +#: Largo máximo razonable de un texto de interfaz en español frente al inglés (expansión de 20–30 % más margen) +_FACTOR_LARGO, _MARGEN_LARGO = 1.6, 10 + + +def _visible(texto: str) -> str: + return TOKEN.sub(" ", texto) + + +def _una_frase(texto: str) -> bool: + """¿Es una sola frase? Ningún punto, ¡, ? o salto antes del final.""" + cuerpo = _visible(texto).rstrip()[:-1] + return not _TERMINOS_DE_FRASE.search(cuerpo) and "\n" not in cuerpo + + +def _abrir(texto: str, signo: str) -> str: + inicio = _INICIO.match(texto) + corte = inicio.end() if inicio else 0 + return texto[:corte] + signo + texto[corte:] + + +#: Del uno al doce se escriben a menudo con letras («say that 3 times» → «dilo tres veces») +_CON_LETRAS: Final = { + "uno": "1", "una": "1", "un": "1", "dos": "2", "tres": "3", "cuatro": "4", "cinco": "5", "seis": "6", + "siete": "7", "ocho": "8", "nueve": "9", "diez": "10", "once": "11", "doce": "12", +} # fmt: skip + + +def _numeros(texto: str) -> Counter[str]: + """Las cifras del texto sin separadores: «1,000», «1.000» y «1000» cuentan igual; «1.5» y «1,5» también.""" + return Counter(re.sub(r"[.,]", "", n) for n in _NUMERO.findall(_visible(texto))) + + +def _faltan_numeros(fuente: str, texto: str) -> bool: + """¿Hay cifras del original que no están en la traducción, ni con letras, o cifras nuevas?""" + original, traducido = _numeros(fuente), _numeros(texto) + if original == traducido: + return False + escritas = Counter(_CON_LETRAS[p.lower()] for p in _PALABRA.findall(_visible(texto)) if p.lower() in _CON_LETRAS) + faltan = original - traducido + return bool(faltan - escritas) or bool(traducido - original) + + +#: Una frase nueva: punto, ¡, ? o … seguido de espacio y de una mayúscula (no cuentan «e.g.» ni «etc.» en medio) +_LIMITE_DE_FRASE: Final = re.compile(r"(? str: + """El último carácter visible (sin espacios ni códigos al final).""" + visible = re.sub(rf"(?:{_MARCADOR}|\s)+$", "", texto) + return visible[-1:] if visible else "" + + +class _Revision: + """El texto (con los códigos protegidos) y lo que se va encontrando.""" + + def __init__(self, fuente: str, texto: str) -> None: + self.fuente = fuente + self.texto = texto + self.hallazgos: list[Hallazgo] = [] + + def arreglo(self, codigo: str, nuevo: str) -> None: + if nuevo != self.texto: + self.texto = nuevo + self.hallazgos.append(Hallazgo(codigo, "info", arreglado=True)) + + def marca(self, codigo: str, gravedad: Gravedad, detalle: str) -> None: + self.hallazgos.append(Hallazgo(codigo, gravedad, detalle)) + + +def _espacios(r: _Revision) -> None: + """Espacios dobles o antes de la puntuación, caracteres invisibles y palabras repetidas que el original no tiene.""" + if not _ANCHO_CERO.search(r.fuente): + r.arreglo("ancho_cero", _ANCHO_CERO.sub("", r.texto)) + if " " not in r.fuente: + r.arreglo("espacios", re.sub(r"(?<=\S) {2,}(?=\S)", " ", r.texto)) + if not _ESPACIO_ANTES.search(r.fuente): + r.arreglo("espacios", _ESPACIO_DESPUES.sub(r"\1", _ESPACIO_ANTES.sub("", r.texto))) + if not _PALABRA_DOBLE.search(r.fuente): + r.arreglo("palabra_doble", _PALABRA_DOBLE.sub(r"\1", r.texto)) + + +def _palabras_inglesas(texto: str) -> list[str]: + """Palabras que solo existen en inglés, si son bastantes para decir que el texto quedó (en parte) en inglés.""" + palabras = [p.lower() for p in _PALABRA.findall(_visible(texto))] + inglesas = [p for p in palabras if p in _INGLES] + return inglesas if inglesas and (len(inglesas) >= 2 or len(palabras) <= 4) else [] + + +#: Palabras que en un texto en español solo aparecen si quedó inglés: con una basta para no decorarlo con ¿¡ +_SOLO_INGLES: Final = frozenset({ + "the", "and", "with", "your", "you", "this", "that", "from", "have", "will", "which", "when", "into", "are", + "is", "isn", "don", "doesn", "can", "won", "it", "its", "of", "to", "for", "not", +}) # fmt: skip + + +def _parece_ingles(texto: str, fuente: str) -> bool: + """¿Quedó en inglés? Lleva una palabra que solo existe en inglés, o la mitad de sus palabras son del original.""" + palabras = [p.lower() for p in _PALABRA.findall(_visible(texto)) if len(p) >= 3] + if any(p.lower() in _SOLO_INGLES for p in _PALABRA.findall(_visible(texto))): + return True + del_original = {p.lower() for p in _PALABRA.findall(_visible(fuente))} + return bool(palabras) and sum(p in del_original for p in palabras) >= len(palabras) / 2 + + +def _pares_de_comillas(texto: str) -> int: + return texto.count('"') // 2 + texto.count("«") + texto.count("“") + + +def _signos(r: _Revision) -> None: + """¿ y ¡ de apertura, y la puntuación final que el original tiene y la traducción perdió.""" + for cierre, apertura in (("?", "¿"), ("!", "¡")): + if _parece_ingles(r.texto, r.fuente): # un texto que quedó en inglés no se decora: se marca como duda + break + if _final(r.texto) == cierre and apertura not in r.texto: + if _una_frase(r.texto): + r.arreglo("signo_apertura", _abrir(r.texto, apertura)) + else: + r.marca("signo_apertura", "duda", f"falta «{apertura}»") + fin_fuente, fin, texto = _final(r.fuente), _final(r.texto), r.texto.rstrip() + if r.fuente.rstrip().endswith("...") and not texto.endswith("..."): + if texto.endswith("…"): + r.arreglo("puntuacion_final", texto[:-1] + "...") + elif fin and fin not in ".!?:" and not texto.endswith("⟧"): + r.arreglo("puntuacion_final", texto + "...") + elif fin_fuente == ":" and fin != ":" and not texto.endswith("⟧"): + r.arreglo("puntuacion_final", (texto[:-1] if fin == "." else texto) + ":") + elif (fin_fuente == "." and fin not in ".!?…:") or (fin_fuente not in ".!?…:" and fin == "."): + r.marca("puntuacion_final", "info", "el punto final no coincide con el original") + + +def _al_inicio(texto: str, posicion: int) -> bool: + antes = re.sub(rf"(?:{_MARCADOR}|\s)+$", "", texto[:posicion]) + return not antes or antes[-1] in ".!?¿¡:\n" + + +def _comillas_y_fechas(r: _Revision, dialecto: str) -> None: + """Comillas del dialecto, solo si el original las usa (es_es «», es_mx ""), y meses y días en minúscula.""" + # Solo si el original usa comillas y la traducción tiene los mismos pares (no se tocan comillas que el + # original no tenía, como las de un nombre que el modelo destacó) + if ('"' in r.fuente or "“" in r.fuente) and _pares_de_comillas(r.texto) == _pares_de_comillas(r.fuente): + if dialecto == "es_es": + r.arreglo("comillas", re.sub(r'"([^"\n]+)"', r"«\1»", r.texto)) + else: + r.arreglo("comillas", re.sub(r"[«“]([^»”\n]+)[»”]", r'"\1"', r.texto)) + texto = r.texto + r.arreglo( + "mes_dia", + _PALABRA.sub( + lambda m: ( + m.group(0).lower() + if m.group(0).lower() in _MESES_Y_DIAS and not _al_inicio(texto, m.start()) + else m.group(0) + ), + texto, + ), + ) + + +def _dudas(r: _Revision) -> None: + """Lo que no se puede arreglar sin entender la frase.""" + fuente, texto = r.fuente, r.texto + if _faltan_numeros(fuente, texto): + r.marca("numeros", "duda", "las cifras no coinciden con el original") + for abre, cierra in _PAREJAS: + if texto.count(abre) != texto.count(cierra) and fuente.count(abre) == fuente.count(cierra): + r.marca("pareja", "duda", f"«{abre}» sin pareja") + if texto.count('"') % 2 and not fuente.count('"') % 2: + r.marca("pareja", "duda", "comillas sin pareja") + if _USTED.search(_visible(texto)) and not _USTED.search(_visible(fuente)): + r.marca("usted", "duda", "trata de usted; el juego tutea") + if inglesas := _palabras_inglesas(texto): + r.marca("ingles", "duda", "quedan palabras en inglés: " + ", ".join(sorted(set(inglesas)))) + largo_fuente, largo = len(_visible(fuente).strip()), len(_visible(texto).strip()) + frases_fuente = len(_LIMITE_DE_FRASE.findall(_visible(fuente))) + # Unir dos frases con «:» o «;» es legítimo: solo cuenta si faltan dos o más, o la mitad del largo + if (largo_fuente >= 40 and largo < 0.5 * largo_fuente) or ( + frases_fuente - len(_LIMITE_DE_FRASE.findall(_visible(texto))) >= 2 + ): + r.marca("omision", "duda", "parece que falta parte del original") + + +def _informacion(r: _Revision, ambito: str, rol: str) -> None: + """Se cuenta, pero no se arregla ni se marca como duda.""" + largo_fuente, largo = len(_visible(r.fuente).strip()), len(_visible(r.texto).strip()) + if ambito == "ui" and largo > _FACTOR_LARGO * largo_fuente + _MARGEN_LARGO: + r.marca("largo", "info", "mucho más largo que el original") + if rol == "nombre": + # El juego escribe los nombres con solo la primera en mayúscula, pero el usuario quiere conservar las + # mayúsculas de los términos del universo del pack («Anillo Cuántico»): solo se informa. + capitalizadas = [p for p in _PALABRA.findall(_visible(r.texto))[1:] if p[:1].isupper() and not p.isupper()] + del_original = set(_PALABRA.findall(_visible(r.fuente))) + if any(p not in del_original for p in capitalizadas): + r.marca("mayusculas_titulo", "info", "mayúsculas como en inglés («Espada de Diamante»)") + + +def revisar( + original: str, traduccion: str, *, ambito: str = "ui", dialecto: str = "es_mx", rol: str = "" +) -> tuple[str, list[Hallazgo]]: + """La traducción con los arreglos seguros aplicados y la lista de lo que se encontró.""" + m = enmascarar(traduccion) + r = _Revision(enmascarar(original).texto, m.texto) + _espacios(r) + _signos(r) + _comillas_y_fechas(r, dialecto) + _dudas(r) + _informacion(r, ambito, rol) + restaurado = desenmascarar(r.texto, m.tokens) + return (restaurado if restaurado is not None else traduccion), r.hallazgos + + +def dudas(hallazgos: list[Hallazgo]) -> list[str]: + """Los códigos de las dudas, sin repetir y en orden.""" + return list(dict.fromkeys(h.codigo for h in hallazgos if h.gravedad == "duda")) + + +def arreglos(hallazgos: list[Hallazgo]) -> list[str]: + return [h.codigo for h in hallazgos if h.arreglado] diff --git a/tests/test_argumentos_y_codigos.py b/tests/test_argumentos_y_codigos.py new file mode 100644 index 0000000..2129282 --- /dev/null +++ b/tests/test_argumentos_y_codigos.py @@ -0,0 +1,135 @@ +"""Errores que rompen el juego: argumentos al revés, escapes rotos, formatos fuera de orden y códigos inventados.""" + +from __future__ import annotations + +import itertools + +from hypothesis import given +from hypothesis import strategies as st + +from traductor_es.formatos import javascript +from traductor_es.motores.base import Lote +from traductor_es.nucleo.glosario import Glosario +from traductor_es.nucleo.mascara import ( + codigos_inventados, + desenmascarar, + enmascarar, + pares_en_orden, + posicionar_argumentos, +) +from traductor_es.nucleo.memoria import Memoria +from traductor_es.nucleo.traductor import Traductor + +# ---------------------------------------------------------------- argumentos + + +def _restaurar(original: str, crudo: str) -> str | None: + m = enmascarar(original) + posicionados = posicionar_argumentos(crudo, m.tokens) + assert posicionados is not None + return desenmascarar(crudo, posicionados[0]) + + +def test_argumentos_al_reves_se_numeran() -> None: + # «%s was slain by %s»: el modelo puso primero al asesino; sin numerar, el juego invertiría a los dos + assert _restaurar("%s was slain by %s", "⟦1⟧ mató a ⟦0⟧") == "%2$s mató a %1$s" + + +def test_en_orden_no_se_tocan() -> None: + assert _restaurar("%s was slain by %s", "⟦0⟧ fue asesinado por ⟦1⟧") == "%s fue asesinado por %s" + + +def test_con_formato_y_ya_numerados() -> None: + assert _restaurar("Gave %d %s", "⟦1⟧ ×⟦0⟧") == "%2$s ×%1$d" + assert _restaurar("%2$s by %1$s", "⟦1⟧ de ⟦0⟧") == "%1$s de %2$s" # numerados: el orden es libre + + +def test_mezcla_de_numerados_y_sin_numero_no_se_arregla() -> None: + assert posicionar_argumentos("⟦1⟧ ⟦0⟧", enmascarar("%s and %2$s").tokens) is None + + +@given(st.integers(min_value=2, max_value=4).flatmap(lambda n: st.permutations(list(range(n))))) +def test_cualquier_orden_lleva_cada_valor_a_su_sitio(orden: list[int]) -> None: + n = len(orden) + original = " ".join(f"v{i} %s" for i in range(n)) + crudo = " ".join(f"v{i} ⟦{i}⟧" for i in orden) # palabra y valor se mueven juntos + restaurado = _restaurar(original, crudo) + assert restaurado is not None + if orden == list(range(n)): + assert restaurado == original + else: + for i in range(n): # el valor i del original sigue junto a su palabra, con su número + assert f"v{i} %{i + 1}$s" in restaurado + + +def test_todas_las_permutaciones_de_tres() -> None: + for orden in itertools.permutations(range(3)): + crudo = " ".join(f"⟦{i}⟧" for i in orden) + restaurado = _restaurar("%s %s %s", crudo) + esperado = " ".join(f"%{i + 1}$s" for i in orden) if list(orden) != [0, 1, 2] else "%s %s %s" + assert restaurado == esperado + + +# ---------------------------------------------------------------- pares de formato y códigos inventados + + +def test_pares_de_formato() -> None: + tokens = enmascarar("the §aIron§r §bSword§r").tokens + assert pares_en_orden("la ⟦2⟧Espada⟦3⟧ de ⟦0⟧Hierro⟦1⟧", tokens) # mover un par entero vale + assert not pares_en_orden("la ⟦1⟧Espada⟦0⟧ de ⟦2⟧Hierro⟦3⟧", tokens) # el cierre antes de su apertura no + libro = enmascarar("Press $(k:use) to $(l)open$() the $(item)book$().").tokens + assert pares_en_orden("Pulsa ⟦0⟧ para ⟦1⟧abrir⟦2⟧ el ⟦3⟧libro⟦4⟧.", libro) + assert not pares_en_orden("Pulsa ⟦0⟧ para ⟦2⟧abrir⟦1⟧ el ⟦3⟧libro⟦4⟧.", libro) + + +def test_codigos_inventados() -> None: + tokens = enmascarar("Deals %s damage").tokens + assert not codigos_inventados("Hace %s de daño", tokens) + assert codigos_inventados("Hace §c%s de daño", tokens) # el modelo agregó un color + assert codigos_inventados("Hace %s de daño %s", tokens) # y aquí un argumento + assert not codigos_inventados("Hace %s de daño (50 %%)", tokens, porcentajes=1) + + +# ---------------------------------------------------------------- escapes \uXXXX + + +def test_escapes_unicode_visibles_se_decodifican_y_los_de_control_se_protegen() -> None: + cadena = javascript.escanear("p.tell('\\u00a7cWarning: \\u00e9xito \\u0007')")[0] + assert cadena.texto.startswith("§cWarning: éxito ") + m = enmascarar(cadena.texto) + assert m.texto.startswith("⟦0⟧Warning: éxito ") and m.tokens[0] == "§c" + assert len(m.tokens) == 2 and m.tokens[1].endswith("u0007") # el de control, entero + + +# ---------------------------------------------------------------- en el traductor + + +class _Fijo: + nombre = "fijo" + + def __init__(self, respuesta: str) -> None: + self.respuesta = respuesta + + def traducir_lote(self, lote: Lote) -> dict[str, str]: + return {e.id: self.respuesta for e in lote.entradas} + + +def _traducir(respuesta: str, texto: str, ambito: str = "ui") -> tuple[dict[str, str], dict[str, str]]: + with Memoria(":memory:") as mem: + r = Traductor(_Fijo(respuesta), mem, Glosario()).traducir([texto], ambito) + return r.traducciones, r.rechazados + + +def test_en_un_archivo_de_idioma_se_numeran() -> None: + traducciones, _ = _traducir("⟦1⟧ mató a ⟦0⟧ con su espada", "%s was slain by %s with a sword") + assert traducciones == {"%s was slain by %s with a sword": "%2$s mató a %1$s con su espada"} + + +def test_en_un_script_no_se_puede_y_queda_en_ingles() -> None: + traducciones, rechazados = _traducir("⟦1⟧ mató a ⟦0⟧ con su espada", "%s was slain by %s with a sword", "script") + assert traducciones == {} and rechazados == {"%s was slain by %s with a sword": "orden de argumentos"} + + +def test_un_porcentaje_suelto_se_escapa() -> None: + traducciones, _ = _traducir("Aumenta un 50 % el daño de ⟦0⟧", "Increases %s damage by half") + assert traducciones == {"Increases %s damage by half": "Aumenta un 50 %% el daño de %s"} diff --git a/tests/test_qa.py b/tests/test_qa.py new file mode 100644 index 0000000..e5b9570 --- /dev/null +++ b/tests/test_qa.py @@ -0,0 +1,109 @@ +"""Control de calidad determinista: arreglos seguros, dudas y textos del juego que no deben marcarse.""" + +from __future__ import annotations + +import pytest + +from traductor_es.validacion.qa import arreglos, dudas, revisar + + +def _arreglo(original: str, traduccion: str, dialecto: str = "es_mx") -> tuple[str, list[str]]: + texto, hallazgos = revisar(original, traduccion, dialecto=dialecto) + return texto, arreglos(hallazgos) + + +# ---------------------------------------------------------------- arreglos + + +@pytest.mark.parametrize( + ("original", "traduccion", "esperado", "codigo"), + [ + ("Are you sure?", "Estás seguro?", "¿Estás seguro?", "signo_apertura"), + ("Watch out!", "§cCuidado!", "§c¡Cuidado!", "signo_apertura"), # después del código de color + ("Energy:", "Energía", "Energía:", "puntuacion_final"), + ("Loading...", "Cargando…", "Cargando...", "puntuacion_final"), # el juego usa «...» + ("Waiting...", "Esperando", "Esperando...", "puntuacion_final"), + ("Iron Gear", "Engranaje de hierro", "Engranaje de hierro", None), # nada que arreglar + ("Place it here", "Colócalo aquí", "Colócalo aquí", "espacios"), + ("Place it, then wait", "Colócalo , luego espera", "Colócalo, luego espera", "espacios"), + ("Craft the table", "Fabrica la la mesa", "Fabrica la mesa", "palabra_doble"), + ("Opens on Monday", "Abre el Lunes", "Abre el lunes", "mes_dia"), + ], +) +def test_arreglos(original: str, traduccion: str, esperado: str, codigo: str | None) -> None: + texto, hechos = _arreglo(original, traduccion) + assert texto == esperado + assert hechos == ([codigo] if codigo else []) + + +def test_comillas_segun_el_dialecto() -> None: + assert _arreglo('Press "E"', 'Pulsa "E"', "es_es")[0] == "Pulsa «E»" + assert _arreglo('Press "E"', "Presiona «E»", "es_mx")[0] == 'Presiona "E"' + # Si el original no tiene comillas, no se toca lo que el modelo destacó + assert _arreglo("Press E", "Presiona «E»", "es_mx")[0] == "Presiona «E»" + + +def test_los_arreglos_no_tocan_los_codigos() -> None: + # «$(l)» y «%s» se protegen: los espacios y signos se arreglan alrededor, no dentro + texto, _ = _arreglo("Use $(l)this$() on %s?", "Usa $(l)esto$() en %s?") + assert texto == "¿Usa $(l)esto$() en %s?" + + +def test_un_texto_en_ingles_no_se_decora() -> None: + texto, hallazgos = revisar("Welcome back, %s!", "«ES» Welcome back, %s!") + assert "¡" not in texto and not arreglos(hallazgos) + + +def test_varias_frases_sin_signo_de_apertura_quedan_como_duda() -> None: + texto, hallazgos = revisar("Done. Want more?", "Listo. Quieres más?") + assert texto == "Listo. Quieres más?" and dudas(hallazgos) == ["signo_apertura"] + + +# ---------------------------------------------------------------- dudas + + +@pytest.mark.parametrize( + ("original", "traduccion", "codigo"), + [ + ("Costs 64 coins", "Cuesta 32 monedas", "numeros"), + ("Tier 3 machine", "Máquina de nivel III", "numeros"), + ("Hold (shift) to see", "Mantén (shift para ver", "pareja"), + ("Place the block", "Coloque el bloque", "usted"), + ("Click on the block", "Haz clic on the bloque", "ingles"), + ( + "Mine the ore first. Then smelt it. Finally craft the tool.", + "Mina primero el mineral.", + "omision", + ), + ], +) +def test_dudas(original: str, traduccion: str, codigo: str) -> None: + _, hallazgos = revisar(original, traduccion) + assert codigo in dudas(hallazgos) + + +@pytest.mark.parametrize( + ("original", "traduccion"), + [ + # Convenciones del español del propio juego: no deben marcarse + ("Gave %s %s to %s", "%3$s recibió %1$s de %2$s"), + ("Say that 3 times fast", "Dilo tres veces rápido"), # cifra escrita con letras + ("Costs 1,000 coins", "Cuesta 1.000 monedas"), # otro separador de miles + ("Used in machines (e.g. the Charger). Very useful.", "Se usa en máquinas (p. ej., el cargador). Muy útil."), + ("Mine the ore. Smelt it.", "Mina el mineral y fúndelo."), # unir dos frases es legítimo + ("Spawns in the End", "Aparece en el End"), + ("Crafting Table", "Mesa de trabajo"), + ("Tier I spellbooks. It also allows more.", "Grimorios de nivel I. También permite más."), + ], +) +def test_textos_correctos_no_se_marcan(original: str, traduccion: str) -> None: + texto, hallazgos = revisar(original, traduccion) + assert texto == traduccion and not dudas(hallazgos) + + +def test_mayusculas_de_titulo_en_nombres_solo_se_informan() -> None: + texto, hallazgos = revisar("Diamond Sword", "Espada de Diamante", rol="nombre") + assert texto == "Espada de Diamante" # no se cambia: puede ser un término propio del pack + assert any(h.codigo == "mayusculas_titulo" and h.gravedad == "info" for h in hallazgos) + _, sin_aviso = revisar("Witherproof Glass", "Vidrio a prueba de Wither", rol="nombre") + assert any(h.codigo == "mayusculas_titulo" for h in sin_aviso) # «Wither» es nombre propio: solo información