diff --git a/CHANGELOG.md b/CHANGELOG.md index ee35d6b..f040c96 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -61,6 +61,7 @@ Todos los cambios importantes de ModpackES quedan en este archivo. El formato si ### Cambiado +- **Libros más fieles al original:** el pedido de libros ya no dice «Escribe de forma clara y natural». Esa frase empujaba al modelo a reescribir en vez de traducir: sin ella, el chrF del banco de libros subió 1,45 (IC 0,80 a 2,12). Vale para todos los libros guía, en JSON o en archivos de idioma. - **La memoria distingue cada modpack y recuerda lo dudoso:** - Cada traducción se guarda con su modpack y con su calidad: «ok», o el motivo por el que se aceptó con dudas. - Un modpack siempre usa lo suyo. De otro modpack solo usa lo que quedó bien: un término del glosario que no se cumplió en un pack ya no se copia a todos los demás. @@ -98,6 +99,7 @@ Todos los cambios importantes de ModpackES quedan en este archivo. El formato si ### Corregido +- **Los libros guía que viven en los archivos de idioma se traducían como interfaz.** Desde Patchouli 1.20 casi todos los libros usan claves de idioma (`"i18n": true`), igual que Modonomicon, y la app los mandaba al motor como textos de menú, sueltos. Ahora sus claves («occultism.book.entries…», «…guide.entry…») se traducen como libro, con el título de la entrada y el texto anterior como contexto, y entran en la revisión de misiones y libros. Los nombres de objetos y los textos de menús o tooltips siguen como interfaz. Lo ya traducido de esas claves se vuelve a pedir una vez, con el tono de libro. - **El glosario exigía términos donde la palabra tenía otro sentido:** «lead the way» pedía «Correa», «the power signal» pedía «Poder» y «the target» pedía «Diana». Ahora la app mira en el inglés y el español del juego y de los mods cómo se traduce cada palabra cuando va en minúscula. Si casi nunca sale con el término del glosario, ese término solo se manda y se exige cuando el texto lo usa como nombre: es todo el texto, va con mayúscula a mitad de frase o el texto es un nombre en estilo título. Las palabras que sí se traducen igual («fire» → «fuego») se siguen exigiendo, y los términos del usuario siempre. - **Términos de un mod a medio traducir** («Almacen Portable de Energía», «slot de los Muslos») ya no entran en el glosario: se descarta el término que deja en español una palabra inglesa que no sale en ningún texto en español del juego ni de los mods. Los nombres de los mods de la instancia («estilo Create») no cuentan. - **Artículo con el género equivocado** al cambiar un término que quedó en inglés: «Usa el Wrench» pasa a «Usa la Llave inglesa», no a «el Llave inglesa». Si no se sabe el género, no se cambia y queda como duda. diff --git a/docs/calidad.md b/docs/calidad.md index ab0fa10..ba52c57 100644 --- a/docs/calidad.md +++ b/docs/calidad.md @@ -547,6 +547,29 @@ corridas, US$ 0,11: - Coincide con la investigación: elegir entre salidas ayuda sobre todo cuando el modelo duda más. Por eso el máximo queda como opción y el perfil por defecto es el equilibrado. +## 15 de noviembre de 2026 · libros guía en los archivos de idioma, y un tono que estorbaba + +Desde Patchouli 1.20 casi todos los libros guardan su texto en los archivos de idioma (`"i18n": true`), igual que +Modonomicon, y la app los traducía como textos de interfaz. Ahora sus claves se traducen como libro, con el título de +la entrada y el texto anterior como contexto. + +Al medirlo apareció otra cosa: con el tono de libro de entonces («Escribe de forma clara y natural»), los 116 textos +del banco salían peor que como interfaz. La frase empujaba a reescribir. Se quitó: el tono de libro ahora solo +describe qué son los textos, como el de interfaz. + +Gemini 3.8 Flash, dos corridas por condición (US$ 0,15 en total): + +| Banco de libros | chrF (corridas 1 y 2) | +|---|---| +| Como interfaz (lo que pasaba con las claves de idioma) | 68,3 · 67,6 | +| Como libro, con «clara y natural» | 66,6 · 67,6 | +| Como libro, sin esa frase (ahora) | 68,8 · 68,3 | + +| Comparación pareada | Diferencia | +|---|---| +| Sin la frase contra con la frase | **+1,45** (IC 95 %: +0,80 a +2,12) → mejora | +| Sin la frase contra como interfaz | +0,60 (IC 95 %: −0,03 a +1,28), no se distingue del ruido | + ## Cómo repetirlo ``` diff --git a/src/traductor_es/modulos/base.py b/src/traductor_es/modulos/base.py index 475ec46..52391a6 100644 --- a/src/traductor_es/modulos/base.py +++ b/src/traductor_es/modulos/base.py @@ -3,7 +3,7 @@ from __future__ import annotations import re -from collections.abc import Callable, Mapping, Sequence +from collections.abc import Callable, Iterable, Mapping, Sequence from dataclasses import dataclass, field from pathlib import Path from typing import Protocol @@ -69,6 +69,8 @@ def pack_listo(self) -> PackSalida: class Pieza: texto: str pista: str = "" + #: Otro ámbito que el del módulo (vacío: el del módulo). Lo usan las claves de libro del módulo de mods. + ambito: str = "" @dataclass(slots=True) @@ -127,7 +129,7 @@ def con_vecindad(piezas: Sequence[Pieza], es_titulo: Callable[[Pieza], bool]) -> partes.append(f"dentro de «{titulo}»") if anterior: partes.append(f"viene después de «{anterior}»") - salida.append(Pieza(p.texto, " · ".join(partes))) + salida.append(Pieza(p.texto, " · ".join(partes), p.ambito)) anterior = _recortar(p.texto) return salida @@ -152,9 +154,32 @@ def reunir_pistas(piezas: list[Pieza]) -> dict[str, str]: return {texto: " | ".join(vistas) for texto, vistas in por_texto.items()} +def por_ambito(piezas: Iterable[Pieza], ambito: str) -> dict[str, list[Pieza]]: + """Las piezas por ámbito (el suyo o el del módulo), en orden: cada ámbito se traduce con su tono.""" + grupos: dict[str, list[Pieza]] = {} + for p in piezas: + grupos.setdefault(p.ambito or ambito, []).append(p) + return grupos + + +def ambito_de(modulo: Modulo, texto: str) -> str: + """El ámbito con que se traduce un texto del módulo (el del módulo, salvo que el módulo diga otro).""" + propio = getattr(modulo, "ambito_de", None) + return str(propio(texto)) if callable(propio) else modulo.ambito + + +def pendientes_de(traductor: Traductor, modulo: Modulo, textos: Iterable[str]) -> list[str]: + """Lo que habría que mandar al motor de esos textos del módulo, cada uno en su ámbito.""" + grupos: dict[str, list[str]] = {} + for t in textos: + grupos.setdefault(ambito_de(modulo, t), []).append(t) + return [n for ambito, del_ambito in grupos.items() for n in traductor.pendientes(del_ambito, ambito)] + + def traducir_modulo(modulo: Modulo, traductor: Traductor) -> Resumen: """Recolecta los textos del módulo, los traduce (memoria, glosario o motor) y escribe el resultado.""" - piezas = modulo.recolectar() - pistas = reunir_pistas(piezas) - resultado = traductor.traducir([p.texto for p in piezas], modulo.ambito, pistas) - return modulo.escribir(resultado.traducciones) + traducciones: dict[str, str] = {} + for ambito, piezas in por_ambito(modulo.recolectar(), modulo.ambito).items(): + resultado = traductor.traducir([p.texto for p in piezas], ambito, reunir_pistas(piezas)) + traducciones.update(resultado.traducciones) + return modulo.escribir(traducciones) diff --git a/src/traductor_es/modulos/libros.py b/src/traductor_es/modulos/libros.py index 0da99b2..bad998a 100644 --- a/src/traductor_es/modulos/libros.py +++ b/src/traductor_es/modulos/libros.py @@ -2,7 +2,8 @@ Todos buscan primero el archivo en el idioma del juego y, si no está, usan el inglés archivo por archivo (comprobado en el código de cada mod). Por eso se escriben solo los archivos que faltan en cada variante. -Modonomicon y los libros de Patchouli con `i18n` usan claves de idioma: los traduce el módulo de mods. +Modonomicon y los libros de Patchouli con `i18n` usan claves de idioma: los traduce el módulo de mods, con +el ámbito de libro (ver `mods.es_clave_de_libro`). """ from __future__ import annotations diff --git a/src/traductor_es/modulos/mods.py b/src/traductor_es/modulos/mods.py index 8d1b440..d345af4 100644 --- a/src/traductor_es/modulos/mods.py +++ b/src/traductor_es/modulos/mods.py @@ -2,11 +2,12 @@ from __future__ import annotations +import re from collections.abc import Mapping from pathlib import Path from ..fuentes.recursos import Pendiente -from .base import Contexto, Pieza, Resumen, contar +from .base import Contexto, Pieza, Resumen, con_vecindad, contar from .cambios import Lugar AMBITO = "ui" @@ -159,6 +160,29 @@ def pista_con_contexto( return " · ".join(partes) +#: Ámbito de los textos de libros que viven en los archivos de idioma (Patchouli con `i18n`, Modonomicon…). +AMBITO_LIBRO = "libro" +#: Una clave de libro tiene uno de estos tramos («mysticalagriculture.guide.entry…», «occultism.book.…»). +_CLAVE_DE_LIBRO = re.compile(r"(^|[._])(book|books|guide|guidebook|lexicon|codex|journal|manual)([._]|$)", re.I) +_NO_ES_LIBRO = ("options.", "config.", "key.", "gui.", "tooltip.", "item.", "block.", "itemgroup.", "creativetab.") +#: Un texto de libro de hasta estas palabras y sin punto final es un título (de entrada, de página o de categoría). +_PALABRAS_TITULO = 6 + + +def es_clave_de_libro(clave: str) -> bool: + """¿La clave es texto de un libro guía («occultism.book.entries.ritual.page1»)? No los nombres de objetos ni los + textos de menús o tooltips («item.m.guide_book», «gui.m.book_title»).""" + bajo = clave.lower() + return bool(_CLAVE_DE_LIBRO.search(bajo)) and not bajo.startswith(_NO_ES_LIBRO) and not es_nombre(clave) + + +def _es_titulo_de_libro(p: Pieza, clave: str) -> bool: + texto = p.texto.strip() + return clave.lower().endswith((".name", ".title", ".category")) or ( + len(texto.split()) <= _PALABRAS_TITULO and not texto.endswith((".", "!", "?", ":")) + ) + + def _salto_nuevo(original: str, traduccion: str) -> bool: return any(c in traduccion and c not in original for c in ("\r", "\n")) @@ -170,6 +194,7 @@ class Mods: def __init__(self, ctx: Contexto) -> None: self.ctx = ctx self._pendientes: list[Pendiente] = [] + self._ambitos: dict[str, str] = {} #: texto → ámbito, para los que no son de interfaz def detectar(self) -> bool: return True @@ -187,14 +212,33 @@ def recolectar(self) -> list[Pieza]: juego = textos_del_juego(tabla.textos("minecraft", "en_us"), tabla.textos("minecraft", self.ctx.dialecto)) por_mod: dict[str, Mapping[str, str]] = {} piezas: list[Pieza] = [] + # Los libros guía de los archivos de idioma van como libro, con el título y el texto anterior (por libro) + libros: dict[str, list[tuple[Pieza, str]]] = {} for p in self._pendientes: if p.existente is None: textos = por_mod.get(p.namespace) if textos is None: textos = por_mod[p.namespace] = tabla.textos(p.namespace, "en_us") - piezas.append(Pieza(p.ingles, pista_con_contexto(p.namespace, p.clave, textos, juego))) + if es_clave_de_libro(p.clave): + libros.setdefault(p.namespace, []).append((Pieza(p.ingles, f"{p.namespace}: {p.clave}"), p.clave)) + else: + piezas.append(Pieza(p.ingles, pista_con_contexto(p.namespace, p.clave, textos, juego))) + self._ambitos = {} + for del_libro in libros.values(): + claves = {id(pieza): clave for pieza, clave in del_libro} + con_contexto = con_vecindad( + [pieza for pieza, _ in del_libro], + lambda q, claves=claves: _es_titulo_de_libro(q, claves.get(id(q), "")), + ) + for pieza in con_contexto: + piezas.append(Pieza(pieza.texto, pieza.pista, AMBITO_LIBRO)) + self._ambitos[pieza.texto] = AMBITO_LIBRO return piezas + def ambito_de(self, texto: str) -> str: + """El ámbito de un texto que juntó `recolectar` («libro» para los libros guía; si no, interfaz).""" + return self._ambitos.get(texto, AMBITO) + def lugares(self) -> list[Lugar]: """Por mod (espacio de nombres), {clave: inglés} de lo que la app traduce (tras `recolectar`).""" por_mod: dict[str, dict[str, str]] = {} diff --git a/src/traductor_es/motores/instrucciones.py b/src/traductor_es/motores/instrucciones.py index 433508d..1f99df7 100644 --- a/src/traductor_es/motores/instrucciones.py +++ b/src/traductor_es/motores/instrucciones.py @@ -16,8 +16,7 @@ "Deben ser breves; los nombres van con mayúscula inicial como en el original.", "mision": "Son misiones de un modpack: títulos, subtítulos y descripciones que guían al jugador. " "Usa un tono cercano y tutea al jugador.", - "libro": "Son páginas de libros guía dentro del juego que explican mecánicas, objetos y recetas. " - "Escribe de forma clara y natural.", + "libro": "Son páginas de libros guía dentro del juego que explican mecánicas, objetos y recetas.", "script": "Son mensajes y tooltips que el modpack muestra al jugador.", } diff --git a/src/traductor_es/proceso.py b/src/traductor_es/proceso.py index 874a60c..0b3e18a 100644 --- a/src/traductor_es/proceso.py +++ b/src/traductor_es/proceso.py @@ -17,7 +17,7 @@ from .fuentes.instancia import Instancia from .fuentes.modpack import identificador from .modulos import crafttweaker, datos, libros, misiones, mods, runtime, scripts -from .modulos.base import Contexto, Modulo, Pieza, Resumen, reunir_pistas +from .modulos.base import Contexto, Modulo, Pieza, Resumen, pendientes_de, por_ambito, reunir_pistas from .modulos.cambios import Cambios, Lugar, comparar, indice_de, leer_indice, mezclar, para_la_marca, sin_indice from .modulos.cobertura import Hallazgo, hallazgos_de_comandos, hallazgos_de_scripts, revisar_cobertura from .modulos.mods import es_nombre @@ -30,7 +30,7 @@ from .nucleo.glosario import Glosario from .nucleo.mascara import separar_bordes from .nucleo.memoria import Memoria -from .nucleo.traductor import ECONOMICO, EQUILIBRADO, MAXIMO, PERFIL_POR_DEFECTO, Resultado, Traductor +from .nucleo.traductor import ECONOMICO, EQUILIBRADO, MAXIMO, PERFIL_POR_DEFECTO, Traductor from .nucleo.vocabulario import agregar_vocabulario, preparar_sustituciones from .salida import opciones as opciones_salida from .salida.copias import Respaldo @@ -417,7 +417,7 @@ def analizar(self) -> Informe: if isinstance(modulo, scripts.ScriptsKubeJS): scripts_leidos.append(modulo) leidos.append((grupo, modulo, lugares_de(modulo, piezas))) - pendientes = self.traductor.pendientes([p.texto for p in piezas], modulo.ambito) + pendientes = pendientes_de(self.traductor, modulo, [p.texto for p in piezas]) informe.modulos.append( InformeModulo(grupo, modulo.nombre, modulo.describir(), len({p.texto for p in piezas}), len(pendientes), sum(len(t) for t in pendientes)) @@ -437,7 +437,7 @@ def _analizar_espana(self, informe: Informe) -> None: piezas = modulo.recolectar() except (ValueError, OSError): # ya se avisó en la pasada principal continue - pendientes = self._espana.traductor.pendientes([p.texto for p in piezas], modulo.ambito) + pendientes = pendientes_de(self._espana.traductor, modulo, [p.texto for p in piezas]) # Sin contar los textos otra vez: son los mismos de la pasada principal informe.modulos.append( InformeModulo(grupo, modulo.nombre + ETIQUETA_ESPANA, "versión de España", 0, len(pendientes), @@ -459,7 +459,7 @@ def _comparar_con_la_ultima(self, informe: Informe, leidos: list[tuple[str, Modu informe.cambios = Cambios(comparar(indice, actuales), "indice", fecha) else: pendientes = { - m.nombre: set(self.traductor.pendientes([t for lugar in lugares for t in _textos(lugar)], m.ambito)) + m.nombre: set(pendientes_de(self.traductor, m, [t for lugar in lugares for t in _textos(lugar)])) for _g, m, lugares in leidos } informe.cambios = Cambios( @@ -470,7 +470,7 @@ def _comparar_con_la_ultima(self, informe: Informe, leidos: list[tuple[str, Modu textos = [t for c in informe.cambios.lugares if c.modulo == modulo.nombre for t in c.textos] if not textos: continue - pendientes_mod = self.traductor.pendientes(textos, modulo.ambito) + pendientes_mod = pendientes_de(self.traductor, modulo, textos) informe.modulos_cambios.append( InformeModulo(grupo, modulo.nombre, modulo.describir(), len(set(textos)), len(pendientes_mod), sum(len(t) for t in pendientes_mod)) @@ -543,7 +543,6 @@ def _traducir_pasada( Devuelve si el motor tradujo algo (para los créditos del pack). """ - traductor = pasada.traductor tradujo_el_motor = False etiqueta = ETIQUETA_ESPANA if pasada is self._espana else "" for grupo, modulo in self.modulos(pasada.ctx): @@ -552,41 +551,25 @@ def _traducir_pasada( if traducidos is not None: # el índice de cambios mira el inglés: basta con la pasada principal traducidos.append((_grupo_del_indice(grupo, modulo), modulo.nombre, lugares_de(modulo, piezas))) textos = [p.texto for p in piezas] - pendientes = traductor.pendientes(textos, modulo.ambito) - pistas = reunir_pistas(piezas) # un texto que sale con varias claves lleva el contexto de todas - if pasada is self._espana: - pistas = self._con_version_principal(pistas, textos, modulo.ambito) - if solo_memoria: - resultado = Resultado(traducciones=traductor.conocidas(textos, modulo.ambito)) - else: - resultado = traductor.traducir(textos, modulo.ambito, pistas) - tradujo_el_motor = tradujo_el_motor or bool(resultado.nuevas) - if self.revisar and grupo in GRUPOS_REVISADOS and resultado.nuevas: - self.registro(f" Revisando {len(resultado.nuevas)} traducciones nuevas…") - por_nucleo = {separar_bordes(k)[1]: v for k, v in pistas.items()} - hecha = revision.revisar_y_corregir(traductor, resultado.nuevas, modulo.ambito, por_nucleo) - self.registro(f" {hecha}") - if informe.revision_automatica is None: - informe.revision_automatica = revision.ResumenRevision() - 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} - ) - resumen = modulo.escribir(resultado.traducciones) + pendientes: list[str] = [] + traducciones: dict[str, str] = {} + # Cada ámbito con su tono: los libros guía de los archivos de idioma van como libro, no como interfaz + for ambito, del_ambito in por_ambito(piezas, modulo.ambito).items(): + hecho = self._traducir_ambito(pasada, informe, grupo, ambito, del_ambito, solo_memoria) + pendientes += hecho[0] + traducciones.update(hecho[1]) + tradujo_el_motor = tradujo_el_motor or hecho[2] + resumen = modulo.escribir(traducciones) self.registro(f" {resumen}") informe.modulos.append( InformeModulo(grupo, modulo.nombre + etiqueta, modulo.describir(), len(set(textos)), len(pendientes), sum(len(t) for t in pendientes), resumen) ) # fmt: skip if grupo != "mods": # la revisión del glosario mira textos largos (misiones, libros, scripts) - todas.update(resultado.traducciones) + todas.update(traducciones) if isinstance(modulo, mods.Mods): # Los nombres recién traducidos pasan al glosario: libros, misiones y scripts los usarán igual - nuevos = modulo.nombres(resultado.traducciones) + nuevos = modulo.nombres(traducciones) pasada.glosario.agregar_pares({en: en for en in nuevos}, nuevos) # Un nombre de una sola palabra que el modelo dejó igual es un nombre propio («Arachnarch»): se # protege para que las misiones no lo traduzcan. Con varias palabras suele ser un olvido. @@ -594,6 +577,43 @@ def _traducir_pasada( pasada.glosario.agregar_pares({en: en for en in iguales}, iguales, proteger_iguales=True) return tradujo_el_motor + def _traducir_ambito( + self, + pasada: _Pasada, + informe: Informe, + grupo: str, + ambito: str, + piezas: list[Pieza], + solo_memoria: bool, + ) -> tuple[list[str], dict[str, str], bool]: + """Traduce las piezas de un ámbito de un módulo (y las revisa si toca). (pendientes, traducciones, si el + motor tradujo algo).""" + traductor = pasada.traductor + textos = [p.texto for p in piezas] + pendientes = traductor.pendientes(textos, ambito) + pistas = reunir_pistas(piezas) # un texto que sale con varias claves lleva el contexto de todas + if pasada is self._espana: + pistas = self._con_version_principal(pistas, textos, ambito) + if solo_memoria: + return pendientes, traductor.conocidas(textos, ambito), False + resultado = traductor.traducir(textos, ambito, pistas) + if self.revisar and (grupo in GRUPOS_REVISADOS or ambito == mods.AMBITO_LIBRO) and resultado.nuevas: + self.registro(f" Revisando {len(resultado.nuevas)} traducciones nuevas…") + por_nucleo = {separar_bordes(k)[1]: v for k, v in pistas.items()} + hecha = revision.revisar_y_corregir(traductor, resultado.nuevas, ambito, por_nucleo) + self.registro(f" {hecha}") + if informe.revision_automatica is None: + informe.revision_automatica = revision.ResumenRevision() + 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, 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} + ) + return pendientes, resultado.traducciones, bool(resultado.nuevas) + def _con_version_principal(self, pistas: Mapping[str, str], textos: list[str], ambito: str) -> dict[str, str]: """Pistas de la versión de España con la traducción ya hecha en el dialecto principal. diff --git a/src/traductor_es/salida/paquete.py b/src/traductor_es/salida/paquete.py index 76d9042..c263f98 100644 --- a/src/traductor_es/salida/paquete.py +++ b/src/traductor_es/salida/paquete.py @@ -122,7 +122,7 @@ def textos_del_modpack(proceso: Proceso) -> tuple[set[tuple[str, str]], list[str except (ValueError, OSError) as e: avisos.append(f"{modulo.nombre}: no se pudo leer ({e}). Queda fuera del paquete.") continue - textos |= {(separar_bordes(p.texto)[1], modulo.ambito) for p in piezas if es_traducible(p.texto)} + textos |= {(separar_bordes(p.texto)[1], p.ambito or modulo.ambito) for p in piezas if es_traducible(p.texto)} return textos, avisos diff --git a/tests/test_libros_por_clave.py b/tests/test_libros_por_clave.py new file mode 100644 index 0000000..9495483 --- /dev/null +++ b/tests/test_libros_por_clave.py @@ -0,0 +1,49 @@ +"""Libros guía que viven en los archivos de idioma (Patchouli con `i18n`, Modonomicon): se traducen como libro.""" + +from __future__ import annotations + +from pathlib import Path + +import pytest + +from traductor_es.fuentes import vanilla +from traductor_es.modulos.mods import AMBITO_LIBRO, es_clave_de_libro +from traductor_es.motores.simulador import Simulador +from traductor_es.nucleo.memoria import Memoria +from traductor_es.proceso import Proceso + +from . import fabrica + +_TEXTOS = { + "item.m.wrench": "Wrench", + "gui.m.mode": "Mode", + "m.book.entry.basics.name": "The Basics", + "m.book.entry.basics.page1": "Right-click a block with the Wrench to rotate it.", + "m.book.entry.basics.page2": "Sneak while doing it to pick the block up.", +} + + +def test_que_es_una_clave_de_libro() -> None: + assert es_clave_de_libro("occultism.book.entries.ritual.page1") + assert es_clave_de_libro("mysticalagriculture.guide.entry.tiers") + assert not es_clave_de_libro("item.m.guide_book") # el nombre del objeto es interfaz + assert not es_clave_de_libro("gui.m.book_title") + assert not es_clave_de_libro("config.m.manual_mode") + + +def test_el_proceso_manda_los_libros_como_libro_y_con_vecindad(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None: + monkeypatch.setattr(vanilla, "raices_de_lanzadores", list) + juego = fabrica.prism(tmp_path, "1.20.1") + fabrica.jar(juego / "mods" / "m.jar", fabrica.lang("m", "en_us", _TEXTOS)) + motor = Simulador() + with Memoria(":memory:") as mem, Proceso(juego, motor, grupos=["mods"], memoria=mem) as p: + informe = p.analizar() + p.ejecutar(activar=False) + assert mem.obtener("Sneak while doing it to pick the block up.", "es_mx", AMBITO_LIBRO, p.pack) + assert mem.obtener("Wrench", "es_mx", "ui", p.pack) + por_ambito = {e.texto: (lote.ambito, e.pista) for lote in motor.lotes_recibidos for e in lote.entradas} + assert por_ambito["Wrench"][0] == "ui" and por_ambito["Mode"][0] == "ui" + ambito, pista = por_ambito["Sneak while doing it to pick the block up."] + assert ambito == AMBITO_LIBRO + assert "dentro de «The Basics»" in pista and "viene después de «Right-click a block" in pista + assert informe.a_traducir == len(_TEXTOS) # el análisis cuenta los dos ámbitos