diff --git a/docs/calidad.md b/docs/calidad.md index 0d71f7a..dfc001f 100644 --- a/docs/calidad.md +++ b/docs/calidad.md @@ -409,6 +409,33 @@ uv run python scripts/comparar_mediciones.py --a build/qwen3.5-4b.json --b build del jar del cliente, leído por rangos, y es_mx y es_es del índice de assets. `descargar_lang.py` baja solo los idiomas de los mods. +## 14 de noviembre de 2026 · primer banco de libros + +Hasta ahora los libros no se medían. `scripts/armar_banco_libros.py` arma un banco con traducciones humanas de +libros de mods libres, de dos fuentes: +- los libros de Patchouli en JSON que traen su español, emparejados campo por campo; +- los textos largos (60 caracteres o más) de claves de libro en los archivos de idioma. Desde Patchouli 1.20 casi + todos los libros usan claves de idioma (`"i18n": true`): con el corpus local, los libros en JSON solo dieron 20 + textos de un mod. + +Se descartan las referencias a medias, se deja un tope de 25 textos por mod y la muestra es fija (semilla 7). Con el +corpus de este PC salen **116 textos de 9 mods**, de 167 caracteres de media. Es poco, pero sirve como referencia. + +Gemini 3.8 Flash, tres corridas por condición (unos US$ 0,04 cada una): + +| | chrF (corridas 1 a 3) | Términos del glosario | +|---|---|---| +| Sin los controles de forma | 67,9 · 68,6 · 67,5 | 130, 129 y 128 de 134 | +| Con los controles (la app) | 68,0 · 68,3 · 67,0 | 127, 124 y 128 de 134 | +| Diferencia pareada | −0,25 (IC −0,90 a +0,46), no se distingue del ruido | | + +- **Base de libros: chrF ≈ 68**, contra ≈ 75 en el banco de interfaz. Los textos son más largos y las referencias + de cada mod tienen su propio estilo, así que el chrF castiga más las traducciones correctas pero distintas. +- Los controles no cambian nada en libros: cada texto de la muestra sale de un sitio distinto, así que casi no hay + nombres que se repitan entre textos para unificar. Donde sí actúan es en las misiones de un mismo pack (ver la + 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)`…). + ## Cómo repetirlo ``` @@ -420,6 +447,9 @@ uv run python scripts/medir_calidad.py --banco .descargas/banco/referencia_real. uv run python scripts/comparar_mediciones.py --a build/sin1.json build/sin2.json --b build/con1.json build/con2.json uv run python scripts/juzgar_calidad.py --entrada build/con1.json 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 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/docs/datos-de-terceros.md b/docs/datos-de-terceros.md index 72aab23..fcfd8a5 100644 --- a/docs/datos-de-terceros.md +++ b/docs/datos-de-terceros.md @@ -32,6 +32,9 @@ Solo se usa Modrinth, que publica la licencia de cada proyecto. CurseForge no se - Los textos del juego de Mojang no se redistribuyen. - Los pares inglés/español sacados de jars para medir calidad se quedan en `.descargas/banco/`. En `docs/calidad.md` solo van las métricas, nunca los textos. +- `scripts/descargar_lang.py` baja, de los mods con licencia libre según Modrinth, solo sus archivos de idioma y los + libros de Patchouli en inglés y español (por rangos, sin el jar entero). `scripts/armar_banco_libros.py` saca de + esos libros el banco de libros, que también se queda en `.descargas/banco/`. ## Modelos locales (`.modelos/`) diff --git a/scripts/armar_banco_libros.py b/scripts/armar_banco_libros.py new file mode 100644 index 0000000..4a9ed4b --- /dev/null +++ b/scripts/armar_banco_libros.py @@ -0,0 +1,133 @@ +"""Arma un banco de libros (Patchouli) con traducciones humanas, para medir la calidad en textos largos. + +Usa los libros que bajó `scripts/descargar_lang.py` de mods de licencia libre (.descargas//langs//…): +cada archivo en inglés se empareja con su versión en español del mismo mod, campo por campo +(`paquete.emparejar_libro`), y se descartan las referencias a medias (inglés y español mezclados). El banco va a +`.descargas/banco/libros.json`, solo para uso local (ver docs/datos-de-terceros.md). + +Uso: uv run python scripts/armar_banco_libros.py [--textos 150] [--salida RUTA] +Y luego: uv run python scripts/medir_calidad.py --banco .descargas/banco/libros.json --vanilla .descargas/vanilla +""" + +from __future__ import annotations + +import argparse +import json +import random +import re +import sys +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +import armar_banco_local as abl +import descargar_corpus as dc + +from traductor_es.salida.paquete import emparejar_libro + +#: …/langs//assets//patchouli_books//en_us/.json +_EN_INGLES = re.compile(r"langs/([^/]+)/assets/([^/]+)/patchouli_books/([^/]+)/en_us/(.+\.json)$") +#: Variantes de español en el orden en que se prefieren como referencia. +_PREFERIDAS = ("es_mx", "es_es") +#: Desde Patchouli 1.20 casi todos los libros usan claves de idioma (`"i18n": true`): su texto vive en `lang/`. +#: 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.", "modernfix.") +#: Largo mínimo de un texto de libro sacado de `lang/` (los títulos cortos ya los mide el banco de interfaz). +_MINIMO_LANG = 60 +#: Tope de textos por mod, para que un mod con un libro enorme no ocupe medio banco. +_MAXIMO_POR_MOD = 25 + + +@dataclass(frozen=True, slots=True) +class ParLibro: + jar: str + libro: str + ingles: str + castellano: str + + +def pares_de_libros(raiz: Path) -> list[ParLibro]: + """Los textos de libros que existen en inglés y en español en el mismo mod, sin referencias a medias.""" + salida: list[ParLibro] = [] + for ingles in sorted(raiz.glob("*/langs/*/assets/*/patchouli_books/*/en_us/**/*.json")): + m = _EN_INGLES.search(ingles.as_posix()) + if m is None: + continue + jar, espacio, libro, resto = m.groups() + base = ingles.parents[len(Path(resto).parts) - 1] # …/patchouli_books//en_us + variantes = sorted(p.name for p in base.parent.iterdir() if p.is_dir() and p.name.startswith("es_")) + orden = [v for v in _PREFERIDAS if v in variantes] + [v for v in variantes if v not in _PREFERIDAS] + espanol = next((base.parent / v / resto for v in orden if (base.parent / v / resto).is_file()), None) + if espanol is None: + continue + for en, es in emparejar_libro(ingles.read_bytes(), espanol.read_bytes()).items(): + if abl.referencia_limpia(en, es): + salida.append(ParLibro(jar, f"{espacio}:{libro}", en, es)) + return salida + + +def pares_de_libros_en_lang(pares: list[abl.Par]) -> list[ParLibro]: + """Textos largos de libros que vienen en los archivos de idioma, por su clave.""" + return [ + ParLibro(p.jar, f"{p.namespace}:lang", p.ingles, p.castellano) + for p in pares + if _CLAVE_DE_LIBRO.search(p.clave) + and not p.clave.startswith(_NO_ES_LIBRO) + and len(p.ingles) >= _MINIMO_LANG + and abl.referencia_limpia(p.ingles, p.castellano) + ] + + +def armar(raiz: Path, textos: int, semilla: int = 7, pares_lang: list[abl.Par] | None = None) -> dict[str, Any]: + """El banco: una muestra fija de textos de libros, con el glosario que sacaría la app de los demás mods. + + Junta los libros en JSON y los que vienen en `lang/`, con un tope por mod. + """ + lang = abl.pares() if pares_lang is None else pares_lang + todos = sorted( + set(pares_de_libros(raiz)) | set(pares_de_libros_en_lang(lang)), key=lambda p: (p.jar, p.libro, p.ingles) + ) + unicos = list({p.ingles: p for p in todos}.values()) # un texto repetido cuenta una vez + azar = random.Random(semilla) + azar.shuffle(unicos) + por_mod: dict[str, int] = {} + elegidos: list[ParLibro] = [] + for p in unicos: + if len(elegidos) >= textos or por_mod.get(p.jar, 0) >= _MAXIMO_POR_MOD: + continue + por_mod[p.jar] = por_mod.get(p.jar, 0) + 1 + elegidos.append(p) + medir = {p.jar for p in elegidos} + glosario = abl.glosario_del_banco(lang, medir, ingenuo=False) if (raiz / "vanilla").is_dir() else {} + return { + "descripcion": "Textos reales de libros (Patchouli) de mods libres, en inglés y español. Solo uso local.", + "dialecto": "es_mx", + "glosario": glosario, + "textos": [ + {"ambito": "libro", "original": p.ingles, "referencia": p.castellano, "jar": p.jar, "pista": "libro: text"} + for p in elegidos + ], + } + + +def main(argv: list[str] | None = None) -> int: + sys.stdout.reconfigure(encoding="utf-8", errors="replace") # pyright: ignore[reportAttributeAccessIssue] + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument("--textos", type=int, default=150) + ap.add_argument("--salida", type=Path, default=None, help="por defecto .descargas/banco/libros.json") + args = ap.parse_args(argv) + banco = armar(dc.RAIZ, args.textos) + if not banco["textos"]: + print("No hay libros con traducción al español: baja antes el corpus con scripts/descargar_lang.py.") + return 1 + destino = args.salida or dc.RAIZ / "banco" / "libros.json" + destino.parent.mkdir(parents=True, exist_ok=True) + destino.write_text(json.dumps(banco, indent=1, ensure_ascii=False), encoding="utf-8") + libros = {t["jar"] for t in banco["textos"]} + print(f"Banco de libros: {len(banco['textos'])} textos de {len(libros)} mods → {destino}") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/scripts/descargar_lang.py b/scripts/descargar_lang.py index 2b6724c..8b252dd 100644 --- a/scripts/descargar_lang.py +++ b/scripts/descargar_lang.py @@ -1,9 +1,9 @@ -"""Baja solo los archivos de idioma (lang) de los mods de licencia libre de los packs del corpus. +"""Baja solo los archivos de idioma (lang) y los libros de los mods de licencia libre de los packs del corpus. Para cada mod del índice cuya licencia (según Modrinth) sea libre, lee el directorio del jar con peticiones -por rangos y baja solo `assets/*/lang/` en inglés y español. Lo deja en .descargas//langs// para -medir el glosario y la calidad (ver docs/datos-de-terceros.md). No baja jars completos ni mods con -licencia reservada o dudosa. +por rangos y baja solo `assets/*/lang/` y los libros de Patchouli (`assets/*/patchouli_books/`), en inglés y +español. Lo deja en .descargas//langs// para medir el glosario y la calidad (ver +docs/datos-de-terceros.md). No baja jars completos ni mods con licencia reservada o dudosa. Uso: uv run python scripts/descargar_lang.py [pack ...] """ @@ -20,6 +20,8 @@ from auditar_licencias import mods_por_hash LANG = re.compile(r"^assets/[^/]+/lang/(en_us\.json|en_US\.lang|es_[a-z]{2}\.(json|lang)|es_[A-Z]{2}\.lang)$") +#: Libros de Patchouli en inglés y español, para el banco de libros (scripts/armar_banco_libros.py). +LIBRO = re.compile(r"^assets/[^/]+/patchouli_books/[^/]+/(en_us|es_[a-z]{2})/.+\.json$") LIMITE_POR_PACK = 30 * 1024 * 1024 @@ -37,7 +39,9 @@ def bajar_langs(pack: Path) -> dict[str, Any]: continue url = f["downloads"][0] try: - entradas = [e for e in dc.directorio_central(url, dc.tamano(url)) if LANG.match(e.nombre)] + entradas = [ + e for e in dc.directorio_central(url, dc.tamano(url)) if LANG.match(e.nombre) or LIBRO.match(e.nombre) + ] except (OSError, RuntimeError) as e: resumen["omitidos"].append({"jar": nombre, "motivo": f"error: {e}"}) continue diff --git a/src/traductor_es/salida/paquete.py b/src/traductor_es/salida/paquete.py index 20450d9..dc92c89 100644 --- a/src/traductor_es/salida/paquete.py +++ b/src/traductor_es/salida/paquete.py @@ -411,17 +411,28 @@ def pares_de_libros(pack: Contenedor, mods: Sequence[Contenedor], orden: Sequenc if clave not in en_ingles: continue contenedor, nombre_en = en_ingles[clave] - ingles, espanol = _textos_de_libro(contenedor.leer(nombre_en)), _textos_de_libro(pack.leer(nombre_es)) - if ingles is None or espanol is None or [c for c, _ in ingles] != [c for c, _ in espanol]: + pares.update(emparejar_libro(contenedor.leer(nombre_en), pack.leer(nombre_es))) + return pares + + +def emparejar_libro(ingles: bytes, espanol: bytes) -> dict[str, str]: + """{inglés: español} de un archivo de un libro de Patchouli y su traducción, campo por campo. + + Solo si los dos tienen los mismos campos en el mismo orden, y cada campo se parte igual en los dos (párrafos); + lo que no encaja se deja fuera. + """ + en, es = _textos_de_libro(ingles), _textos_de_libro(espanol) + if en is None or es is None or [c for c, _ in en] != [c for c, _ in es]: + return {} + pares: dict[str, str] = {} + for (_campo, texto_en), (_c, texto_es) in zip(en, es, strict=True): + partes_en, partes_es = unidades(texto_en), unidades(texto_es) + if len(partes_en) != len(partes_es): continue - for (_campo, en), (_c, es) in zip(ingles, espanol, strict=True): - partes_en, partes_es = unidades(en), unidades(es) - if len(partes_en) != len(partes_es): - continue - for a, b in zip(partes_en, partes_es, strict=True): - original, traduccion = separar_bordes(a)[1], separar_bordes(b)[1] - if es_traducible(original) and traduccion != original and _texto_valido(original, traduccion): - pares[original] = traduccion + for a, b in zip(partes_en, partes_es, strict=True): + original, traduccion = separar_bordes(a)[1], separar_bordes(b)[1] + if es_traducible(original) and traduccion != original and _texto_valido(original, traduccion): + pares[original] = traduccion return pares diff --git a/tests/test_banco_libros.py b/tests/test_banco_libros.py new file mode 100644 index 0000000..d2c5de0 --- /dev/null +++ b/tests/test_banco_libros.py @@ -0,0 +1,74 @@ +"""Banco de libros: pares inglés/español de libros de Patchouli, campo por campo y sin referencias a medias.""" + +from __future__ import annotations + +import json +import sys +from pathlib import Path +from types import ModuleType + +import pytest + + +@pytest.fixture +def armar_banco_libros() -> ModuleType: + sys.path.insert(0, str(Path(__file__).parent.parent / "scripts")) + try: + import armar_banco_libros as modulo # pyright: ignore[reportMissingImports] + finally: + sys.path.pop(0) + return modulo # pyright: ignore[reportUnknownVariableType] + + +def _libro(raiz: Path, jar: str, idioma: str, datos: dict[str, object], archivo: str = "entries/a.json") -> None: + ruta = raiz / "pack" / "langs" / jar / "assets" / "m" / "patchouli_books" / "guia" / idioma / archivo + ruta.parent.mkdir(parents=True, exist_ok=True) + ruta.write_text(json.dumps(datos), encoding="utf-8") + + +def test_arma_el_banco_con_los_libros_traducidos(tmp_path: Path, armar_banco_libros: ModuleType) -> None: + _libro( + tmp_path, + "m.jar", + "en_us", + {"name": "Getting Started", "pages": [{"text": "Welcome to this guide about machines."}]}, + ) + _libro( + tmp_path, + "m.jar", + "es_es", + {"name": "Primeros pasos", "pages": [{"text": "Te damos la bienvenida a esta guía sobre máquinas."}]}, + ) + # Una «traducción» a medias (mezcla inglés y español) no sirve de referencia + _libro(tmp_path, "m.jar", "en_us", {"name": "Power the Grinder now"}, "entries/b.json") + _libro(tmp_path, "m.jar", "es_es", {"name": "Power the Grinder ahora"}, "entries/b.json") + # Un libro sin español no aporta nada + _libro(tmp_path, "otro.jar", "en_us", {"name": "Lonely"}) + banco = armar_banco_libros.armar(tmp_path, textos=10, pares_lang=[]) # pyright: ignore[reportUnknownMemberType] + pares = {t["original"]: t["referencia"] for t in banco["textos"]} + assert pares == { + "Getting Started": "Primeros pasos", + "Welcome to this guide about machines.": "Te damos la bienvenida a esta guía sobre máquinas.", + } + assert {t["ambito"] for t in banco["textos"]} == {"libro"} and banco["dialecto"] == "es_mx" + + +def test_prefiere_es_mx_como_referencia(tmp_path: Path, armar_banco_libros: ModuleType) -> None: + _libro(tmp_path, "m.jar", "en_us", {"name": "Getting Started"}) + _libro(tmp_path, "m.jar", "es_es", {"name": "Primeros pasos"}) + _libro(tmp_path, "m.jar", "es_mx", {"name": "Para empezar"}) + banco = armar_banco_libros.armar(tmp_path, textos=10, pares_lang=[]) # pyright: ignore[reportUnknownMemberType] + assert [t["referencia"] for t in banco["textos"]] == ["Para empezar"] + + +def test_suma_los_libros_que_vienen_en_lang(tmp_path: Path, armar_banco_libros: ModuleType) -> None: + par = armar_banco_libros.abl.Par # pyright: ignore[reportUnknownMemberType] + largo = "Place the main ingredient on the central pedestal and the catalysts around it." + traduccion = "Coloca el ingrediente principal sobre el pedestal central y los catalizadores alrededor." + lang = [ + par("ma.jar", "ma", "ma.guide.entry.infusion.page.1", largo, traduccion), + par("ma.jar", "ma", "ma.guide.title", "Guide", "Guía"), # corto: ya lo mide el banco de interfaz + par("x.jar", "x", "options.book.render", largo, traduccion), # una opción, no un libro + ] + banco = armar_banco_libros.armar(tmp_path, textos=10, pares_lang=lang) # pyright: ignore[reportUnknownMemberType] + assert [t["original"] for t in banco["textos"]] == [largo]