Upload app.py

app.py

@@ -33,532 +33,82 @@ GROQ_URL = "https://api.groq.com/openai/v1/chat/completions"
 GROQ_KEY = os.environ.get("GROQ_API_KEY")
 
 
-# --- REFINAMIENTO DE TRADUCCIÓN CON GROQ (SENTIDO TRADICIONAL) ---
-def refinar_texto_con_groq(texto_literal):
+def _limpiar_entidades(s: str) -> str:
+    """Deshace entidades HTML aunque vengan DOBLEMENTE escapadas
+    (p.ej. ' ' -> ' '), que es lo que rompía el hebreo en pantalla
+    mostrando literalmente ' '."""
+    prev = None
+    out = s or ""
+    for _ in range(3):
+        if out == prev:
+            break
+        prev = out
+        out = html.unescape(out)
+    return out
+
+
+# --- TRADUCCIÓN CON SENTIDO (GROQ), VERSÍCULO POR VERSÍCULO ---
+# Groq traduce DESDE EL HEBREO (fuente segura, siempre presente) a un español
+# fluido y con sentido tradicional, devolviendo UNA LÍNEA POR VERSÍCULO. Así el
+# mismo texto con sentido se muestra alineado y se usa EXACTAMENTE en el audio.
+def traducir_capitulo_con_groq(pares):
     """
-    Toma el texto literal/interlinear y lo transforma mediante Groq 
-    a un español fluido, claro y con el sentido tradicional exacto.
+    pares: lista de (n, hebreo, es_literal). Devuelve dict {n: español_con_sentido}.
+    Si Groq no está disponible o falla, cae al literal español (o al hebreo).
     """
-    if not GROQ_KEY or not texto_literal.strip():
-        return texto_literal
-        
+    fallback = {n: (es or he) for (n, he, es) in pares}
+    if not GROQ_KEY or not pares:
+        return fallback
+
+    # Bloque de entrada numerado: el hebreo es la fuente; el literal español,
+    # si existe, va solo como ayuda.
+    lineas_in = []
+    for (n, he, es) in pares:
+        ayuda = f"   (ayuda literal: {es})" if es else ""
+        lineas_in.append(f"[{n}] {he}{ayuda}")
+    entrada = "\n".join(lineas_in)
+
     sistema = (
-        "Eres un experto en traducción bíblica y exégesis tradicional hebrea. "
-        "Tu tarea es tomar el texto literal o interlinear proporcionado y transformarlo "
-        "a un español fluido, claro y con el sentido tradicional exacto, "
-        "manteniendo la profundidad, el respeto y la fidelidad al texto original sin perder naturalidad."
+        "Eres un experto en traducción bíblica del hebreo y en exégesis tradicional. "
+        "Traduces cada versículo hebreo a un español fluido, claro y natural, "
+        "con el sentido tradicional exacto, sin perder fidelidad ni profundidad. "
+        "Reglas de salida ESTRICTAS: devuelve SOLO las traducciones, una por línea, "
+        "cada línea empezando por el número entre corchetes tal cual: '[N] traducción'. "
+        "No incluyas el texto hebreo, ni títulos, ni comentarios, ni notas. "
+        "Conserva el mismo número de versículos que recibas."
     )
-    
+    max_tok = min(8000, max(1500, len(pares) * 90))
     cuerpo = {
         "model": MODELO_ESTUDIA,
         "temperature": 0.3,
-        "max_tokens": 2000,
+        "max_tokens": max_tok,
         "messages": [
             {"role": "system", "content": sistema},
-            {"role": "user", "content": f"Por favor, da forma y sentido natural al siguiente texto manteniendo su tradición:\n\n{texto_literal}"}
-        ]
+            {"role": "user", "content": f"Traduce con sentido cada versículo:\n\n{entrada}"},
+        ],
     }
-    
-    try:
-        data = json.dumps(cuerpo).encode("utf-8")
-        req = urllib.request.Request(GROQ_URL, data=data, method="POST")
-        req.add_header("Content-Type", "application/json")
-        req.add_header("Authorization", f"Bearer {GROQ_KEY}")
-        with urllib.request.urlopen(req, timeout=90) as r:
-            d = json.load(r)
-        return (d["choices"][0]["message"]["content"] or "").strip()
-    except Exception as e:
-        print(f"Error refinando con Groq: {e}")
-        return texto_literal
-
-
-# --- PROCESAMIENTO ACÚSTICO FFMPEG ---
-def procesar_audio_narrador(ruta):
-    if not shutil.which("ffmpeg"):
-        return ruta
-    filtros = [
-        "atempo=0.92",
-        "bass=g=5:f=120",
-        "treble=g=2",
-        "aecho=0.8:0.88:40:0.15"
-    ]
-    salida = ruta[:-4] + "_narrador.mp3"
-    cmd = ["ffmpeg", "-y", "-i", ruta, "-af", ", ".join(filtros), "-ac", "2", salida]
-    try:
-        subprocess.run(cmd, check=True, capture_output=True, timeout=60)
-        if os.path.getsize(salida) > 0:
-            return salida
-    except Exception:
-        pass
-    return ruta
-
-
-def procesar_audio_divino(ruta):
-    if not shutil.which("ffmpeg"):
-        return ruta
-    filtros = [
-        "atempo=0.88",                         
-        "asetrate=44100*0.88",                  
-        "aresample=44100",                      
-        "bass=g=12:f=180",                     
-        "treble=g=-3",                        
-        "aecho=0.85:0.9:50:0.2"
-    ]
-    salida = ruta[:-4] + "_divino.mp3"
-    cmd = ["ffmpeg", "-y", "-i", ruta, "-af", ", ".join(filtros), "-ac", "2", salida]
-    try:
-        subprocess.run(cmd, check=True, capture_output=True, timeout=60)
-        if os.path.getsize(salida) > 0:
-            return salida
-    except Exception:
-        pass
-    return ruta
-
-
-def concatenar_audios(lista_rutas):
-    if not lista_rutas:
-        return None
-    if len(lista_rutas) == 1:
-        return lista_rutas[0]
-
-    salida_final = tempfile.NamedTemporaryFile(suffix=".mp3", delete=False).name
-    list_file = tempfile.NamedTemporaryFile(suffix=".txt", mode="w", delete=False, encoding="utf-8")
-    
-    for r in lista_rutas:
-        list_file.write(f"file '{os.path.abspath(r)}'\n")
-    list_file.close()
-
-    cmd = ["ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", list_file.name, "-c", "copy", salida_final]
-    try:
-        subprocess.run(cmd, check=True, capture_output=True, timeout=120)
-        os.remove(list_file.name)
-        return salida_final
-    except Exception:
-        if os.path.exists(list_file.name):
-            os.remove(list_file.name)
-        return lista_rutas[0]
-
-
-def mezclar_fondo(voz_path):
-    if not (os.path.exists(FONDO) and shutil.which("ffmpeg")):
-        return voz_path
-    salida = voz_path[:-4] + "_mix.mp3"
-    filtro = (f"[1:a]volume={FONDO_VOL}[m];"
-              f"[0:a][m]amix=inputs=2:duration=first:normalize=0[a]")
-    cmd = ["ffmpeg", "-y", "-i", voz_path, "-stream_loop", "-1", "-i", FONDO,
-           "-filter_complex", filtro, "-map", "[a]", salida]
-    try:
-        subprocess.run(cmd, check=True, capture_output=True, timeout=120)
-        if os.path.getsize(salida) > 0:
-            return salida
-    except Exception:
-        pass
-    return voz_path
-
-
-# --- SEPARACIÓN DE BLOQUES (NARRADOR vs DIOS) PARA ESPAÑOL ---
-def segmentar_texto_divino(texto):
-    patron = r'((?:Y\s+dijo\s+Dios|dijo\s+Dios|Y\s+llamó\s+Dios|Y\s+bendijo\s+Dios)[^:,.–—]*[:,.–—]?\s*)([^.\n]+)'
-    bloques = []
-    ultimo_idx = 0
-
-    for match in re.finditer(patron, texto, flags=re.IGNORECASE):
-        start, end = match.span()
-        if start > ultimo_idx:
-            bloques.append(("narrador", texto[ultimo_idx:start]))
-        
-        intro_dios = match.group(1) 
-        palabras_dios = match.group(2) 
-
-        bloques.append(("narrador", intro_dios))
-        bloques.append(("dios", palabras_dios))
-        ultimo_idx = end
-
-    if ultimo_idx < len(texto):
-        bloques.append(("narrador", texto[ultimo_idx:]))
-
-    return bloques if bloques else [("narrador", texto)]
-
-
-async def generar_bloque_audio(texto, es_divino):
-    ruta = tempfile.NamedTemporaryFile(suffix=".mp3", delete=False).name
-    voz = VOZ_DIVINA if es_divino else VOZ_NARRADOR
-    pitch = "-5Hz" if es_divino else VOZ_PITCH
-    rate = "-9%" if es_divino else VOZ_RATE
 
-    try:
-        com = edge_tts.Communicate(texto[:4000], voz, rate=rate, pitch=pitch)
-        await com.save(ruta)
-    except Exception:
-        return None
-
-    if es_divino:
-        return procesar_audio_divino(ruta)
-    else:
-        return procesar_audio_narrador(ruta)
-
-
-async def leer_es(texto):
-    if not texto or not texto.strip():
-        return None
-
-    bloques = segmentar_texto_divino(texto)
-    audios_segmentos = []
-
-    for tipo, contenido in bloques:
-        if contenido.strip():
-            es_divino = (tipo == "dios")
-            audio_seg = await generar_bloque_audio(contenido, es_divino)
-            if audio_seg:
-                audios_segmentos.append(audio_seg)
-
-    audio_final = concatenar_audios(audios_segmentos)
-    if audio_final:
-        audio_final = mezclar_fondo(audio_final)
-    
-    return audio_final
-
-
-# --- REPRODUCTOR DE HEBREO LITÚRGICO REAL (TROPE) ---
-async def leer_he(nombre_espanol, capitulo):
-    libro_id = id_por_nombre(nombre_espanol)
-    if not libro_id:
-        return None
-
-    MAPEO_TORAH = {
-        "Genesis": "01",
-        "Exodus": "02",
-        "Leviticus": "03",
-        "Numbers": "04",
-        "Deuteronomy": "05"
-    }
-
-    carpeta_audios = "audios_torah"
-    if not os.path.exists(carpeta_audios):
-        os.makedirs(carpeta_audios)
-
-    ruta_local = os.path.join(carpeta_audios, f"{libro_id}_{capitulo}.mp3")
-
-    if os.path.exists(ruta_local):
-        return mezclar_fondo(ruta_local)
-
-    if libro_id in MAPEO_TORAH:
-        id_mechon = MAPEO_TORAH[libro_id]
-        cap_formateado = f"{int(capitulo):02d}"
-        url_audio = f"https://mechon-mamre.org/mp3/t{id_mechon}{cap_formateado}.mp3"
-        
-        try:
-            req = urllib.request.Request(
-                url_audio,
-                headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"}
-            )
-            with urllib.request.urlopen(req, timeout=30) as response, open(ruta_local, 'wb') as out_file:
-                out_file.write(response.read())
-            return mezclar_fondo(ruta_local)
-        except Exception as e:
-            print(f"Error descargando el audio: {e}")
-            return None
-            
-    return None
-
-
-# --- CARGA Y MANEJO DE LIBROS ---
-NOMBRES_ES = {
-    "Genesis": "Génesis", "Exodus": "Éxodo", "Leviticus": "Levítico",
-    "Numbers": "Números", "Deuteronomy": "Deuteronomio", "Joshua": "Josué",
-    "Judges": "Jueces", "Ruth": "Rut", "1_Samuel": "1 Samuel", "2_Samuel": "2 Samuel",
-    "1_Kings": "1 Reyes", "2_Kings": "2 Reyes", "1_Chronicles": "1 Crónicas",
-    "2_Chronicles": "2 Crónicas", "Ezra": "Esdras", "Nehemiah": "Nehemías",
-    "Esther": "Ester", "Job": "Job", "Psalms": "Salmos", "Proverbs": "Proverbios",
-    "Ecclesiastes": "Eclesiastés", "Song_of_Songs": "Cantar de los Cantares",
-    "Isaiah": "Isaías", "Jeremiah": "Jeremías", "Lamentations": "Lamentaciones",
-    "Ezekiel": "Ezequiel", "Daniel": "Daniel", "Hosea": "Oseas", "Joel": "Joel",
-    "Amos": "Amós", "Obadiah": "Abdías", "Jonah": "Jonás", "Micah": "Miqueas",
-    "Nahum": "Nahúm", "Habakkuk": "Habacuc", "Zephaniah": "Sofonías",
-    "Haggai": "Hageo", "Zechariah": "Zacarías", "Malachi": "Malaquías",
-}
-
-
-def _convertir_traduccion_plana(book_id: str, data: dict) -> dict:
-    texto = data.get("translation", "") or ""
-    lineas = [l.strip() for l in texto.split("\n") if l.strip()]
-    versiculos = [{"n": i + 1, "he": "", "es": linea} for i, linea in enumerate(lineas)]
-    return {
-        "id": book_id,
-        "es": NOMBRES_ES.get(book_id, book_id),
-        "heb": "",
-        "capitulos": {"1": versiculos},
-    }
-
-
-def cargar_libros():
-    libros = {}
-    for ruta in sorted(glob.glob(os.path.join(CARPETA, "*.json"))):
-        try:
-            with open(ruta, encoding="utf-8") as f:
-                d = json.load(f)
-            book_id = os.path.splitext(os.path.basename(ruta))[0]
-            if "capitulos" in d:
-                lid = d.get("id") or book_id
-                libros[lid] = d
-            elif "translation" in d:
-                libros[book_id] = _convertir_traduccion_plana(book_id, d)
-        except Exception as e:
-            print("No pude leer", ruta, e)
-    return libros
-
-
-LIBROS = cargar_libros()
-ORDEN = ["Genesis", "Exodus", "Leviticus", "Numbers", "Deuteronomy"]
-IDS = [i for i in ORDEN if i in LIBROS] + [i for i in LIBROS if i not in ORDEN]
-NOMBRES = [LIBROS[i].get("es", i) for i in IDS] or ["(sube tus libros)"]
-
-
-def id_por_nombre(nombre):
-    for i in IDS:
-        if LIBROS[i].get("es", i) == nombre:
-            return i
-    return IDS[0] if IDS else None
-
-
-def versiculos(lid, cap):
-    return LIBROS.get(lid, {}).get("capitulos", {}).get(str(cap), [])
-
-
-def render(nombre, cap):
-    lid = id_por_nombre(nombre)
-    if not lid:
-        return "<div class='pasaje'><p>Aún no has subido libros a la carpeta <b>libros/</b>.</p></div>", "", ""
-    try:
-        cap = max(1, int(float(cap or 1)))
-    except Exception:
-        cap = 1
-    d = LIBROS[lid]
-    vs = versiculos(lid, cap)
-    if not vs:
-        return f"<div class='pasaje'><p>No hay texto para {html.escape(d.get('es',''))} {cap}.</p></div>", "", ""
-    
-    plano_es, plano_he = [], []
-    for v in vs:
-        he_raw = html.unescape(v.get("he", "")).replace("&nbsp;", " ").replace("{פ}", "").replace("{ס}", "").strip()
-        es_raw = html.unescape(v.get("es", "")).replace("&nbsp;", " ").strip()
-        if he_raw:
-            plano_he.append(he_raw)
-        if es_raw:
-            plano_es.append(es_raw)
-            
-    # Obtenemos la versión fluida y con sentido tradicional en español mediante Groq
-    texto_bruto_es = " ".join(plano_es)
-    texto_refinado_es = refinar_texto_con_groq(texto_bruto_es) if plano_es else ""
-    texto_es_final = texto_refinado_es if texto_refinado_es else texto_bruto_es
-
-    # Construcción de la interfaz visual con hebreo intacto y limpio
-    filas = [f"<div class='cab'><span class='h'>{html.escape(html.unescape(d.get('heb','')))}</span><br>"
-             f"{html.escape(d.get('es',''))} {cap}</div>"]
-    
-    for i, v in enumerate(vs):
-        n_verso = v.get('n', i + 1)
-        he_raw = html.unescape(v.get("he", "")).replace("&nbsp;", " ").replace("{פ}", "").replace("{ס}", "").strip()
-        he_html = html.escape(he_raw)
-        
-        fila = f"<div class='verso'><span class='num'>{n_verso}</span>"
-        if he_html:
-            fila += f"<span class='he'>{he_html}</span>"
-        fila += "</div>"
-        filas.append(fila)
-        
-    # Añadir al final el bloque completo en español con sentido fluido tradicional
-    if texto_es_final:
-        filas.append(f"<div class='verso' style='margin-top: 20px; border-top: 1px solid rgba(255,255,255,0.15); padding-top: 15px;'><span class='es'><b>Traducción fluida tradicional:</b><br>{html.escape(texto_es_final)}</span></div>")
-        
-    return f"<div class='pasaje'>{''.join(filas)}</div>", texto_es_final, " ".join(plano_he)
-
-
-def estudiar(mensaje, historial, contexto):
-    if not GROQ_KEY:
-        return "Para el estudio, añade el Secret GROQ_API_KEY en el Space."
-    sistema = (
-        "Eres un compañero de estudio de la Torá que responde en español, cálido y honesto. "
-        "Ofreces el sentido literal (peshat), contexto histórico y lingüístico, capas de la "
-        "tradición (midrash, Rashi cuando venga al caso) y reflexión espiritual. Vas al grano.\n\n" + contexto
-    )
-    mensajes = [{"role": "system", "content": sistema}]
-    for m in (historial or []):
-        if isinstance(m, dict) and m.get("role") in ("user", "assistant"):
-            mensajes.append({"role": m["role"], "content": m["content"]})
-    mensajes.append({"role": "user", "content": mensaje})
-    cuerpo = {"model": MODELO_ESTUDIA, "temperature": 0.4, "max_tokens": 1200, "messages": mensajes}
     try:
         data = json.dumps(cuerpo).encode("utf-8")
         req = urllib.request.Request(GROQ_URL, data=data, method="POST")
         req.add_header("Content-Type", "application/json")
         req.add_header("Authorization", f"Bearer {GROQ_KEY}")
-        with urllib.request.urlopen(req, timeout=90) as r:
+        with urllib.request.urlopen(req, timeout=120) as r:
             d = json.load(r)
-        return (d["choices"][0]["message"]["content"] or "").strip()
+        salida = (d["choices"][0]["message"]["content"] or "").strip()
     except Exception as e:
-        return f"No pude consultar a la IA ahora mismo ({e})."
+        print(f"Error traduciendo con Groq: {e}")
+        return fallback
 
+    # Parseamos las líneas '[N] texto' a un diccionario por versículo.
+    res = {}
+    for linea in salida.splitlines():
+        m = re.match(r"\s*\[?(\d+)\]?[\.\)\|:\-]?\s*(.+)$", linea.strip())
+        if m:
+            res[int(m.group(1))] = m.group(2).strip()
 
-# ============================ INTERFAZ GRADIO ============================
-with gr.Blocks(theme=fenix_theme(), css=FENIX_CSS, title="Centralita Torá") as demo:
-    st_es = gr.State("")
-    st_he = gr.State("")
-    st_nombre = gr.State(NOMBRES[0])
-    st_cap = gr.State(1)
-
-    gr.HTML("<div id='cabecera'><div class='estrella'>✡</div>"
-            "<h1>Centralita Torá</h1><p>hebreo real e impecable · español fluido y natural</p></div>")
-
-    with gr.Tab("Leer"):
-        with gr.Row():
-            dd = gr.Dropdown(NOMBRES, value=NOMBRES[0], label="Libro")
-            ncap = gr.Number(value=1, precision=0, label="Capítulo", minimum=1)
-        ver_btn = gr.Button("Ver capítulo", variant="primary")
-        salida = gr.HTML()
-        with gr.Row():
-            b_es = gr.Button("🔊 Narrador + Voz Divina (Español)", variant="secondary")
-            b_he = gr.Button("🔊 עברית (Hebreo con Trope Real)", variant="secondary")
-        audio = gr.Audio(label="Audio Litúrgico", autoplay=True)
-
-        def ver(nombre, cap):
-            md, es, he = render(nombre, cap)
-            return md, es, he, nombre, cap
-
-        ver_btn.click(ver, [dd, ncap], [salida, st_es, st_he, st_nombre, st_cap])
-        b_es.click(leer_es, st_es, audio)
-        b_he.click(leer_he, inputs=[st_nombre, st_cap], outputs=[audio])
-
-    with gr.Tab("Buscar"):
-        q = gr.Textbox(label="Palabra o frase (hebreo o español)", placeholder="ej. luz  /  אור")
-        q_btn = gr.Button("Buscar", variant="primary")
-        q_out = gr.HTML()
-
-        def buscar(texto):
-            t = (texto or "").strip().lower()
-            if not t:
-                return "<p>Escribe algo para buscar.</p>"
-            filas = []
-            for lid in IDS:
-                d = LIBROS[lid]
-                for c, vs in d.get("capitulos", {}).items():
-                    for v in vs:
-                        campos = " ".join(filter(None, [v.get("es"), v.get("he")])).lower()
-                        if t in campos:
-                            ref = f"{d.get('es', lid)} {c}:{v.get('n')}"
-                            txt = html.escape(html.unescape(v.get("es") or v.get("he") or ""))
-                            filas.append(f"<div class='resultado'><span class='ref'>{ref}</span> — {txt}</div>")
-                            if len(filas) >= 120:
-                                return "".join(filas)
-            return "".join(filas) if filas else "<p>Sin resultados en los libros cargados.</p>"
-
-        q_btn.click(buscar, q, q_out)
-
-    with gr.Tab("Estudiar"):
-        gr.Markdown("La IA usa el capítulo abierto en **Leer** como contexto.")
-        chat = gr.Chatbot(type="messages", height=360)
-        pin = gr.Textbox(placeholder="Pregunta sobre el pasaje…", label="")
-        with gr.Row():
-            enviar = gr.Button("Preguntar", variant="primary")
-            comentar = gr.Button("Comentar este capítulo", variant="secondary")
-
-        def responder(mensaje, historial, es, he, nombre, cap):
-            mensaje = (mensaje.strip() if mensaje else "")
-            if not mensaje:
-                return historial, ""
-            contexto = f"Pasaje en pantalla — {nombre} {cap}:\nHebreo: {he}\nEspañol: {es}"
-            r = estudiar(mensaje, historial, contexto)
-            historial = (historial or []) + [
-                {"role": "user", "content": mensaje},
-                {"role": "assistant", "content": r},
-            ]
-            return historial, ""
-
-        enviar.click(responder, [pin, chat, st_es, st_he, st_nombre, st_cap], [chat, pin])
-        comentar.click(
-            lambda h, es, he, n, c: responder("Comenta y ayúdame a estudiar este capítulo.", h, es, he, n, c),
-            [chat, st_es, st_he, st_nombre, st_cap], [chat, pin],
-        )
-
-    with gr.Tab("Cómo subir"):
-        gr.Markdown(
-            "Sube un JSON por libro a la carpeta `libros/`. Para el estudio y traducción fluida, añade el Secret `GROQ_API_KEY`."
-        )
-
-if __name__ == "__main__":
-    demo.launch(ssr_mode=False)
-    # -*- coding: utf-8 -*-
-"""
-Centralita Torá — HuggingFace Space (Gradio)
-Leer hebreo real + español fluido con exégesis de Groq y audio optimizado
-"""
-import os, glob, json, tempfile, html, asyncio, subprocess, shutil, re
-import urllib.request
-import gradio as gr
-import edge_tts
-try:
-    from gtts import gTTS
-except Exception:
-    gTTS = None
-
-from gradio_theme_fenix import fenix_theme, FENIX_CSS
-
-# --- CONFIGURACIÓN DE VOZ Y AUDIO ---
-VOZ_DIVINA = "es-ES-AlvaroNeural"
-VOZ_NARRADOR = "es-ES-AlvaroNeural"  
-
-# Perillas de entonación para Narrador en Español
-VOZ_RATE = "-10%"
-VOZ_PITCH = "+5Hz"
-
-# Fondo musical
-FONDO = "fondo.mp3"
-FONDO_VOL = 0.18
-
-# IA de Estudio y Refinamiento (Groq)
-MODELO_ESTUDIA = "openai/gpt-oss-120b"
-CARPETA = "libros"
-GROQ_URL = "https://api.groq.com/openai/v1/chat/completions"
-GROQ_KEY = os.environ.get("GROQ_API_KEY")
-
-
-# --- REFINAMIENTO DE TRADUCCIÓN CON GROQ (SENTIDO TRADICIONAL) ---
-def refinar_texto_con_groq(texto_literal):
-    """
-    Toma el texto literal/interlinear y lo transforma mediante Groq 
-    a un español fluido, claro y con el sentido tradicional exacto.
-    """
-    if not GROQ_KEY or not texto_literal.strip():
-        return texto_literal
-        
-    sistema = (
-        "Eres un experto en traducción bíblica y exégesis tradicional hebrea. "
-        "Tu tarea es tomar el texto literal o interlinear proporcionado y transformarlo "
-        "a un español fluido, claro y con el sentido tradicional exacto, "
-        "manteniendo la profundidad, el respeto y la fidelidad al texto original sin perder naturalidad."
-    )
-    
-    cuerpo = {
-        "model": MODELO_ESTUDIA,
-        "temperature": 0.3,
-        "max_tokens": 2000,
-        "messages": [
-            {"role": "system", "content": sistema},
-            {"role": "user", "content": f"Por favor, da forma y sentido natural al siguiente texto manteniendo su tradición:\n\n{texto_literal}"}
-        ]
-    }
-    
-    try:
-        data = json.dumps(cuerpo).encode("utf-8")
-        req = urllib.request.Request(GROQ_URL, data=data, method="POST")
-        req.add_header("Content-Type", "application/json")
-        req.add_header("Authorization", f"Bearer {GROQ_KEY}")
-        with urllib.request.urlopen(req, timeout=90) as r:
-            d = json.load(r)
-        return (d["choices"][0]["message"]["content"] or "").strip()
-    except Exception as e:
-        print(f"Error refinando con Groq: {e}")
-        return texto_literal
+    # Si Groq se saltó algún versículo, se completa con el fallback.
+    return {n: res.get(n, fallback[n]) for (n, he, es) in pares}
 
 
 # --- PROCESAMIENTO ACÚSTICO FFMPEG ---
@@ -827,39 +377,42 @@ def render(nombre, cap):
     if not vs:
         return f"<div class='pasaje'><p>No hay texto para {html.escape(d.get('es',''))} {cap}.</p></div>", "", ""
     
-    plano_es, plano_he = [], []
-    for v in vs:
-        he_raw = html.unescape(v.get("he", "")).replace("&nbsp;", " ").replace("{פ}", "").replace("{ס}", "").strip()
-        es_raw = html.unescape(v.get("es", "")).replace("&nbsp;", " ").strip()
+    # Recopilamos (n, hebreo_limpio, español_literal) por versículo.
+    pares = []
+    plano_he = []
+    for i, v in enumerate(vs):
+        n_verso = v.get('n', i + 1)
+        he_raw = _limpiar_entidades(v.get("he", "")).replace("&nbsp;", " ").replace("{פ}", "").replace("{ס}", "").strip()
+        es_raw = _limpiar_entidades(v.get("es", "")).replace("&nbsp;", " ").strip()
+        pares.append((n_verso, he_raw, es_raw))
         if he_raw:
             plano_he.append(he_raw)
-        if es_raw:
-            plano_es.append(es_raw)
-            
-    # Obtenemos la versión fluida y con sentido tradicional en español mediante Groq
-    texto_bruto_es = " ".join(plano_es)
-    texto_refinado_es = refinar_texto_con_groq(texto_bruto_es) if plano_es else ""
-    texto_es_final = texto_refinado_es if texto_refinado_es else texto_bruto_es
 
-    # Construcción de la interfaz visual con hebreo intacto y limpio
-    filas = [f"<div class='cab'><span class='h'>{html.escape(html.unescape(d.get('heb','')))}</span><br>"
+    # Groq da SENTIDO a las palabras ANTES de mostrarlas: traduce el capítulo
+    # desde el hebreo, versículo por versículo.
+    es_por_verso = traducir_capitulo_con_groq(pares)
+
+    # Interfaz: hebreo intacto arriba y, debajo, la traducción con sentido.
+    filas = [f"<div class='cab'><span class='h'>{html.escape(_limpiar_entidades(d.get('heb','')))}</span><br>"
              f"{html.escape(d.get('es',''))} {cap}</div>"]
-    
-    for i, v in enumerate(vs):
-        n_verso = v.get('n', i + 1)
-        he_raw = html.unescape(v.get("he", "")).replace("&nbsp;", " ").replace("{פ}", "").replace("{ס}", "").strip()
-        he_html = html.escape(he_raw)
-        
+
+    partes_es = []
+    for (n_verso, he_raw, es_raw) in pares:
+        es_sentido = (es_por_verso.get(n_verso) or es_raw or "").strip()
+        if es_sentido:
+            partes_es.append(es_sentido)
+
         fila = f"<div class='verso'><span class='num'>{n_verso}</span>"
-        if he_html:
-            fila += f"<span class='he'>{he_html}</span>"
+        if he_raw:
+            fila += f"<span class='he'>{html.escape(he_raw)}</span>"
+        if es_sentido:
+            fila += f"<span class='es'>{html.escape(es_sentido)}</span>"
         fila += "</div>"
         filas.append(fila)
-        
-    # Añadir al final el bloque completo en español con sentido fluido tradicional
-    if texto_es_final:
-        filas.append(f"<div class='verso' style='margin-top: 20px; border-top: 1px solid rgba(255,255,255,0.15); padding-top: 15px;'><span class='es'><b>Traducción fluida tradicional:</b><br>{html.escape(texto_es_final)}</span></div>")
-        
+
+    # Texto que se locuta = exactamente la traducción con sentido de todo el capítulo.
+    texto_es_final = " ".join(partes_es)
+
     return f"<div class='pasaje'>{''.join(filas)}</div>", texto_es_final, " ".join(plano_he)
 
 
@@ -935,7 +488,7 @@ with gr.Blocks(theme=fenix_theme(), css=FENIX_CSS, title="Centralita Torá") as
                         campos = " ".join(filter(None, [v.get("es"), v.get("he")])).lower()
                         if t in campos:
                             ref = f"{d.get('es', lid)} {c}:{v.get('n')}"
-                            txt = html.escape(html.unescape(v.get("es") or v.get("he") or ""))
+                            txt = html.escape(_limpiar_entidades(v.get("es") or v.get("he") or ""))
                             filas.append(f"<div class='resultado'><span class='ref'>{ref}</span> — {txt}</div>")
                             if len(filas) >= 120:
                                 return "".join(filas)
@@ -976,4 +529,3 @@ with gr.Blocks(theme=fenix_theme(), css=FENIX_CSS, title="Centralita Torá") as
 
 if __name__ == "__main__":
     demo.launch(ssr_mode=False)
-