Añadir mu-plugins y scripts de feadulta

scripts/minimax_tts.py

@@ -0,0 +1,430 @@
+#!/usr/bin/env python3
+"""TTS con MiniMax (clonación de voz + síntesis de calidad). Issue #76.
+
+Credenciales en /home/rafa/Feadulta/minimax.txt:
+  - la API key (línea que empieza por 'sk-api-')
+  - el GroupId (línea 'GroupId=...' o 'group_id ...' o un número suelto)
+
+Subcomandos:
+  clone <audio.wav> <voice_id>                  sube y clona (voice_id: >=8 chars, letras+números)
+  carta <post_id> <voice_id> [model] [nombre]   locuta una carta entera
+  text  "<texto>" <voice_id> [model] [nombre]   locuta texto suelto
+models: speech-2.8-turbo (barato) | speech-2.8-hd (calidad)
+"""
+import html
+import json
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+import requests
+
+CRED = "/home/rafa/Feadulta/minimax.txt"
+BASE = "https://api.minimax.io/v1"
+OUT = Path(__file__).resolve().parent.parent / "wordpress/wp-content/uploads/tts-samples"
+CONTAINER = "wordpress-web"
+
+
+def creds():
+    key = gid = None
+    for ln in open(CRED):
+        ln = ln.strip()
+        if not ln:
+            continue
+        if ln.startswith("sk-"):
+            key = ln  # coge la última key del fichero (la más reciente)
+        elif "groupid" in ln.lower() or "group_id" in ln.lower():
+            gid = re.split(r"[=:\s]+", ln, 1)[1].strip()
+        elif ln.isdigit():
+            gid = ln
+    return key, gid
+
+
+KEY, GID = creds()
+H_JSON = {"Authorization": f"Bearer {KEY}", "Content-Type": "application/json"}
+
+
+def _q(url):
+    return f"{url}?GroupId={GID}" if GID else url
+
+
+def upload(path, purpose="voice_clone"):
+    r = requests.post(_q(f"{BASE}/files/upload"),
+                      headers={"Authorization": f"Bearer {KEY}"},
+                      data={"purpose": purpose},
+                      files={"file": open(path, "rb")})
+    j = r.json()
+    fid = (j.get("file") or {}).get("file_id")
+    if not fid:
+        sys.exit(f"upload falló: {json.dumps(j)[:400]}")
+    print(f"  file_id={fid}")
+    return fid
+
+
+def clone(audio, voice_id):
+    print(f"Subiendo {audio}…", flush=True)
+    fid = upload(audio, "voice_clone")
+    print(f"Clonando como voice_id={voice_id}…", flush=True)
+    r = requests.post(_q(f"{BASE}/voice_clone"), headers=H_JSON,
+                      json={"file_id": fid, "voice_id": voice_id, "model": "speech-2.8-hd"})
+    print(json.dumps(r.json(), ensure_ascii=False)[:500])
+
+
+def get_post_text(pid):
+    subprocess.run(["docker", "exec", CONTAINER, "php", "/tmp/fea_post_io.php", "get", str(pid)],
+                   check=True, capture_output=True)
+    subprocess.run(["docker", "cp", f"{CONTAINER}:/tmp/fea_es.json", "/tmp/fea_es.json"], check=True)
+    d = json.load(open("/tmp/fea_es.json"))
+    raw = re.sub(r"(?i)</p>|<br\s*/?>|</h[1-6]>", "\n", d["content"])
+    raw = re.sub(r"<[^>]+>", "", raw)
+    raw = re.sub(r"\[[^\]]+\]", "", raw)
+    raw = html.unescape(raw)
+    paras = [re.sub(r"\s+", " ", p).strip() for p in raw.split("\n") if len(p.strip()) > 1]
+    paras = trim_after_author_signature(paras)
+    return d["title"], "\n\n".join(paras)
+
+
+def is_author_signature(text):
+    """Heurística simple para detectar la firma final del autor.
+
+    Queremos conservar la línea del nombre y cortar todo lo que venga detrás
+    (URLs, notas, anexos o bloques extra), pero sin confundirla con títulos
+    internos del artículo.
+    """
+    text = text.strip()
+    if not text or len(text) > 80 or any(ch.isdigit() for ch in text):
+        return False
+    if any(mark in text for mark in [":", ";", "http", "www.", "@"]):
+        return False
+    words = text.split()
+    if len(words) < 2 or len(words) > 6:
+        return False
+    allowed_lower = {"de", "del", "la", "las", "los", "y", "e"}
+    for word in words:
+        clean = re.sub(r"[^\wÁÉÍÓÚÜÑáéíóúüñ-]", "", word)
+        if not clean:
+            return False
+        if clean.lower() in allowed_lower:
+            continue
+        if not clean[0].isupper():
+            return False
+    return True
+
+
+def trim_after_author_signature(paras):
+    out = []
+    for p in paras:
+        out.append(p)
+        if is_author_signature(p):
+            break
+    return out
+
+
+def _sent_pause(n_words, short, long_):
+    """Pausa (s) tras un punto, proporcional a la longitud de la frase que cierra:
+    frase corta → pausa corta; frase larga → el narrador 'respira' más."""
+    if n_words < short:
+        return os.environ.get("FEA_PAUSE_SHORT", "0.1")
+    if n_words <= long_:
+        return os.environ.get("FEA_PAUSE_MID", "0.2")
+    return os.environ.get("FEA_PAUSE_LONG", "0.3")
+
+
+def ensure_terminal_punctuation(block):
+    """Cierra con punto los bloques sin puntuación final.
+
+    MiniMax deja la entonación abierta cuando un título/párrafo termina "en seco".
+    Si el bloque ya acaba en . ! ? … : ;, se respeta.
+    """
+    block = block.strip()
+    if not block:
+        return ""
+    if block[-1] not in ".!?…:;":
+        return block + "."
+    return block
+
+
+def expand_bible_abbreviations(text):
+    """Expande abreviaturas bíblicas cuando aparecen con forma de cita.
+
+    Ejemplos:
+    - Mt 5, 1-12   -> Mateo 5, 1-12
+    - Lc 2, 10     -> Lucas 2, 10
+    - Jn 3, 16     -> Juan 3, 16
+    - Mc 1, 14     -> Marcos 1, 14
+
+    Se limita a abreviaturas seguidas de capítulo/versículo para no tocar usos
+    no bíblicos de esas siglas dentro del texto.
+    """
+    books = [
+        ("1Cor", "Primera carta a los Corintios"),
+        ("2Cor", "Segunda carta a los Corintios"),
+        ("1Tes", "Primera carta a los Tesalonicenses"),
+        ("2Tes", "Segunda carta a los Tesalonicenses"),
+        ("1Tim", "Primera carta a Timoteo"),
+        ("2Tim", "Segunda carta a Timoteo"),
+        ("1Pe", "Primera carta de Pedro"),
+        ("2Pe", "Segunda carta de Pedro"),
+        ("1Jn", "Primera carta de Juan"),
+        ("2Jn", "Segunda carta de Juan"),
+        ("3Jn", "Tercera carta de Juan"),
+        ("1Mac", "Primer libro de los Macabeos"),
+        ("2Mac", "Segundo libro de los Macabeos"),
+        ("1Sam", "Primer libro de Samuel"),
+        ("2Sam", "Segundo libro de Samuel"),
+        ("1Sm", "Primer libro de Samuel"),
+        ("2Sm", "Segundo libro de Samuel"),
+        ("1Re", "Primer libro de los Reyes"),
+        ("2Re", "Segundo libro de los Reyes"),
+        ("1Cr", "Primer libro de las Crónicas"),
+        ("2Cr", "Segundo libro de las Crónicas"),
+        ("Hch", "Hechos de los Apóstoles"),
+        ("Rom", "Romanos"),
+        ("Rm", "Romanos"),
+        ("Gal", "Gálatas"),
+        ("Gál", "Gálatas"),
+        ("Ef", "Efesios"),
+        ("Flp", "Filipenses"),
+        ("Fil", "Filipenses"),
+        ("Col", "Colosenses"),
+        ("Tit", "Tito"),
+        ("Flm", "Filemón"),
+        ("Heb", "Hebreos"),
+        ("Sant", "Santiago"),
+        ("St", "Santiago"),
+        ("Sto", "Santiago"),
+        ("Jud", "Judas"),
+        ("Ap", "Apocalipsis"),
+        ("Mt", "Mateo"),
+        ("Mc", "Marcos"),
+        ("Lc", "Lucas"),
+        ("Jn", "Juan"),
+        ("Gn", "Génesis"),
+        ("Gen", "Génesis"),
+        ("Ex", "Éxodo"),
+        ("Lv", "Levítico"),
+        ("Lev", "Levítico"),
+        ("Nm", "Números"),
+        ("Num", "Números"),
+        ("Dt", "Deuteronomio"),
+        ("Jos", "Josué"),
+        ("Jue", "Jueces"),
+        ("Rut", "Rut"),
+        ("Esd", "Esdras"),
+        ("Neh", "Nehemías"),
+        ("Tob", "Tobías"),
+        ("Jdt", "Judit"),
+        ("Est", "Ester"),
+        ("Job", "Job"),
+        ("Sal", "Salmos"),
+        ("Prov", "Proverbios"),
+        ("Cant", "Cantar de los Cantares"),
+        ("Sab", "Sabiduría"),
+        ("Eclo", "Eclesiástico"),
+        ("Sir", "Eclesiástico"),
+        ("Ecl", "Eclesiástico"),
+        ("Isa", "Isaías"),
+        ("Is", "Isaías"),
+        ("Jer", "Jeremías"),
+        ("Jr", "Jeremías"),
+        ("Lam", "Lamentaciones"),
+        ("Bar", "Baruc"),
+        ("Eze", "Ezequiel"),
+        ("Ez", "Ezequiel"),
+        ("Dan", "Daniel"),
+        ("Dn", "Daniel"),
+        ("Os", "Oseas"),
+        ("Joel", "Joel"),
+        ("Am", "Amós"),
+        ("Abd", "Abdías"),
+        ("Jon", "Jonás"),
+        ("Miq", "Miqueas"),
+        ("Nah", "Nahúm"),
+        ("Hab", "Habacuc"),
+        ("Sof", "Sofonías"),
+        ("Ag", "Ageo"),
+        ("Zac", "Zacarías"),
+        ("Mal", "Malaquías"),
+    ]
+    for short, full in books:
+        text = re.sub(
+            rf"\b{short}\.?(?=\s+\d)",
+            full,
+            text,
+        )
+    text = re.sub(r"\b1\s+Co\.?(?=\s+\d)", "Primera carta a los Corintios", text)
+    text = re.sub(r"\b2\s+Co\.?(?=\s+\d)", "Segunda carta a los Corintios", text)
+    text = re.sub(r"\b1\s+Ts\.?(?=\s+\d)", "Primera carta a los Tesalonicenses", text)
+    text = re.sub(r"\b2\s+Ts\.?(?=\s+\d)", "Segunda carta a los Tesalonicenses", text)
+    text = re.sub(r"\b1\s+P\.?(?=\s+\d)", "Primera carta de Pedro", text)
+    text = re.sub(r"\b2\s+P\.?(?=\s+\d)", "Segunda carta de Pedro", text)
+    return text
+
+
+def add_pauses(text, para=None):
+    """Pausas MiniMax <#seg#> DINÁMICAS por longitud de frase + cierre de párrafos.
+    - Tras cada fin de frase (.!?…): pausa según nº de palabras de esa frase
+      (<short=0.1s, <=long=0.2s, >long=0.3s; umbrales por palabras).
+    - A los párrafos/títulos sin puntuación final se les añade un punto, para que
+      MiniMax cierre bien la entonación (si no, deja el tono abierto)."""
+    para = para if para is not None else os.environ.get("FEA_PARA_PAUSE", "0.7")
+    short = int(os.environ.get("FEA_SHORT_WORDS", "6"))
+    long_ = int(os.environ.get("FEA_LONG_WORDS", "12"))
+    text = expand_bible_abbreviations(text)
+    out = []
+    for p in text.split("\n\n"):
+        p = ensure_terminal_punctuation(p)
+        if not p:
+            continue
+        # Reconstruir insertando pausa proporcional tras cada signo de fin de frase.
+        parts = re.split(r"([.!?…]+)", p)
+        rebuilt = ""
+        for i in range(0, len(parts), 2):
+            frase = parts[i]
+            sign = parts[i + 1] if i + 1 < len(parts) else ""
+            rebuilt += frase + sign
+            if sign and frase.strip():
+                rebuilt += f" <#{_sent_pause(len(frase.split()), short, long_)}#> "
+        # Quitar la pausa de frase final: el separador de párrafo ya aporta la suya.
+        rebuilt = re.sub(r"\s*<#[\d.]+#>\s*$", "", rebuilt)
+        out.append(rebuilt.strip())
+    return f" <#{para}#> ".join(out)
+
+
+# MiniMax limita a 10.000 car por petición; dejamos margen porque las pausas
+# <#seg#> y el language_boost también cuentan.
+CHAR_LIMIT = 8000
+
+
+def _split_for_tts(text, limit=CHAR_LIMIT):
+    """Trocea respetando las pausas <#..#> (frase/párrafo). Fallback por palabras
+    si una frase suelta supera el límite."""
+    if len(text) <= limit:
+        return [text]
+    parts = re.split(r"(\s*<#[\d.]+#>\s*)", text)
+    chunks, cur = [], ""
+    for seg in parts:
+        if not seg:
+            continue
+        if len(cur) + len(seg) <= limit:
+            cur += seg
+            continue
+        if cur.strip():
+            chunks.append(cur.strip())
+        if len(seg) > limit:                       # frase gigantesca: parte por palabras
+            cur = ""
+            for w in seg.split(" "):
+                if len(cur) + len(w) + 1 <= limit:
+                    cur += (" " if cur else "") + w
+                else:
+                    if cur:
+                        chunks.append(cur)
+                    cur = w
+        else:
+            cur = seg
+    if cur.strip():
+        chunks.append(cur.strip())
+    return chunks
+
+
+def _synth_chunk(text, voice_id, model):
+    """Una petición t2a. Devuelve (audio_bytes|None, rc, usage_chars)."""
+    body = {
+        "model": model,
+        "text": text,
+        "voice_setting": {"voice_id": voice_id, "speed": 1.0, "vol": 1.0, "pitch": 0},
+        "audio_setting": {"sample_rate": 32000, "bitrate": 128000, "format": "mp3", "channel": 1},
+        "language_boost": "Spanish",
+    }
+    r = requests.post(f"{BASE}/t2a_v2", headers=H_JSON, json=body)
+    j = r.json()
+    audio_hex = (j.get("data") or {}).get("audio")
+    if not audio_hex:
+        rc = (j.get("base_resp") or {}).get("status_code")
+        print(f"t2a falló: {json.dumps(j, ensure_ascii=False)[:300]}")
+        return None, rc, 0
+    usage = (j.get("extra_info") or {}).get("usage_characters", 0)
+    return bytes.fromhex(audio_hex), 0, usage
+
+
+def t2a(text, voice_id, model, name):
+    chunks = _split_for_tts(text)
+    print(f"Sintetizando {len(text)} car con {model} / {voice_id} "
+          f"({len(chunks)} petición/es)…", flush=True)
+    raw = OUT / f"{name}.raw.mp3"
+    if len(chunks) == 1:
+        audio, rc, _ = _synth_chunk(chunks[0], voice_id, model)
+        if audio is None:
+            return rc
+        raw.write_bytes(audio)
+    else:
+        parts = []
+        for k, ch in enumerate(chunks):
+            if k > 0:
+                import os as _os, time as _t
+                _t.sleep(int(_os.environ.get("FEA_CHUNK_PAUSE", "35")))  # respetar TPM de MiniMax
+            print(f"  trozo {k + 1}/{len(chunks)} ({len(ch)} car)…", flush=True)
+            audio, rc, _ = _synth_chunk(ch, voice_id, model)
+            if audio is None:
+                for p in parts:
+                    p.unlink(missing_ok=True)
+                return rc
+            p = OUT / f"{name}.part{k}.mp3"
+            p.write_bytes(audio)
+            parts.append(p)
+        import subprocess as sp0
+        args = ["ffmpeg", "-y"]
+        for p in parts:
+            args += ["-i", str(p)]
+        n = len(parts)
+        filt = "".join(f"[{k}:a]" for k in range(n)) + f"concat=n={n}:v=0:a=1[a]"
+        args += ["-filter_complex", filt, "-map", "[a]", "-b:a", "128k", str(raw)]
+        sp0.run(args, capture_output=True)
+        for p in parts:
+            p.unlink(missing_ok=True)
+    # Acabado: comfort noise marrón + fade in/out (quita el "bump" final).
+    import subprocess as sp
+    dur = float(sp.run(["ffprobe", "-v", "error", "-show_entries", "format=duration",
+                        "-of", "default=noprint_wrappers=1:nokey=1", str(raw)],
+                       capture_output=True, text=True).stdout.strip() or "0")
+    st = max(0.0, dur - 0.5)
+    mp3 = OUT / f"{name}.mp3"
+    sp.run(["ffmpeg", "-y", "-i", str(raw), "-filter_complex",
+            "anoisesrc=color=brown:amplitude=0.004:sample_rate=32000[n];"
+            "[n]highpass=f=120,lowpass=f=3800[nf];"
+            "[0:a][nf]amix=inputs=2:duration=first:dropout_transition=0:normalize=0[m];"
+            f"[m]afade=t=in:st=0:d=0.08,afade=t=out:st={st:.2f}:d=0.5[a]",
+            "-map", "[a]", "-b:a", "128k", str(mp3)], capture_output=True)
+    raw.unlink(missing_ok=True)
+    print(f"OK -> {mp3}  ({dur:.0f}s)")
+    return 0
+
+
+def main():
+    if len(sys.argv) < 2:
+        sys.exit(__doc__)
+    cmd = sys.argv[1]
+    if not KEY:
+        sys.exit("No encuentro la API key en " + CRED)
+    if cmd == "clone":
+        clone(sys.argv[2], sys.argv[3])
+    elif cmd == "carta":
+        pid, voice_id = sys.argv[2], sys.argv[3]
+        model = sys.argv[4] if len(sys.argv) > 4 else "speech-2.8-turbo"
+        title, text = get_post_text(int(pid))
+        name = sys.argv[5] if len(sys.argv) > 5 else f"carta-minimax-{pid}-{model.split('-')[-1]}"
+        text = add_pauses(text)
+        print(f"Post #{pid}: «{title}» ({len(text)} car con pausas)")
+        t2a(text, voice_id, model, name)
+    elif cmd == "text":
+        model = sys.argv[4] if len(sys.argv) > 4 else "speech-2.8-turbo"
+        name = sys.argv[5] if len(sys.argv) > 5 else "minimax-text"
+        t2a(sys.argv[2], sys.argv[3], model, name)
+    else:
+        sys.exit(__doc__)
+
+
+if __name__ == "__main__":
+    main()