diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2d0daca..ee1b19a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -73,6 +73,10 @@ 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).
- **«Guardar el informe de lo que queda…» no guardaba nada**, ni desde el menú «Más» ni desde el botón del cuadro del informe.
diff --git a/docs/calidad.md b/docs/calidad.md
index dfc001f..c67cd99 100644
--- a/docs/calidad.md
+++ b/docs/calidad.md
@@ -450,6 +450,9 @@ uv run python scripts/armar_banco_misiones.py --textos 400
uv run python scripts/descargar_lang.py # también baja los libros de Patchouli en inglés y español
uv run python scripts/armar_banco_libros.py --textos 150
uv run python scripts/medir_calidad.py --banco .descargas/banco/libros.json --vanilla .descargas/vanilla
+# Grabar las respuestas (una vez, cuesta) y medir después un cambio del post-proceso contra ellas (gratis):
+uv run python scripts/medir_calidad.py --banco .descargas/banco/ui_final.json --vanilla .descargas/vanilla --grabacion .descargas/banco/grabaciones/ui_final.sqlite --repeticiones 3
+uv run python scripts/medir_calidad.py --banco .descargas/banco/ui_final.json --vanilla .descargas/vanilla --grabacion .descargas/banco/grabaciones/ui_final.sqlite --repeticiones 3 --solo-grabado
uv run python scripts/medir_calidad.py --sin-vecindad --banco .descargas/banco/misiones.json --salida build/base.json
uv run python scripts/medir_calidad.py --banco .descargas/banco/misiones.json --salida build/mejora.json
uv run python scripts/preferencia_pareada.py --a build/base.json --b build/mejora.json
diff --git a/scripts/hoja_revision.py b/scripts/hoja_revision.py
index d160cd8..4ff688a 100644
--- a/scripts/hoja_revision.py
+++ b/scripts/hoja_revision.py
@@ -82,6 +82,7 @@ def _banco(args: argparse.Namespace) -> int:
button[data-v=L].on{background:var(--leve);color:#fff;border-color:var(--leve)}
button[data-v=G].on{background:var(--grave);color:#fff;border-color:var(--grave)}
input.nota{width:100%;margin-top:8px;padding:8px;border:1px solid var(--borde);border-radius:6px;background:var(--fondo);color:var(--texto);font:inherit}
+.causa{margin-top:8px;font:inherit;padding:6px;border-radius:8px;border:1px solid var(--borde);background:var(--tarjeta);color:inherit}
.fin{display:flex;gap:8px;align-items:center;flex-wrap:wrap;margin:18px 0}
.fin .principal{background:var(--acento);color:#fff;border-color:var(--acento)}
+
`;
+ const causa = t.querySelector(".causa");
+ causa.value = (estado[i] && estado[i].c) || "";
+ causa.addEventListener("change", () => { estado[i] = {...(estado[i] || {}), c: causa.value}; guardar(); });
const nota = t.querySelector(".nota");
nota.value = (estado[i] && estado[i].n) || "";
nota.addEventListener("input", () => { estado[i] = {...(estado[i] || {}), n: nota.value}; guardar(); });
@@ -134,7 +144,7 @@ def _banco(args: argparse.Namespace) -> int:
document.getElementById("copiar").addEventListener("click", async () => {
const filas = DATOS.map((d, i) => {
const e = estado[i] || {};
- return `${i + 1}:${e.v || "-"}${e.n ? " (" + e.n.replace(/\\s+/g, " ") + ")" : ""}`;
+ return `${i + 1}:${e.v || "-"}${e.c ? "[" + e.c + "]" : ""}${e.n ?" (" + e.n.replace(/\\s+/g, " ") + ")" : ""}`;
});
const texto = "HOJA " + DATOS.length + "\\n" + filas.join("\\n");
try { await navigator.clipboard.writeText(texto); document.getElementById("aviso").textContent = "Copiado: pégalo en el chat."; }
diff --git a/scripts/medir_calidad.py b/scripts/medir_calidad.py
index 6273869..313ea78 100644
--- a/scripts/medir_calidad.py
+++ b/scripts/medir_calidad.py
@@ -19,6 +19,7 @@
from traductor_es.motores.base import Motor
from traductor_es.motores.carga import Enfriador
from traductor_es.motores.gemini import MODELO_POR_DEFECTO
+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.validacion import medicion
@@ -81,6 +82,23 @@ def main(argv: list[str] | None = None) -> int:
help="carpeta con en_us.json, es_mx.json y es_es.json del juego: sus nombres entran como oficiales (como "
"en la app) si el banco no los trae",
)
+ ap.add_argument(
+ "--grabacion",
+ type=Path,
+ default=None,
+ help="archivo SQLite donde se graban las respuestas del motor; un pedido ya grabado no se vuelve a pagar",
+ )
+ ap.add_argument(
+ "--solo-grabado",
+ action="store_true",
+ help="con --grabacion: no llamar a la API; lo que no esté grabado queda sin respuesta (mide gratis)",
+ )
+ ap.add_argument(
+ "--repeticiones",
+ type=int,
+ default=1,
+ 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("--banco", type=Path, default=RAIZ / "tests" / "datos" / "referencia_es.json")
ap.add_argument("--salida", type=Path, default=RAIZ / "build" / "medicion.json")
@@ -102,27 +120,41 @@ def main(argv: list[str] | None = None) -> int:
if args.sin_contexto:
banco.ejemplos = {}
banco.casos = [medicion.Caso(c.ambito, c.original, c.referencia) for c in banco.casos]
- resultados = medicion.medir(
- motor,
- banco,
- nombre,
- modelo,
- args.motor,
- revisar=args.revisar,
- glosario_estricto=not args.glosario_laxo,
- hilos=args.hilos or (1 if args.carga_segura else 4),
- cantidad_ejemplos=args.n_ejemplos,
- controles_de_forma=not args.sin_controles,
- )
- for m in resultados:
- print(m.tabla(), end="\n\n")
- peores = resultados[-1].ejemplos[:5]
- if peores:
- print("Más lejos de la referencia (no siempre son errores):")
- for e in peores:
- print(f" [{e['chrf']}] {e['original']}\n → {e['traduccion']}\n ref. {e['referencia']}")
- medicion.guardar(resultados, args.salida)
- print(f"\nDetalle en {args.salida}")
+ total = 0.0
+ for repeticion in range(1, max(1, args.repeticiones) + 1):
+ usado: Motor = motor
+ if args.grabacion is not None:
+ usado = MotorGrabado(motor, args.grabacion, repeticion, solo_grabado=args.solo_grabado)
+ resultados = medicion.medir(
+ usado,
+ banco,
+ nombre,
+ modelo,
+ args.motor,
+ revisar=args.revisar,
+ glosario_estricto=not args.glosario_laxo,
+ hilos=args.hilos or (1 if args.carga_segura else 4),
+ cantidad_ejemplos=args.n_ejemplos,
+ controles_de_forma=not args.sin_controles,
+ )
+ for m in resultados:
+ print(m.tabla(), end="\n\n")
+ if isinstance(usado, MotorGrabado):
+ print(f"Grabación: {usado.aciertos} pedidos grabados, {usado.pedidos} nuevos, {usado.faltantes} sin grabar")
+ usado.cerrar()
+ peores = resultados[-1].ejemplos[:5]
+ if peores and args.repeticiones == 1:
+ print("Más lejos de la referencia (no siempre son errores):")
+ for e in peores:
+ print(f" [{e['chrf']}] {e['original']}\n → {e['traduccion']}\n ref. {e['referencia']}")
+ salida = args.salida
+ if args.repeticiones > 1:
+ salida = salida.with_name(f"{salida.stem}_{repeticion}{salida.suffix}")
+ medicion.guardar(resultados, salida)
+ print(f"\nDetalle en {salida}")
+ total += sum(m.costo_real or 0.0 for m in resultados)
+ if total:
+ print(f"Gasto real en la API: US$ {total:.4f}")
return 0
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/motores/fabrica.py b/src/traductor_es/motores/fabrica.py
index 10e64e0..0354acb 100644
--- a/src/traductor_es/motores/fabrica.py
+++ b/src/traductor_es/motores/fabrica.py
@@ -31,6 +31,7 @@ def direccion_por_defecto(motor: str) -> str:
def limites_de_lote(motor: Motor) -> tuple[int, int]:
"""Tamaño de los pedidos que conviene mandarle a este motor."""
+ motor = getattr(motor, "envuelto", motor) # un motor grabado (medición) usa los límites del real
return LIMITES_LOCALES if isinstance(motor, Compatible) and motor.es_local else LIMITES_NORMALES
diff --git a/src/traductor_es/motores/gemini.py b/src/traductor_es/motores/gemini.py
index d3f2e79..b855bfd 100644
--- a/src/traductor_es/motores/gemini.py
+++ b/src/traductor_es/motores/gemini.py
@@ -110,6 +110,9 @@ def __init__(
self._reintentos = reintentos
self._temperatura = temperatura
self._con_razonamiento = True
+ #: Tokens facturados (entrada, salida con el razonamiento) en esta sesión, según lo que informa Google
+ self.uso = [0, 0]
+ self._lock_uso = threading.Lock()
#: Para el modo por lotes: se llama con el estado del trabajo mientras se espera.
self.al_esperar: Callable[[str], None] = lambda _estado: None
#: Si se activa mientras se espera un trabajo por lotes, se cancela en Google y se deja de esperar.
@@ -157,6 +160,17 @@ def _config(self, lote: Lote) -> types.GenerateContentConfig:
thinking_config=razonamiento,
)
+ def _anotar_uso(self, respuesta: Any) -> None:
+ """Suma los tokens que Google dice haber cobrado por esta respuesta (sin datos, no suma nada)."""
+ uso = getattr(respuesta, "usage_metadata", None)
+ if uso is None:
+ return
+ entrada = int(getattr(uso, "prompt_token_count", 0) or 0)
+ salida = int(getattr(uso, "candidates_token_count", 0) or 0) + int(getattr(uso, "thoughts_token_count", 0) or 0)
+ with self._lock_uso:
+ self.uso[0] += entrada
+ self.uso[1] += salida
+
def traducir_lote(self, lote: Lote) -> dict[str, str]:
espera = _ESPERA_INICIAL
for intento in range(self._reintentos):
@@ -166,6 +180,7 @@ def traducir_lote(self, lote: Lote) -> dict[str, str]:
respuesta = self._cliente.models.generate_content(
model=self.modelo, contents=usuario(lote), config=self._config(lote)
)
+ self._anotar_uso(respuesta)
return interpretar(getattr(respuesta, "text", None))
except errors.APIError as e:
fatal = explicar(e)
@@ -231,5 +246,7 @@ def _un_trabajo(self, lotes: Sequence[Lote]) -> list[dict[str, str]]:
for i in range(len(lotes)):
r = respuestas[i] if i < len(respuestas) else None
texto = getattr(getattr(r, "response", None), "text", None) if r is not None else None
+ if r is not None:
+ self._anotar_uso(getattr(r, "response", None))
salida.append(interpretar(texto))
return salida
diff --git a/src/traductor_es/motores/grabadora.py b/src/traductor_es/motores/grabadora.py
new file mode 100644
index 0000000..34038a2
--- /dev/null
+++ b/src/traductor_es/motores/grabadora.py
@@ -0,0 +1,91 @@
+"""Grabar y reproducir las respuestas de un motor, para medir cambios del proceso sin el ruido del modelo.
+
+Gemini no responde igual dos veces (en el banco de interfaz, dos corridas coinciden en ~67 % de los textos), así que
+al comparar dos versiones del proceso la variación del modelo tapa el efecto del cambio. `MotorGrabado` envuelve a
+un motor y guarda en SQLite la respuesta a cada pedido, con la clave del pedido exacto (instrucciones y textos). Si
+el pedido se repite, la respuesta sale de la grabación, sin costo y siempre igual. Un cambio que solo toca lo que se
+hace después del modelo (controles, arreglos) se mide así contra las mismas respuestas.
+
+Solo es una herramienta de medición: la app no la usa.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import sqlite3
+import threading
+from pathlib import Path
+from typing import Any, cast
+
+from .base import Lote, Motor
+from .instrucciones import sistema, usuario
+
+
+def clave_del_pedido(motor: str, lote: Lote, repeticion: int = 0) -> str:
+ """Huella del pedido: el mismo motor, las mismas instrucciones y los mismos textos dan la misma clave."""
+ datos = "\x00".join((str(repeticion), motor, sistema(lote), usuario(lote)))
+ return hashlib.sha256(datos.encode("utf-8")).hexdigest()
+
+
+class MotorGrabado:
+ """Un motor cuyas respuestas se graban y se reutilizan.
+
+ `repeticion` separa corridas que deben ser independientes (la 1.ª, la 2.ª…): cada una tiene su propia grabación.
+ Con `solo_grabado`, un pedido que no está grabado no va a la API: se devuelve vacío (el texto se rechaza, como si
+ el motor no hubiera respondido) y se cuenta en `faltantes`.
+ """
+
+ def __init__(self, motor: Motor, ruta: Path, repeticion: int = 0, solo_grabado: bool = False) -> None:
+ self.envuelto = motor
+ self.repeticion = repeticion
+ self.solo_grabado = solo_grabado
+ self.aciertos = 0 #: respuestas que salieron de la grabación
+ self.pedidos = 0 #: respuestas que se pidieron al motor (y se grabaron)
+ self.faltantes = 0 #: pedidos sin grabación con `solo_grabado`
+ ruta.parent.mkdir(parents=True, exist_ok=True)
+ self._lock = threading.Lock()
+ self._db = sqlite3.connect(ruta, check_same_thread=False)
+ self._db.execute("CREATE TABLE IF NOT EXISTS respuestas (clave TEXT PRIMARY KEY, salida TEXT NOT NULL)")
+ self._db.commit()
+
+ @property
+ def nombre(self) -> str:
+ return self.envuelto.nombre
+
+ @property
+ def uso(self) -> list[int] | None:
+ """Tokens de entrada y salida que el motor real facturó (lo grabado no cuenta)."""
+ return cast("list[int] | None", getattr(self.envuelto, "uso", None))
+
+ def traducir_lote(self, lote: Lote) -> dict[str, str]:
+ clave = clave_del_pedido(self.nombre, lote, self.repeticion)
+ with self._lock:
+ fila = self._db.execute("SELECT salida FROM respuestas WHERE clave=?", (clave,)).fetchone()
+ if fila is not None:
+ self.aciertos += 1
+ datos: Any = json.loads(str(fila[0]))
+ return {str(k): str(v) for k, v in cast("dict[str, Any]", datos).items()}
+ if self.solo_grabado:
+ self.faltantes += 1
+ return {}
+ salida = self.envuelto.traducir_lote(lote)
+ if salida: # una respuesta vacía (error de red, cuota) no se graba: la próxima vez se vuelve a pedir
+ with self._lock:
+ self._db.execute(
+ "INSERT OR REPLACE INTO respuestas (clave, salida) VALUES (?, ?)",
+ (clave, json.dumps(salida, ensure_ascii=False)),
+ )
+ self._db.commit()
+ self.pedidos += 1
+ return salida
+
+ def cerrar(self) -> None:
+ with self._lock:
+ self._db.close()
+
+ def __enter__(self) -> MotorGrabado:
+ return self
+
+ def __exit__(self, *_: object) -> None:
+ self.cerrar()
diff --git a/src/traductor_es/nucleo/ejemplos.py b/src/traductor_es/nucleo/ejemplos.py
index 5d17d35..4c793be 100644
--- a/src/traductor_es/nucleo/ejemplos.py
+++ b/src/traductor_es/nucleo/ejemplos.py
@@ -80,6 +80,8 @@ def agregar(self, ingles: Mapping[str, object], traducido: Mapping[str, object])
def parecidos(self, textos: Iterable[str], cantidad: int | None = None, largo_total: int = 700) -> dict[str, str]:
"""Los pares más relevantes para estos textos, sin los textos mismos."""
cantidad = self.cantidad if cantidad is None else cantidad
+ if cantidad <= 0: # sin esto se colaba un ejemplo: el tope se miraba después de agregar el primero
+ return {}
propios = {t.strip() for t in textos}
buscadas = Counter(p for t in propios for p in _palabras(t))
with self._lock:
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]*\)|[A-Za-z][A-Za-z0-9]*>")
+#: 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..a45fb8a 100644
--- a/src/traductor_es/nucleo/traductor.py
+++ b/src/traductor_es/nucleo/traductor.py
@@ -20,7 +20,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]
@@ -311,7 +322,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)
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 +346,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)
def _procesar(
self,
@@ -345,6 +357,7 @@ def _procesar(
resultado: Resultado,
tolerante: bool = False,
glosario: Mapping[str, str] | None = None,
+ ambito: str = "ui",
) -> dict[str, str]:
buenos: dict[str, str] = {}
rechazados: dict[str, str] = {}
@@ -355,9 +368,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:
@@ -387,6 +400,33 @@ def _procesar(
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/validacion/medicion.py b/src/traductor_es/validacion/medicion.py
index eed3581..b7549e5 100644
--- a/src/traductor_es/validacion/medicion.py
+++ b/src/traductor_es/validacion/medicion.py
@@ -18,10 +18,11 @@
from collections.abc import Iterable, Mapping
from dataclasses import asdict, dataclass, field
from pathlib import Path
-from typing import Any
+from typing import Any, cast
from ..motores import fabrica
from ..motores.base import Motor
+from ..motores.gemini import PRECIOS
from ..nucleo import terminos as terminos_repetidos
from ..nucleo.ejemplos import CANTIDAD_EN_LA_APP, Ejemplos
from ..nucleo.glosario import Glosario
@@ -204,6 +205,8 @@ class Medicion:
descanso: float = 0.0 #: segundos de pausa de la carga segura (motores locales)
traducciones: list[dict[str, str]] = field(default_factory=list[dict[str, str]]) #: todas, para juzgarlas
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)
@property
def porcentaje(self) -> float:
@@ -250,6 +253,16 @@ def tabla(self) -> str:
else []
),
("Costo estimado", "desconocido" if self.costo_estimado is None else f"US$ {self.costo_estimado:.3f}"),
+ *(
+ [
+ (
+ "Costo real",
+ f"US$ {self.costo_real:.4f} ({self.tokens_reales[0]} + {self.tokens_reales[1]} tokens)",
+ )
+ ]
+ if self.costo_real is not None and self.tokens_reales is not None
+ else []
+ ),
(
"Tiempo",
f"{self.segundos:.0f} s" + (f" (de ellos {self.descanso:.0f} s de descanso)" if self.descanso else ""),
@@ -302,6 +315,25 @@ def _medir(
)
+def _uso(motor: Motor) -> list[int]:
+ """Tokens (entrada, salida) que el motor lleva facturados; [0, 0] si no los informa."""
+ uso: object = getattr(motor, "uso", None)
+ if not isinstance(uso, list):
+ return [0, 0]
+ valores = cast("list[int]", uso)
+ return [int(valores[0]), int(valores[1])] if len(valores) == 2 else [0, 0]
+
+
+def _gasto(motor: Motor, antes: list[int], modelo: str) -> tuple[tuple[int, int] | None, float | None]:
+ """(tokens, US$) gastados desde `antes`, si el motor los informa y se conoce el precio del modelo."""
+ if getattr(motor, "uso", None) is None:
+ return None, None
+ ahora = _uso(motor)
+ tokens = (ahora[0] - antes[0], ahora[1] - antes[1])
+ precio = PRECIOS.get(modelo)
+ return tokens, (None if precio is None else (tokens[0] * precio[0] + tokens[1] * precio[1]) / 1e6)
+
+
def medir(
motor: Motor,
banco: Banco,
@@ -339,6 +371,7 @@ def medir(
if caso.pista:
pistas[caso.original] = caso.pista
inicio = time.perf_counter()
+ uso_antes = list(_uso(motor))
resultados = {ambito: traductor.traducir(textos, ambito, pistas) for ambito, textos in por_ambito.items()}
segundos = time.perf_counter() - inicio
informe = Informe(
@@ -349,6 +382,7 @@ 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].rechazos = dict(
Counter(m.split(":")[0] for r in resultados.values() for m in r.rechazados.values())
)
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_grabadora.py b/tests/test_grabadora.py
new file mode 100644
index 0000000..d0f7acb
--- /dev/null
+++ b/tests/test_grabadora.py
@@ -0,0 +1,67 @@
+"""Grabar y reproducir respuestas del motor: lo mismo pedido dos veces sale igual y no se vuelve a pagar."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from traductor_es.motores.base import Entrada, Lote
+from traductor_es.motores.compatible import PERFILES, Compatible
+from traductor_es.motores.fabrica import LIMITES_LOCALES, limites_de_lote
+from traductor_es.motores.grabadora import MotorGrabado, clave_del_pedido
+from traductor_es.motores.simulador import Simulador
+from traductor_es.nucleo.ejemplos import Ejemplos
+from traductor_es.validacion import medicion
+
+BANCO = Path(__file__).parent / "datos" / "referencia_es.json"
+
+
+def _lote(*textos: str) -> Lote:
+ return Lote(tuple(Entrada(str(i), t) for i, t in enumerate(textos)), "ui", "español")
+
+
+def test_lo_grabado_se_reutiliza_y_no_llega_al_motor(tmp_path: Path) -> None:
+ ruta = tmp_path / "g.sqlite"
+ with MotorGrabado(Simulador(), ruta) as g:
+ assert g.traducir_lote(_lote("Iron Gear")) == {"0": "«ES» Iron Gear"}
+ otro = Simulador()
+ with MotorGrabado(otro, ruta) as g2:
+ assert g2.traducir_lote(_lote("Iron Gear")) == {"0": "«ES» Iron Gear"}
+ assert otro.lotes_recibidos == [] and (g2.aciertos, g2.pedidos) == (1, 0)
+
+
+def test_cada_repeticion_tiene_su_grabacion_y_solo_grabado_no_llama(tmp_path: Path) -> None:
+ ruta = tmp_path / "g.sqlite"
+ with MotorGrabado(Simulador(), ruta, repeticion=1) as g:
+ g.traducir_lote(_lote("Iron Gear"))
+ otro = Simulador()
+ with MotorGrabado(otro, ruta, repeticion=2, solo_grabado=True) as g2:
+ assert g2.traducir_lote(_lote("Iron Gear")) == {} # la 2.ª repetición no está grabada
+ assert g2.faltantes == 1 and otro.lotes_recibidos == []
+ assert clave_del_pedido("m", _lote("a"), 1) != clave_del_pedido("m", _lote("a"), 2)
+
+
+def test_un_motor_grabado_usa_los_limites_del_real(tmp_path: Path) -> None:
+ local = Compatible(PERFILES["personalizado"], "m", direccion="http://127.0.0.1:8089/v1")
+ with MotorGrabado(local, tmp_path / "g.sqlite") as g:
+ assert limites_de_lote(g) == LIMITES_LOCALES
+
+
+def test_sin_ejemplos_no_se_cuela_ninguno() -> None:
+ pares = {"Iron Gear": "Engranaje de hierro", "Iron Plate": "Placa de hierro"}
+ sin = Ejemplos(cantidad=0)
+ sin.agregar_pares(pares)
+ assert sin.parecidos(["Iron Ingot"]) == {}
+ con_uno = Ejemplos(cantidad=1)
+ con_uno.agregar_pares(pares)
+ assert len(con_uno.parecidos(["Iron Ingot"])) == 1
+
+
+def test_reproducir_un_banco_da_lo_mismo_con_varios_hilos(tmp_path: Path) -> None:
+ banco = medicion.Banco.leer(BANCO)
+ ruta = tmp_path / "g.sqlite"
+ with MotorGrabado(Simulador(), ruta, 1) as grabado:
+ primera = medicion.medir(grabado, banco, "s", "", "simulador", hilos=4)[0]
+ with MotorGrabado(Simulador(), ruta, 1, solo_grabado=True) as reproducido:
+ segunda = medicion.medir(reproducido, banco, "s", "", "simulador", hilos=4)[0]
+ assert reproducido.faltantes == 0 and reproducido.pedidos == 0
+ assert segunda.traducidos == primera.traducidos and segunda.chrf == primera.chrf