Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
7 changes: 7 additions & 0 deletions CHANGELOG.md
Original file line number Diff line number Diff line change
Expand Up @@ -56,6 +56,13 @@ Todos los cambios importantes de ModpackES quedan en este archivo. El formato si

### Cambiado

- **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.
- Los nombres del propio juego mandan sobre la memoria («Lingote de hierro» aunque la memoria diga «Lingote de Hierro»). Por encima solo quedan tus correcciones y tu glosario.
- Lo que la memoria tiene como bueno se vuelve a comprobar con los códigos y el glosario de hoy. Si ya no cumple (por ejemplo, agregaste un término), ese texto se traduce de nuevo una vez. Lo que se aceptó con dudas en el mismo pack no se vuelve a pedir, para no pagar en cada traducción.
- La memoria se actualiza sola la primera vez que se abre: lo de antes queda como «ok» y para todos los packs, y se guarda una copia del archivo viejo (`memoria.sqlite.v1.bak`).
- El paquete compartible (`.modpackes.zip`) lleva marcado lo dudoso; al aplicarlo, eso queda solo para ese modpack. Un paquete viejo sigue sirviendo.
- **Más contexto en los textos de los mods, sin costo extra:**
- Los textos van al motor en el orden del archivo y no en orden alfabético, así que un lote junta el nombre de un objeto con su tooltip y el título de una misión con su descripción.
- Un tooltip o una descripción dice de qué objeto habla («habla de «Teleporter»»).
Expand Down
2 changes: 1 addition & 1 deletion README.md
Original file line number Diff line number Diff line change
Expand Up @@ -33,7 +33,7 @@ y **cualquier lanzador**, y escribe a la vez las siete variantes de español del

- **No modifica los jars de los mods.** Lo de los mods va en un resource pack aparte.
- **Todo tiene copia de seguridad.** Un botón devuelve el modpack a su texto original.
- **No se paga dos veces.** Lo ya traducido queda en una memoria que se reutiliza, también entre modpacks.
- **No se paga dos veces.** Lo ya traducido queda en una memoria que se reutiliza, también entre modpacks (de otro modpack, solo lo que quedó sin dudas).
- **Respeta los formatos.** Colores, enlaces, variables y comandos llegan intactos; lo que no pasa las
reglas de calidad se reintenta o queda en inglés antes que romper algo.

Expand Down
10 changes: 10 additions & 0 deletions src/traductor_es/fuentes/modpack.py
Original file line number Diff line number Diff line change
Expand Up @@ -99,3 +99,13 @@ def datos_del_modpack(juego: Path) -> DatosModpack:
if not nombre:
nombre = juego.parent.name if juego.name in (".minecraft", "minecraft") else juego.name
return DatosModpack(nombre, version)


def identificador(juego: Path) -> str:
"""Con qué nombre se guarda el modpack en la memoria: el nombre del pack (sin la versión, para que una
actualización siga usando lo suyo) o, si no se sabe, el de su carpeta."""
nombre = datos_del_modpack(juego).nombre
if nombre:
return nombre
carpeta = juego.parent if juego.name.lower() in ("minecraft", ".minecraft") else juego
return carpeta.name or "instancia"
30 changes: 30 additions & 0 deletions src/traductor_es/nucleo/glosario.py
Original file line number Diff line number Diff line change
Expand Up @@ -42,6 +42,7 @@ def __init__(self) -> None:
self._palabras_es: set[str] = set() #: palabras del español de esos textos (sin mayúsculas)
self._ambiguos: dict[tuple[str, str], bool] = {}
self._marcas: set[str] = set() #: nombres de mods («create»): no son inglés a medio traducir
self._por_palabra: dict[str, list[tuple[str, str, re.Pattern[str]]]] | None = None

def __len__(self) -> int:
return len(self._terminos) + len(self._fijos)
Expand Down Expand Up @@ -230,8 +231,37 @@ def _ordenados(self) -> list[tuple[str, str, re.Pattern[str]]]:
for k in sorted(todos, key=len, reverse=True)
]
self._orden = orden
self._por_palabra = None
return orden

def oficial(self, texto: str) -> str | None:
"""El nombre del propio juego para ese texto entero («Iron Ingot» → «Lingote de hierro»), si el usuario no
lo cambió."""
t = texto.strip()
return self._terminos.get(t) if t in self._oficiales and t not in self._fijos else None

def terminos_en(self, texto: str, maximo: int = 60) -> dict[str, str]:
"""Lo mismo que `relevantes([texto])`, rápido para muchos textos sueltos: solo mira los términos que empiezan
con una palabra del texto."""
orden = self._ordenados()
if self._por_palabra is None:
indice: dict[str, list[tuple[str, str, re.Pattern[str]]]] = {}
for termino in orden:
primera = next(iter(PALABRA.findall(termino[0])), termino[0])
indice.setdefault(primera, []).append(termino)
self._por_palabra = indice
bajo = sin_formato(texto).lower()
candidatos = [c for p in set(PALABRA.findall(bajo)) for c in self._por_palabra.get(p, ())]
elegidos: dict[str, str] = {}
for termino_bajo, original, patron in sorted(candidatos, key=lambda c: -len(c[0])):
if termino_bajo in bajo and patron.search(bajo):
if self.ambiguo(original) and not uso_como_nombre(original, texto):
continue
elegidos[original] = self._fijos.get(original) or self._terminos[original]
if len(elegidos) >= maximo:
break
return elegidos

def relevantes(self, textos: Iterable[str], maximo: int = 60) -> dict[str, str]:
"""Términos que aparecen como palabra completa en los textos, priorizando los más largos.

Expand Down
130 changes: 105 additions & 25 deletions src/traductor_es/nucleo/memoria.py
Original file line number Diff line number Diff line change
@@ -1,11 +1,13 @@
"""Memoria de traducciones en SQLite: lo traducido una vez se reutiliza en cualquier modpack."""
"""Memoria de traducciones en SQLite: lo traducido una vez se reutiliza en el mismo modpack y, si quedó bien, en
cualquier otro."""

from __future__ import annotations

import shutil
import sqlite3
import threading
from collections import Counter
from collections.abc import Iterable
from collections.abc import Iterable, Mapping
from dataclasses import dataclass
from datetime import UTC, datetime
from pathlib import Path
Expand All @@ -31,6 +33,16 @@ class Fila:
ambito: str
traduccion: str
motor: str
calidad: str = "ok" #: «ok» o por qué se aceptó con dudas


#: Pack de lo que no es de ningún modpack en particular (lo de antes del esquema 2, las pruebas, las mediciones).
SIN_PACK = "*"
#: Calidad de una traducción que pasó todas las reglas.
OK = "ok"
_LARGO_CALIDAD = 200
#: Versión del esquema de la base (PRAGMA user_version).
ESQUEMA = 2


def codigos_iguales(original: str, traduccion: str) -> bool:
Expand All @@ -44,10 +56,13 @@ def _patron_like(texto: str) -> str:


class Memoria:
"""Guarda (texto original, dialecto, ámbito) → traducción.
"""Guarda (texto original, dialecto, ámbito, pack) → traducción, con su calidad.

El ámbito separa el tono: una misión tutea al jugador y un nombre de objeto va en mayúscula inicial,
así que el mismo texto puede traducirse distinto en cada ámbito.

El pack separa los modpacks: una traducción se reutiliza siempre en el pack que la hizo, y en otro pack solo si
pasó todas las reglas (calidad «ok»). Lo aceptado con dudas en un pack no se lleva a los demás.
"""

def __init__(self, ruta: Path | str) -> None:
Expand All @@ -63,12 +78,16 @@ def __init__(self, ruta: Path | str) -> None:
raise

def _crear_tablas(self) -> None:
columnas = [str(c[1]) for c in self._db.execute("PRAGMA table_info(traducciones)")]
if columnas and "pack" not in columnas:
self._migrar_a_v2()
self._db.execute(
"""CREATE TABLE IF NOT EXISTS traducciones (
origen TEXT NOT NULL, dialecto TEXT NOT NULL, ambito TEXT NOT NULL,
traduccion TEXT NOT NULL, motor TEXT NOT NULL, fecha TEXT NOT NULL,
PRIMARY KEY (origen, dialecto, ambito))"""
origen TEXT NOT NULL, dialecto TEXT NOT NULL, ambito TEXT NOT NULL, pack TEXT NOT NULL,
traduccion TEXT NOT NULL, motor TEXT NOT NULL, fecha TEXT NOT NULL, calidad TEXT NOT NULL,
PRIMARY KEY (origen, dialecto, ambito, pack))"""
)
self._db.execute(f"PRAGMA user_version = {ESQUEMA}")
# Correcciones del usuario: un texto, una traducción en todos los ámbitos. Mandan sobre todo lo demás.
self._db.execute(
"""CREATE TABLE IF NOT EXISTS correcciones (
Expand All @@ -77,22 +96,67 @@ def _crear_tablas(self) -> None:
)
self._db.commit()

def obtener(self, origen: str, dialecto: str, ambito: str) -> str | None:
def _migrar_a_v2(self) -> None:
"""Esquema 1 → 2 sin perder nada: guarda una copia del archivo y pasa cada fila al pack «*» con calidad «ok»
(no se sabe con qué pack ni con qué dudas se hizo, y así se sigue usando como antes)."""
if self.ruta is not None and self.ruta.is_file():
shutil.copy2(self.ruta, self.ruta.with_name(self.ruta.name + ".v1.bak"))
self._db.execute("BEGIN") # una sola transacción, también para el ALTER: o se migra todo o nada
try:
self._db.execute("ALTER TABLE traducciones RENAME TO traducciones_v1")
self._db.execute(
"""CREATE TABLE traducciones (
origen TEXT NOT NULL, dialecto TEXT NOT NULL, ambito TEXT NOT NULL, pack TEXT NOT NULL,
traduccion TEXT NOT NULL, motor TEXT NOT NULL, fecha TEXT NOT NULL, calidad TEXT NOT NULL,
PRIMARY KEY (origen, dialecto, ambito, pack))"""
)
self._db.execute(
"INSERT INTO traducciones SELECT origen, dialecto, ambito, ?, traduccion, motor, fecha, ? "
"FROM traducciones_v1",
(SIN_PACK, OK),
)
self._db.execute("DROP TABLE traducciones_v1")
except sqlite3.Error:
self._db.rollback()
raise
self._db.commit()

def fila(self, origen: str, dialecto: str, ambito: str, pack: str = SIN_PACK) -> tuple[str, str] | None:
"""(traducción, calidad) que vale para este pack: la suya; si no tiene, la más reciente de otro que quedó
«ok». None si no hay ninguna."""
with self._lock:
fila = self._db.execute(
"SELECT traduccion FROM traducciones WHERE origen=? AND dialecto=? AND ambito=?",
(origen, dialecto, ambito),
"SELECT traduccion, calidad FROM traducciones WHERE origen=? AND dialecto=? AND ambito=? "
"AND (pack=? OR calidad=?) ORDER BY pack=? DESC, fecha DESC LIMIT 1",
(origen, dialecto, ambito, pack, OK, pack),
).fetchone()
return None if fila is None else str(fila[0])

def guardar(self, pares: dict[str, str], dialecto: str, ambito: str, motor: str) -> None:
return None if fila is None else (str(fila[0]), str(fila[1]))

def obtener(self, origen: str, dialecto: str, ambito: str, pack: str = SIN_PACK) -> str | None:
hallada = self.fila(origen, dialecto, ambito, pack)
return None if hallada is None else hallada[0]

def guardar(
self,
pares: Mapping[str, str],
dialecto: str,
ambito: str,
motor: str,
pack: str = SIN_PACK,
dudas: Mapping[str, str] | None = None,
) -> None:
"""Guarda traducciones del pack; las que están en `dudas` ({original: motivo}) quedan marcadas con su motivo."""
if not pares:
return
fecha = datetime.now(UTC).isoformat(timespec="seconds")
dudas = dudas or {}
with self._lock:
self._db.executemany(
"INSERT OR REPLACE INTO traducciones VALUES (?, ?, ?, ?, ?, ?)",
[(o, dialecto, ambito, t, motor, fecha) for o, t in pares.items()],
"INSERT OR REPLACE INTO traducciones VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
[
(o, dialecto, ambito, pack, t, motor, fecha, (dudas.get(o) or OK)[:_LARGO_CALIDAD])
for o, t in pares.items()
],
)
self._db.commit()

Expand All @@ -103,33 +167,40 @@ def recientes(self, dialecto: str, limite: int = 50_000) -> dict[str, str]:
"SELECT origen, traduccion FROM traducciones WHERE dialecto=? ORDER BY fecha DESC LIMIT ?",
(dialecto, limite),
).fetchall()
salida = {str(o): str(t) for o, t in filas}
salida: dict[str, str] = {}
for o, t in filas: # de la más nueva a la más vieja: si un texto está en varios packs, gana la última
salida.setdefault(str(o), str(t))
salida.update(self.correcciones(dialecto))
return salida

def filas(self, buscadas: Iterable[tuple[str, str]], dialecto: str) -> list[Fila]:
"""Las traducciones guardadas de esos pares (original, ámbito), con el motor que las hizo."""
def filas(self, buscadas: Iterable[tuple[str, str]], dialecto: str, pack: str = SIN_PACK) -> list[Fila]:
"""Las traducciones que valen para el pack de esos pares (original, ámbito), con el motor y la calidad."""
salida: list[Fila] = []
with self._lock:
for origen, ambito in sorted(set(buscadas)):
fila = self._db.execute(
"SELECT traduccion, motor FROM traducciones WHERE origen=? AND dialecto=? AND ambito=?",
(origen, dialecto, ambito),
"SELECT traduccion, motor, calidad FROM traducciones WHERE origen=? AND dialecto=? AND ambito=? "
"AND (pack=? OR calidad=?) ORDER BY pack=? DESC, fecha DESC LIMIT 1",
(origen, dialecto, ambito, pack, OK, pack),
).fetchone()
if fila is not None:
salida.append(Fila(origen, ambito, str(fila[0]), str(fila[1])))
salida.append(Fila(origen, ambito, str(fila[0]), str(fila[1]), str(fila[2])))
return salida

def importar(self, filas: Iterable[Fila], dialecto: str) -> int:
"""Guarda traducciones de otra memoria (reemplaza las que ya hubiera). Devuelve cuántas guardó."""
def importar(self, filas: Iterable[Fila], dialecto: str, pack: str = SIN_PACK) -> int:
"""Guarda traducciones de otra memoria en el pack (reemplaza las que ya tuviera). Devuelve cuántas guardó."""
fecha = datetime.now(UTC).isoformat(timespec="seconds")
lista = [(f.origen, dialecto, f.ambito, f.traduccion, f.motor, fecha) for f in filas]
lista = [
(f.origen, dialecto, f.ambito, pack, f.traduccion, f.motor, fecha, (f.calidad or OK)[:_LARGO_CALIDAD])
for f in filas
]
with self._lock:
self._db.executemany("INSERT OR REPLACE INTO traducciones VALUES (?, ?, ?, ?, ?, ?)", lista)
self._db.executemany("INSERT OR REPLACE INTO traducciones VALUES (?, ?, ?, ?, ?, ?, ?, ?)", lista)
self._db.commit()
return len(lista)

def olvidar(self, origen: str, dialecto: str, ambito: str) -> None:
"""Borra ese texto de la memoria en todos los packs."""
with self._lock:
self._db.execute(
"DELETE FROM traducciones WHERE origen=? AND dialecto=? AND ambito=?", (origen, dialecto, ambito)
Expand Down Expand Up @@ -194,9 +265,13 @@ def buscar(self, texto: str, dialecto: str, limite: int = 200) -> list[Coinciden
else []
)
vistos: set[str] = set()
pares: set[tuple[str, str]] = set()
salida: list[Coincidencia] = []
for o, a, t in filas:
origen = str(o)
if (origen, str(a)) in pares: # el mismo texto en varios packs: se muestra una vez
continue
pares.add((origen, str(a)))
vistos.add(origen)
corregida = corregidas.get(origen)
salida.append(Coincidencia(origen, str(a), corregida or str(t), corregida is not None))
Expand All @@ -209,8 +284,13 @@ def buscar(self, texto: str, dialecto: str, limite: int = 200) -> list[Coinciden
return salida[:limite]

def cantidad(self) -> int:
"""Cuántos textos distintos hay (el mismo texto en varios packs cuenta una vez)."""
with self._lock:
return int(self._db.execute("SELECT COUNT(*) FROM traducciones").fetchone()[0])
return int(
self._db.execute(
"SELECT COUNT(*) FROM (SELECT DISTINCT origen, dialecto, ambito FROM traducciones)"
).fetchone()[0]
)

def cerrar(self) -> None:
with self._lock:
Expand Down
Loading
Loading