Narrar em português com Eleven v4 por API e usar o Flash no volume

# scripts/narrar_v4.py: narração com Eleven v4 pela Text to Dialogue (SDK 2.71.0).
import json
import os
import re
import sys
from pathlib import Path

from elevenlabs import DialogueInput
from elevenlabs.client import ElevenLabs

LIMITE_PEDIDO = 2_000   # a Text to Dialogue pede até 2.000 caracteres somados por pedido
PRECO_LISTA = 0.08      # US$ por mil caracteres; o lançamento a US$ 0,022 terminou em 12/10/2026


def dividir(texto: str, limite: int) -> list[str]:
    """Quebra o roteiro em pedidos de até "limite" caracteres, sem cortar frase."""
    pedidos, atual = [], ""
    for frase in re.split(r"(?<=[.!?…])\s+|\n{2,}", texto):
        frase = frase.strip()
        if not frase:
            continue
        if len(frase) > limite:
            raise SystemExit(f"Frase com {len(frase)} caracteres: quebre-a no roteiro.")
        if atual and len(atual) + 1 + len(frase) > limite:
            pedidos.append(atual)
            atual = frase
        else:
            atual = f"{atual} {frase}".strip()
    if atual:
        pedidos.append(atual)
    return pedidos


entrada, saida = Path(sys.argv[1]), Path(sys.argv[2])
texto = entrada.read_text(encoding="utf-8").strip()

# Dicionário local de locução: a troca de grafia acontece no texto, antes do
# envio, e a legenda sai do roteiro original. Ex.: {"mise en place": "mizanplás"}
dic_path = Path("config/pronuncia.json")
if dic_path.exists():
    for grafia, leitura in json.loads(dic_path.read_text(encoding="utf-8")).items():
        texto = texto.replace(grafia, leitura)

if saida.exists():
    raise SystemExit(f"{saida} já existe. Ouça antes de gerar de novo.")

pedidos = dividir(texto, LIMITE_PEDIDO)
estimativa = len(texto) / 1000 * PRECO_LISTA
print(f"{len(texto)} caracteres em {len(pedidos)} pedido(s); estimativa pelo preço de lista: US$ {estimativa:.4f}")
if input("Autoriza a geração paga? Digite SIM: ").strip() != "SIM":
    raise SystemExit("Cancelado.")

cliente = ElevenLabs()  # lê ELEVENLABS_API_KEY do ambiente
voz = os.environ["ELEVENLABS_VOICE_ID"]
saida.parent.mkdir(parents=True, exist_ok=True)
temporario = saida.with_suffix(".part")

# Um pedido por trecho, na ordem. Quadros de MP3 do mesmo formato podem ser
# emendados em sequência; para WAV ou PCM, junte com o concat do FFmpeg.
with temporario.open("wb") as arquivo:
    for trecho in pedidos:
        audio = cliente.text_to_dialogue.convert(
            model_id="eleven_v4",
            language_code="pt",
            inputs=[DialogueInput(text=trecho, voice_id=voz)],
            output_format="mp3_44100_128",   # padrão documentado
        )
        for bloco in audio:
            if bloco:
                arquivo.write(bloco)
if temporario.stat().st_size == 0:
    raise RuntimeError("A API devolveu áudio vazio.")
temporario.replace(saida)

Path("logs").mkdir(exist_ok=True)
Path(f"logs/{saida.stem}.json").write_text(json.dumps({
    "modelo": "eleven_v4",
    "voice_id": voz,
    "caracteres": len(texto),
    "pedidos": len(pedidos),
    "estimativa_usd_lista": round(estimativa, 4),
    "arquivo": str(saida),
}, ensure_ascii=False, indent=2), encoding="utf-8")
print(f"Áudio salvo em {saida}")

// scripts/narrar-v4.ts: a mesma narração com o SDK oficial de TypeScript.
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";
import { createWriteStream, existsSync } from "node:fs";
import { readFile, rename } from "node:fs/promises";
import { Readable } from "node:stream";
import { pipeline } from "node:stream/promises";

const ENTRADA = "roteiro/amostra.txt";
const SAIDA = "audio/amostra_v4.mp3";
const voiceId = process.env.ELEVENLABS_VOICE_ID;
if (!voiceId) throw new Error("Defina ELEVENLABS_VOICE_ID no ambiente.");
if (existsSync(SAIDA)) throw new Error(SAIDA + " já existe. Ouça antes de gerar de novo.");

const texto = (await readFile(ENTRADA, "utf8")).trim();
// A Text to Dialogue pede até 2.000 caracteres somados por pedido; acima disso, divida como no script Python.
if (texto.length > 2_000) throw new Error("Acima de 2.000 caracteres: divida o roteiro em pedidos menores.");
console.log("Estimativa pelo preço de lista: US$ " + ((texto.length / 1000) * 0.08).toFixed(4));

const client = new ElevenLabsClient(); // lê ELEVENLABS_API_KEY do ambiente
const audio = await client.textToDialogue.convert({
  modelId: "eleven_v4",
  languageCode: "pt",
  outputFormat: "mp3_44100_128",
  inputs: [{ text: texto, voiceId }],
});

// Grava num arquivo temporário e só renomeia quando o fluxo termina.
const temporario = SAIDA + ".part";
await pipeline(Readable.fromWeb(audio as any), createWriteStream(temporario));
await rename(temporario, SAIDA);
console.log("Áudio salvo em " + SAIDA);

#!/usr/bin/env bash
set -euo pipefail
: "$ELEVENLABS_API_KEY"   # falha cedo se a chave não estiver no ambiente

# VOZ_RAFA e VOZ_CONVIDADO são voice_id da sua conta.
mkdir -p logs
cat > logs/pedido_v4.json <<'JSON'
{
  "model_id": "eleven_v4",
  "language_code": "pt",
  "inputs": [
    { "text": "[curious] Você já provou bolo de rolo de verdade?", "voice_id": "VOZ_RAFA" },
    { "text": "[laughs] Só o de padaria... e não é a mesma coisa.", "voice_id": "VOZ_CONVIDADO" }
  ]
}
JSON

curl --fail-with-body -sS -X POST \
  "https://api.elevenlabs.io/v1/text-to-dialogue?output_format=mp3_44100_128" \
  -H "xi-api-key: $ELEVENLABS_API_KEY" \
  -H "Content-Type: application/json" \
  --data @logs/pedido_v4.json \
  -o audio/dialogo_v4.mp3

# Confirma que o arquivo é áudio de verdade, não um JSON de erro salvo como .mp3.
ffprobe -v error -show_entries format=duration:stream=codec_name \
  -of default=noprint_wrappers=1 audio/dialogo_v4.mp3

# Substitui o laço "for trecho in pedidos" do scripts/narrar_v4.py.
anteriores: list[str] = []          # ids dos pedidos já gerados (cabeçalho request-id)
with temporario.open("wb") as arquivo:
    for i, trecho in enumerate(pedidos):
        anterior = pedidos[i - 1][-100:] if i else None                    # até 100 caracteres
        seguinte = pedidos[i + 1][:100] if i + 1 < len(pedidos) else None   # até 100 caracteres
        resposta = cliente.text_to_dialogue.with_raw_response.convert(
            model_id="eleven_v4",
            language_code="pt",
            inputs=[DialogueInput(text=trecho, voice_id=voz)],
            output_format="mp3_44100_128",
            previous_text=anterior,
            future_text=seguinte,
            previous_request_ids=anteriores[-3:] or None,                   # até três ids
        )
        for bloco in resposta.data:
            if bloco:
                arquivo.write(bloco)
        id_pedido = resposta.headers.get("request-id")
        if id_pedido:
            anteriores.append(id_pedido)
print(f"{len(pedidos)} pedido(s) encadeados; ids em logs/{saida.stem}.json")

# Uso, na raiz video-ia: python scripts/narrar_com_legenda.py roteiro/bloco_01.txt
import base64, json, os, sys
from pathlib import Path
from elevenlabs.client import ElevenLabs

entrada = Path(sys.argv[1]); nome = entrada.stem
texto = entrada.read_text(encoding="utf-8").strip()
SEMENTE = 20261012

resp = ElevenLabs().text_to_speech.with_raw_response.convert_with_timestamps(
    voice_id=os.environ["ELEVENLABS_VOICE_ID"],
    model_id="eleven_flash_v2_5",
    language_code="pt",
    text=texto,
    seed=SEMENTE,                       # leitura parecida ao refazer (melhor esforço)
    apply_text_normalization="on",      # números e símbolos por extenso antes de falar
    output_format="mp3_44100_128",
)
dados = resp.data
for pasta in ("audio", "legendas", "logs"):
    Path(pasta).mkdir(exist_ok=True)
Path(f"audio/{nome}_flash.mp3").write_bytes(base64.b64decode(dados.audio_base_64))

# Caracteres -> palavras: a palavra vai do primeiro ao último caractere
al, palavras, atual = dados.alignment, [], ""
for ch, t0, t1 in zip(al.characters, al.character_start_times_seconds, al.character_end_times_seconds):
    if ch.isspace():
        if atual:
            palavras.append((atual, ini, fim)); atual = ""
        continue
    if not atual:
        ini = t0
    atual += ch; fim = t1
if atual:
    palavras.append((atual, ini, fim))

def ts(s):
    ms = round(s * 1000); h, ms = divmod(ms, 3600000); m, ms = divmod(ms, 60000); s2, ms = divmod(ms, 1000)
    return f"{h:02}:{m:02}:{s2:02},{ms:03}"

blocos, bloco = [], []
for p in palavras:                       # até 42 caracteres por legenda
    if bloco and len(" ".join(x[0] for x in bloco + [p])) > 42:
        blocos.append(bloco); bloco = []
    bloco.append(p)
if bloco:
    blocos.append(bloco)
with open(f"legendas/{nome}.srt", "w", encoding="utf-8") as srt:
    for i, b in enumerate(blocos, 1):
        srt.write(f"{i}\n{ts(b[0][1])} --> {ts(b[-1][2])}\n{' '.join(x[0] for x in b)}\n\n")

custo = resp.headers.get("character-cost")
Path(f"logs/{nome}_flash.json").write_text(json.dumps({
    "modelo": "eleven_flash_v2_5", "seed": SEMENTE, "caracteres_cobrados": custo,
    "request_id": resp.headers.get("request-id"), "legendas": len(blocos),
}, ensure_ascii=False, indent=2), encoding="utf-8")
print(f"{len(palavras)} palavras, {len(blocos)} legendas, character-cost {custo}")