Transcrever com Scribe v2 e cortar o vídeo pela palavra falada

# scripts/transcrever.py: Scribe v2 com tempo por palavra e SRT pelo additional_formats.
import base64
import json
import sys
from pathlib import Path

from elevenlabs.client import ElevenLabs

audio = Path(sys.argv[1])
destino = Path("transcricoes/bruto.json")
if destino.exists():
    raise SystemExit("Já existe transcrição. Revise antes de pagar outra chamada.")
Path("transcricoes").mkdir(exist_ok=True)
Path("legendas").mkdir(exist_ok=True)

cliente = ElevenLabs()  # ELEVENLABS_API_KEY no ambiente
with audio.open("rb") as arquivo:
    r = cliente.speech_to_text.convert(
        file=arquivo,
        model_id="scribe_v2",
        language_code="por",                 # Scribe aceita ISO 639-1 (pt) ou ISO 639-3 (por)
        timestamps_granularity="word",
        tag_audio_events=True,
        diarize=True,                        # entrevista: separa quem falou
        num_speakers=2,
        # keyterms=["Cozinha da Rafa", "bolo de rolo"],   # +20% (US$ 0,05/h); só se errar nomes
        additional_formats=[{
            "format": "srt",
            "max_characters_per_line": 42,
            "include_speakers": False,
            "segment_on_silence_longer_than_s": 0.6,
            "max_segment_duration_s": 4.0,
        }],
    )

dados = r.dict()
destino.write_text(json.dumps(dados, ensure_ascii=False, indent=2, default=str), encoding="utf-8")

srt = r.additional_formats[0]
conteudo = srt.content
if srt.is_base_64_encoded:                    # no SDK Python o campo JSON is_base64_encoded vira is_base_64_encoded
    conteudo = base64.b64decode(conteudo).decode("utf-8")
Path("legendas/bruto.srt").write_text(conteudo, encoding="utf-8")

palavras = [w for w in dados["words"] if w["type"] == "word"]
print(f"{len(palavras)} palavras; última termina em {palavras[-1]['end']:.2f} s")

// scripts/transcrever.ts: npx tsx scripts/transcrever.ts audio/bruto.mp3
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";
import { existsSync } from "node:fs";
import { mkdir, readFile, writeFile } from "node:fs/promises";

const caminho = process.argv[2];
if (!caminho) throw new Error("Informe o arquivo de áudio.");
if (existsSync("transcricoes/bruto.json")) throw new Error("Transcrição já existe; revise antes de pagar outra.");

const client = new ElevenLabsClient(); // ELEVENLABS_API_KEY no ambiente
const audio = new Blob([await readFile(caminho)], { type: "audio/mpeg" });

const resposta = await client.speechToText.convert({
  file: audio,
  modelId: "scribe_v2",
  languageCode: "por",
  timestampsGranularity: "word",
  tagAudioEvents: true,
  diarize: false, // um falante só: vídeo de receita narrado pela Rafa
});

await mkdir("transcricoes", { recursive: true });
await writeFile("transcricoes/bruto.json", JSON.stringify(resposta, null, 2), "utf8");

const palavras = (resposta as { words: { type: string; end: number }[] }).words.filter((w) => w.type === "word");
console.log(palavras.length + " palavras; fim em " + palavras.at(-1)?.end.toFixed(2) + " s");

#!/usr/bin/env bash
set -euo pipefail
: "$ELEVENLABS_API_KEY"
mkdir -p audio transcricoes
[ -e transcricoes/bruto.json ] && { echo "Transcrição já existe."; exit 1; }

# Cópia leve para transcrever: mono, 16 kHz, MP3 64 kbps. O bruto não muda.
ffmpeg -nostdin -v error -y -i midia/raw/bruto.mp4 -vn -ac 1 -ar 16000 -b:a 64k audio/bruto.mp3
SEG=$(ffprobe -v error -show_entries format=duration -of csv=p=0 audio/bruto.mp3)
python -c "s=float('$SEG'); print(f'{s/60:.1f} min, estimativa US$ {s/3600*0.22:.4f}')"
read -rp "Autoriza a transcrição? Digite SIM: " OK; [ "$OK" = "SIM" ] || exit 1

curl --fail-with-body -sS -X POST "https://api.elevenlabs.io/v1/speech-to-text" \
  -H "xi-api-key: $ELEVENLABS_API_KEY" \
  -F "file=@audio/bruto.mp3;type=audio/mpeg" \
  -F "model_id=scribe_v2" \
  -F "language_code=por" \
  -F "timestamps_granularity=word" \
  -F "tag_audio_events=true" \
  -F "diarize=false" \
  -o transcricoes/bruto.json.part

# Só promove se a resposta tiver words[]; erro HTTP salvo como .json não segue.
python -c "import json,sys; d=json.load(open('transcricoes/bruto.json.part',encoding='utf-8')); sys.exit(0 if isinstance(d.get('words'),list) else 1)"
mv transcricoes/bruto.json.part transcricoes/bruto.json
echo "Transcrição salva em transcricoes/bruto.json"

# scripts/descrever.py: segunda chamada ao Scribe, só para o texto de publicação.
# Uso, na raiz video-ia: python scripts/descrever.py audio/bruto.mp3
import sys
from pathlib import Path

from elevenlabs.client import ElevenLabs

audio = Path(sys.argv[1])
destino = Path("publicacao/descricao.md")
if destino.exists():
    raise SystemExit("Descrição já existe. Revise antes de pagar outra chamada.")
destino.parent.mkdir(exist_ok=True)

INSTRUCAO = (
    "Escreva em português do Brasil uma descrição de vídeo do YouTube com três parágrafos, "
    "uma lista de ingredientes com quantidades ditas na fala e uma lista de capítulos "
    "com o tema de cada etapa da receita. Não invente quantidades nem etapas."
)
print("Edição de transcrição: +30% sobre a base, mínimo de 10 s por pedido.")
if input("Autoriza a chamada paga? Digite SIM: ").strip() != "SIM":
    raise SystemExit("Cancelado.")

cliente = ElevenLabs()
with audio.open("rb") as arquivo:
    r = cliente.speech_to_text.convert(
        file=arquivo,
        model_id="scribe_v2",
        language_code="por",
        transcript_edit=INSTRUCAO,       # incompatível com entity_detection, entity_redaction e use_multi_channel
        diarize=False,
    )

# Os tempos de r.words continuam no texto original; aqui só o texto editado interessa.
editado = getattr(r, "edited_transcript", None)
if not editado:
    raise SystemExit("A resposta não trouxe edited_transcript; nada foi gravado.")
destino.write_text(editado, encoding="utf-8")
print(f"Descrição em {destino}. O corte segue usando transcricoes/bruto.json.")

# scripts/provar_corte.py: a revisão do agente é uma segunda transcrição, não a duração.
# Uso, na raiz video-ia: python scripts/provar_corte.py
import json
from pathlib import Path

from elevenlabs.client import ElevenLabs

def limpa(t):
    return t.strip(" .,!?;:").lower()

esperadas = [limpa(w["text"]) for w in json.loads(
    Path("legendas/palavras_cortado.json").read_text(encoding="utf-8"))]

cliente = ElevenLabs()
with Path("renders/cortado.mp4").open("rb") as arquivo:   # o Scribe aceita MP4 direto
    r = cliente.speech_to_text.convert(file=arquivo, model_id="scribe_v2",
                                       language_code="por", timestamps_granularity="word")
obtidas = [limpa(w.text) for w in r.words if w.type == "word"]

faltam = sorted(set(esperadas) - set(obtidas))
sobram = sorted(set(obtidas) - set(esperadas))
print(f"esperadas {len(esperadas)}, obtidas {len(obtidas)}")
print("faltam:", faltam[:20] or "nenhuma")
print("sobram:", sobram[:20] or "nenhuma")
Path("edicao/prova_corte.json").write_text(json.dumps(
    {"esperadas": len(esperadas), "obtidas": len(obtidas), "faltam": faltam, "sobram": sobram},
    ensure_ascii=False, indent=2), encoding="utf-8")
if faltam:
    raise SystemExit("Há palavra fora dos cortes aprovados que sumiu: ouça os trechos antes de seguir.")

# Uso, na raiz video-ia: python scripts/alinhar_roteiro.py audio/narracao.mp3 roteiro/roteiro.md
import json, re, sys
from pathlib import Path
from elevenlabs.client import ElevenLabs

audio, roteiro = Path(sys.argv[1]), Path(sys.argv[2])
linhas = roteiro.read_text(encoding="utf-8").splitlines()
texto = " ".join(l for l in linhas if not l.lstrip().startswith("#"))   # títulos não são falados
texto = re.sub(r"\[[^\]]+\]", " ", texto)                                # tags do v4 também não
texto = re.sub(r"\s+", " ", texto).strip()

with audio.open("rb") as f:
    r = ElevenLabs().forced_alignment.create(file=f, text=texto)

palavras = [{"text": w.text, "startMs": round(w.start * 1000), "endMs": round(w.end * 1000),
             "loss": round(w.loss, 3)} for w in r.words]
Path("legendas").mkdir(exist_ok=True)
Path("legendas/palavras_roteiro.json").write_text(
    json.dumps(palavras, ensure_ascii=False, indent=2), encoding="utf-8")

print(f"{len(palavras)} palavras, perda média {r.loss:.3f}")
for p in sorted(palavras, key=lambda p: p["loss"], reverse=True)[:10]:
    print(f"{p['startMs'] / 1000:7.2f} s  {p['text']:<22} perda {p['loss']}")