diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2d0daca..2e2dade 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -73,6 +73,7 @@ Todos los cambios importantes de ModpackES quedan en este archivo. El formato si
### Corregido
+- **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/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/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_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