Files
CenaForge/clipper/app/editor_api.py
T
MateuusandClaude Opus 5.5 377536f778 Clipador: quem fala cada palavra (streamer × outra pessoa) e legenda em duas linhas
A fala de colegas no Discord e de outros jogadores saía na legenda como se fosse do
streamer. Agora cada palavra tem falante:

- voz: cada trecho de fala vira uma impressão de voz (WeSpeaker ResNet34-LM, ONNX,
  pesos CC-BY-4.0) na análise do bloco (~0,2 s de CPU por bloco); as vozes da sessão
  são agrupadas sob demanda (0,05 s) e a do streamer é a que mexe a boca na webcam
  (YuNet, nova série `mouth` no rastreio) ou a mais alta no áudio. Sem prova, tudo
  continua como do streamer.
- dados: `scoring.Word.speaker`; `words_json` aceita o 4º elemento; tabela
  `voice_chunks` (CREATE TABLE IF NOT EXISTS, fora da lista de migrações).
- legenda: streamer na posição normal e outra pessoa logo abaixo, em outra cor
  (`caption.otherColor`/`otherSize`); blocos nunca misturam falantes; os dois juntos
  = duas linhas; gancho desvia as duas; vertical e horizontal.
- tradução com `speaker` por linha; juízes recebem a transcrição marcada.
- painel: cor da outra pessoa na configuração, falante na transcrição do editor
  (com correção manual), prévia em duas linhas e "O que falam" no modal.
- doc/clipador/FALANTES.md com abordagem, licenças e qualidade medida na sessão 15.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 03:57:00 -03:00

479 lines
26 KiB
Python

"""Rotas do editor de cortes (`/v1/clips/{id}/edit|proxy|waveform|export|preview-render|retranscribe|tts|suggest`)
e o render do projeto chamado pela fila do motor (worker.render_clip).
O projeto fica na tabela `edits` (migração v4): `project_json` + `rev` (sobe a cada gravação; o painel manda o
`rev` que leu e recebe 409 se outro lugar salvou no meio — autosave sem atropelar). Arquivos de trabalho do
editor em `output/clipper/<sessão>/edit-<corte>/` (proxy 480p, forma de onda, narração TTS, prévia real).
"""
from __future__ import annotations
import hashlib
import json
import logging
import threading
import time
import uuid
from pathlib import Path
import httpx
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
from pydantic import BaseModel, Field
from . import editor, editor_render, layout, media, speakers
from .config import REPO_ROOT
from .db import loads, now
from .judge import JudgeError, _chat_block, _transcript
from .scoring import Word
log = logging.getLogger("cenaforge_clipper.editor")
PREVIEW_MAX_S = 10.0
RETRANSCRIBE_MAX_S = 90.0
_locks: dict[str, threading.Lock] = {}
_locks_guard = threading.Lock()
def _lock(key: str) -> threading.Lock:
with _locks_guard:
return _locks.setdefault(key, threading.Lock())
class EditPut(BaseModel):
project: dict
rev: int = Field(default=0, ge=0)
class WindowIn(BaseModel):
lo: float = Field(ge=0)
hi: float = Field(ge=0)
class PreviewRenderIn(BaseModel):
fromS: float = Field(default=0, ge=0, le=editor.MAX_OUTPUT_S)
durationS: float = Field(default=5, ge=1, le=PREVIEW_MAX_S)
project: dict | None = None # projeto ainda não salvo (o que está na tela); None = o salvo
class RangeIn(BaseModel):
startS: float = Field(ge=0)
endS: float = Field(ge=0)
class TtsIn(BaseModel):
text: str = Field(min_length=1, max_length=300)
voice: str = Field(pattern=r"^[a-z0-9][a-z0-9-]{1,47}$")
speed: float = Field(default=1.0, ge=0.5, le=2.0)
class SuggestIn(BaseModel):
project: dict | None = None
# ---------------------------------------------------------------- utilidades (também usadas pelo worker)
def edit_dir(engine, session_id: int, clip_id: int) -> Path:
return engine.settings.clips_dir / str(session_id) / f"edit-{clip_id}"
def session_segments(engine, session_id: int) -> list[tuple[Path, float, float]]:
return [(REPO_ROOT / s["file"], s["start_s"], s["end_s"])
for s in engine.db.all("SELECT * FROM segments WHERE session_id = ? AND deleted = 0 ORDER BY idx", session_id)]
def validate_for(engine, clip: dict, session: dict, data: dict) -> dict:
return editor.validate_project(
data, session_id=clip["session_id"], session_duration=session["duration_s"], repo_root=REPO_ROOT,
tts_dir=edit_dir(engine, clip["session_id"], clip["id"]), assets_dir=REPO_ROOT / "assets")
def load_edit(engine, clip_id: int) -> dict | None:
row = engine.db.get("SELECT * FROM edits WHERE clip_id = ?", clip_id)
if row:
row["project"] = loads(row["project_json"], None)
return row
def render_clip_edit(engine, clip: dict, session: dict, edit: dict, out: Path, thumb: Path) -> str | None:
"""Render do corte pelo projeto de edição (chamado pela fila do motor). Devolve o caminho da capa (ou None)."""
project = validate_for(engine, clip, session, edit["project"])
segments = session_segments(engine, clip["session_id"])
if engine._encoder is None:
engine._encoder = media.pick_encoder(engine.settings.ffmpeg or "ffmpeg", engine.settings.encoder)
base = engine.intel.settings_for(session)
credit = engine.channel_label(session)
ffmpeg = engine.settings.ffmpeg or "ffmpeg"
# A capa sai ANTES do vídeo: com `cover.atStart` ela também entra nos 2 primeiros quadros do MP4.
cover: Path | None = None
if project["cover"]["enabled"]:
cover = out.parent / f"{out.stem}-cover.jpg"
try:
editor_render.render_cover(ffmpeg, segments, project, base, credit, cover)
except media.MediaError as exc: # capa é extra: o vídeo vale mesmo sem ela
log.warning("capa do corte %s falhou: %s", clip["id"], exc)
cover = None
editor_render.render_project(ffmpeg, engine.settings.ffprobe, engine._encoder, segments, project, base, credit, out,
REPO_ROOT, chat=chat_for(engine, project), cover_file=cover,
translation=translation_for(engine, clip, project, base))
total = editor.output_duration(project["cuts"])
media.thumbnail(ffmpeg, out, min(3.0, total / 2), thumb)
# Formato em que ESTE arquivo saiu (camadas padrão ← canal ← sessão ← projeto): a fila desenha o player por ele.
engine.db.run("UPDATE clips SET aspect = ? WHERE id = ?", layout.aspect(editor.effective_settings(base, project)), clip["id"])
return cover.relative_to(REPO_ROOT).as_posix() if cover else None
def translation_for(engine, clip: dict, project: dict, base: dict, dev: bool = True) -> list[dict] | None:
"""Frases traduzidas para a legenda de desenvolvimento (doc/clipador/IDIOMAS.md): só com `dev.translation`
ligado, render de desenvolvimento e fonte em inglês. Traduz o trecho do projeto se ainda não houver tradução."""
cfg = editor.effective_settings(base, project)
if not layout.dev_flags(cfg, dev)["translation"]:
return None
ps = editor.pieces(project["cuts"])
if not ps:
return None
data = engine.translate_clip(clip["id"], ps[0].start, ps[-1].end)
return (data or {}).get("lines") or None
def chat_for(engine, project: dict) -> list | None:
"""Mensagens do chat da sessão para o bloco "chat na tela" (só quando o projeto pede)."""
if not (project.get("chat") or {}).get("enabled"):
return None
lo = project["source"]["lo"]
return engine.load_timeline(project["source"]["sessionId"], max(0.0, lo - 30))["chat"]
def _judge(clip: dict) -> dict:
data = loads(clip.get("judge_json"), None)
return data if isinstance(data, dict) else {}
def auto_for(engine, clip: dict, session: dict) -> dict:
"""Projeto que a IA entrega: o que o pipeline já sabe (análise, Whisper, volume, configuração do corte)."""
judge = _judge(clip)
lo, hi = editor.default_window(clip, session["duration_s"])
words = engine.words_between(clip["session_id"], lo, hi) # já com quem fala cada palavra (FALANTES.md)
loudness = engine.load_timeline(clip["session_id"], max(0.0, lo - 5))["loudness"]
return editor.auto_project(clip, judge.get("analysis"), words, loudness, session["duration_s"],
engine.intel.settings_for(session), model=judge.get("model") or "", generated_at=now())
def ensure_edit(engine, clip: dict, session: dict) -> dict:
"""Garante o projeto de edição do corte (um só caminho de render: projeto → FFmpeg). Sem projeto, a IA gera um
agora e ele fica salvo como "gerado pela IA". O trecho do corte (start/end) passa a ser o do projeto."""
row = load_edit(engine, clip["id"])
if row and row["project"]:
return row
project = validate_for(engine, clip, session, auto_for(engine, clip, session))
raw = json.dumps(project, ensure_ascii=False)
ts = now()
engine.db.run("INSERT OR REPLACE INTO edits (clip_id, project_json, origin, ai_project_json, rev, created_at, updated_at)"
" VALUES (?, ?, 'ai', ?, 1, ?, ?)", clip["id"], raw, raw, ts, ts)
start, end = editor.span(project)
engine.db.run("UPDATE clips SET start_s = ?, end_s = ? WHERE id = ?", start, end, clip["id"])
return load_edit(engine, clip["id"])
def retime_edit(engine, clip_id: int, start: float, end: float) -> None:
"""O cartão mudou início/fim de um corte com edição: estica/encolhe as pontas do projeto."""
row = load_edit(engine, clip_id)
if not row or not row["project"]:
return
project = editor.retime(row["project"], start, end)
engine.db.run("UPDATE edits SET project_json = ?, rev = rev + 1, updated_at = ? WHERE clip_id = ?",
json.dumps(project, ensure_ascii=False), now(), clip_id)
def _audio_library() -> list[dict]:
root = REPO_ROOT / "assets"
out = []
if root.is_dir():
for f in sorted(root.rglob("*")):
if f.is_file() and f.suffix.lower() in editor.AUDIO_EXT:
out.append({"file": f.relative_to(REPO_ROOT).as_posix(), "name": f.stem})
if len(out) >= 200:
break
return out
def _window_key(lo: float, hi: float) -> str:
return f"{int(round(lo * 1000))}-{int(round(hi * 1000))}"
def _clean_old(folder: Path, prefix: str, keep: str) -> None:
for f in folder.glob(f"{prefix}-*"):
if f.name != keep:
f.unlink(missing_ok=True)
# ---------------------------------------------------------------- rotas
def register(app: FastAPI, engine, clip_view, get_clip) -> None:
"""`clip_view(row)` e `get_clip(id)` vêm do main (mesmo formato do resto da API; 404 se não existir)."""
db, settings = engine.db, engine.settings
ffmpeg = settings.ffmpeg or "ffmpeg"
@app.exception_handler(editor.EditError)
async def edit_error(_request: Request, exc: editor.EditError):
return JSONResponse({"error": str(exc)}, status_code=400)
@app.exception_handler(media.MediaError)
async def media_error(_request: Request, exc: media.MediaError):
return JSONResponse({"error": f"FFmpeg: {exc}"}, status_code=400)
def _context(clip_id: int) -> tuple[dict, dict]:
clip = get_clip(clip_id)
session = db.get("SELECT * FROM sessions WHERE id = ?", clip["session_id"])
if not session:
raise editor.EditError("sessão do corte não existe mais")
return clip, session
def _check_window(session: dict, lo: float, hi: float) -> tuple[float, float]:
lo, hi = max(0.0, lo), min(hi, session["duration_s"])
if not 5 <= hi - lo <= editor.MAX_WINDOW_S:
raise editor.EditError(f"a janela precisa ter de 5 s a {editor.MAX_WINDOW_S / 60:.0f} min dentro da gravação")
segs = db.all("SELECT deleted FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ?", session["id"], lo, hi)
if not segs:
raise editor.EditError("não há gravação nessa janela")
if any(s["deleted"] for s in segs):
raise editor.EditError("parte dessa janela já foi apagada (CLIPPER_KEEP_HOURS); escolha uma janela menor")
return round(lo, 3), round(hi, 3)
def _words(session_id: int, lo: float, hi: float) -> list[Word]:
return [w for w in engine.words_between(session_id, lo, hi) if lo <= w.start <= hi]
def _cached_proxy(clip: dict, lo: float, hi: float) -> dict | None:
f = edit_dir(engine, clip["session_id"], clip["id"]) / f"proxy-{_window_key(lo, hi)}.mp4"
return {"file": f.relative_to(REPO_ROOT).as_posix(), "lo": lo, "hi": hi} if f.is_file() else None
def _cached_wave(clip: dict, lo: float, hi: float) -> list[float] | None:
f = edit_dir(engine, clip["session_id"], clip["id"]) / f"waveform-{_window_key(lo, hi)}.json"
return loads(f.read_text(encoding="utf-8"), None) if f.is_file() else None
@app.get("/v1/clips/{clip_id}/edit")
def get_edit(clip_id: int, lo: float | None = None, hi: float | None = None):
"""Tudo que o editor precisa: projeto (salvo ou o padrão), palavras/chat/volume da janela, análise da IA,
configuração efetiva, presets, biblioteca de áudio e o que já está pronto (proxy, forma de onda)."""
clip, session = _context(clip_id)
row = load_edit(engine, clip_id)
view = clip_view(clip)
if row and row["project"]:
project, rev = row["project"], row["rev"]
ai_project = loads(row.get("ai_project_json"), None)
else:
project = ai_project = auto_for(engine, clip, session) # o que a IA entregaria (ainda não salvo)
rev = 0
w_lo = project["source"]["lo"] if lo is None else lo
w_hi = project["source"]["hi"] if hi is None else hi
w_lo, w_hi = _check_window(session, w_lo, w_hi)
tl = engine.load_timeline(clip["session_id"], max(0.0, w_lo - 5))
chat = [{"t": round(m.t, 2), "user": m.user, "text": m.text[:160], "emotes": list(m.emotes)}
for m in tl["chat"] if w_lo <= m.t <= w_hi][:600]
per_s = [0] * int(w_hi - w_lo + 1)
for m in tl["chat"]:
if w_lo <= m.t <= w_hi:
per_s[int(m.t - w_lo)] += 1
loud = tl["loudness"][int(w_lo): int(w_hi) + 1]
analysis = (view["judge"] or {}).get("analysis") if isinstance(view["judge"], dict) else None
return {
"clip": view, "project": project, "rev": rev, "saved": bool(row),
"origin": row["origin"] if row else "ai", "aiProject": ai_project,
"exportedAt": row["exported_at"] if row else None, "cover": row["cover"] if row else None,
"window": {"lo": w_lo, "hi": w_hi}, "sessionDurationS": session["duration_s"],
"words": [editor.word_item(w) for w in _words(clip["session_id"], w_lo, w_hi)],
"chat": chat, "chatPerS": per_s, "loudnessDb": loud, "analysis": analysis,
"settings": engine.intel.settings_for(session), "credit": engine.channel_label(session),
"presets": [{"id": k, "label": editor.PRESET_LABEL[k], "style": editor.PRESET_STYLE[k]} for k in editor.CAPTION_PRESETS],
"audioLibrary": _audio_library(), "proxy": _cached_proxy(clip, w_lo, w_hi),
"waveform": _cached_wave(clip, w_lo, w_hi), "peaksPerS": editor_render.PEAKS_PER_S,
"judgeEnabled": engine.judge.enabled, "voiceConfigured": engine.voice.configured,
"limits": {"maxWindowS": editor.MAX_WINDOW_S, "maxOutputS": editor.MAX_OUTPUT_S, "minOutputS": editor.MIN_OUTPUT_S,
"previewMaxS": PREVIEW_MAX_S, "retranscribeMaxS": RETRANSCRIBE_MAX_S},
}
@app.put("/v1/clips/{clip_id}/edit")
def put_edit(clip_id: int, body: EditPut):
"""Salva o projeto (autosave). `rev` = o que o painel leu; diferente do banco → 409 (outro salvou antes)."""
clip, session = _context(clip_id)
project = validate_for(engine, clip, session, body.project)
ts = now()
with db.lock:
row = db.get("SELECT rev FROM edits WHERE clip_id = ?", clip_id)
if row and body.rev != row["rev"]:
return JSONResponse({"error": "O projeto foi salvo em outro lugar. Recarregue o editor.", "rev": row["rev"]},
status_code=409)
if row:
db.run("UPDATE edits SET project_json = ?, origin = 'user', rev = rev + 1, updated_at = ? WHERE clip_id = ?",
json.dumps(project, ensure_ascii=False), ts, clip_id)
else:
ai = json.dumps(auto_for(engine, clip, session), ensure_ascii=False)
db.run("INSERT INTO edits (clip_id, project_json, origin, ai_project_json, rev, created_at, updated_at)"
" VALUES (?, ?, 'user', ?, 1, ?, ?)", clip_id, json.dumps(project, ensure_ascii=False), ai, ts, ts)
rev = db.get("SELECT rev FROM edits WHERE clip_id = ?", clip_id)["rev"]
return {"project": project, "rev": rev, "savedAt": ts, "durationS": editor.output_duration(project["cuts"])}
@app.delete("/v1/clips/{clip_id}/edit", status_code=204)
def delete_edit(clip_id: int):
"""Descarta a edição: o corte volta a ser renderizado do jeito automático (o MP4 atual fica até o próximo render)."""
get_clip(clip_id)
db.run("DELETE FROM edits WHERE clip_id = ?", clip_id)
@app.post("/v1/clips/{clip_id}/proxy")
def make_proxy(clip_id: int, body: WindowIn):
"""Vídeo leve (480p) da janela para a prévia no navegador. Fica em cache por janela."""
clip, session = _context(clip_id)
lo, hi = _check_window(session, body.lo, body.hi)
folder = edit_dir(engine, clip["session_id"], clip_id)
name = f"proxy-{_window_key(lo, hi)}.mp4"
with _lock(f"proxy-{clip_id}"):
if not (folder / name).is_file():
t = time.monotonic()
editor_render.make_proxy(ffmpeg, session_segments(engine, clip["session_id"]), lo, hi, folder / name)
log.info("proxy do corte %s (%.0f s de vídeo) em %.1f s", clip_id, hi - lo, time.monotonic() - t)
_clean_old(folder, "proxy", name)
return _cached_proxy(clip, lo, hi) | {"words": [editor.word_item(w) for w in _words(clip["session_id"], lo, hi)]}
@app.get("/v1/clips/{clip_id}/waveform")
def get_waveform(clip_id: int, lo: float, hi: float):
clip, session = _context(clip_id)
lo, hi = _check_window(session, lo, hi)
folder = edit_dir(engine, clip["session_id"], clip_id)
name = f"waveform-{_window_key(lo, hi)}.json"
with _lock(f"wave-{clip_id}"):
peaks = _cached_wave(clip, lo, hi)
if peaks is None:
peaks = editor_render.waveform(ffmpeg, session_segments(engine, clip["session_id"]), lo, hi, folder)
folder.mkdir(parents=True, exist_ok=True)
(folder / name).write_text(json.dumps(peaks), encoding="utf-8")
_clean_old(folder, "waveform", name)
return {"lo": lo, "hi": hi, "peaksPerS": editor_render.PEAKS_PER_S, "peaks": peaks}
@app.post("/v1/clips/{clip_id}/preview-render")
def preview_render(clip_id: int, body: PreviewRenderIn):
"""Prévia REAL (mesma pipeline do export) de poucos segundos, a partir de `fromS` do corte editado."""
clip, session = _context(clip_id)
row = load_edit(engine, clip_id)
data = body.project or (row["project"] if row else None)
if not data:
raise editor.EditError("salve o projeto antes (ou mande o projeto na prévia)")
project = validate_for(engine, clip, session, data)
total = editor.output_duration(project["cuts"])
a = min(body.fromS, max(0.0, total - 1))
b = min(total, a + body.durationS)
out = edit_dir(engine, clip["session_id"], clip_id) / "preview.mp4"
segments = session_segments(engine, clip["session_id"])
base, credit = engine.intel.settings_for(session), engine.channel_label(session)
with _lock(f"preview-{clip_id}"):
t = time.monotonic()
# Prévia que começa no 0 s com `cover.atStart`: a capa entra nos 2 primeiros quadros, como no export.
cover = None
if a <= 0.001 and project["cover"]["enabled"] and project["cover"].get("atStart"):
cover = out.parent / "preview-cover.jpg"
try:
editor_render.render_cover(ffmpeg, segments, project, base, credit, cover)
except media.MediaError as exc: # capa é extra: a prévia vale mesmo sem ela
log.warning("capa da prévia do corte %s falhou: %s", clip_id, exc)
cover = None
editor_render.render_project(ffmpeg, settings.ffprobe, ["-c:v", "libx264", "-preset", "veryfast", "-crf", "24"],
segments, project, base, credit, out, REPO_ROOT,
out_range=(a, b), timeout=180, chat=chat_for(engine, project), cover_file=cover,
translation=translation_for(engine, clip, project, base))
took = time.monotonic() - t
return {"file": out.relative_to(REPO_ROOT).as_posix(), "fromS": a, "toS": b, "seconds": round(took, 1), "version": now()}
@app.post("/v1/clips/{clip_id}/export")
def export(clip_id: int):
"""Exporta: o corte volta para a fila de render com o projeto salvo; ao terminar fica `ready` (para aprovar)."""
clip, session = _context(clip_id)
row = load_edit(engine, clip_id)
if not row or not row["project"]:
raise editor.EditError("nada para exportar: salve o projeto primeiro")
project = validate_for(engine, clip, session, row["project"])
start, end = editor.span(project)
segs = db.all("SELECT deleted FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ?", clip["session_id"], start, end)
if not segs or any(s["deleted"] for s in segs):
raise editor.EditError("os blocos gravados deste trecho já foram apagados")
words = editor.output_words(project)
ts = now()
db.run("UPDATE clips SET start_s = ?, end_s = ?, status = 'pending', error = NULL, transcript = ?, updated_at = ? WHERE id = ?",
start, end, " ".join(w.word for w in words)[:4000], ts, clip_id)
db.run("UPDATE edits SET exported_at = ? WHERE clip_id = ?", ts, clip_id)
engine.wake_clips.set()
return clip_view(get_clip(clip_id)) | {"editedDurationS": editor.output_duration(project["cuts"])}
@app.post("/v1/clips/{clip_id}/retranscribe")
def retranscribe(clip_id: int, body: RangeIn):
"""Transcreve de novo (Whisper do serviço de voz, palavra a palavra) o trecho [startS, endS] da sessão."""
clip, session = _context(clip_id)
a, b = body.startS, min(body.endS, session["duration_s"])
if not 0.5 <= b - a <= RETRANSCRIBE_MAX_S:
raise editor.EditError(f"o trecho precisa ter de 0,5 a {RETRANSCRIBE_MAX_S:.0f} s")
if not engine.voice.configured:
raise editor.EditError("serviço de voz não instalado")
wav = editor_render.extract_wav(ffmpeg, session_segments(engine, clip["session_id"]), a, b,
edit_dir(engine, clip["session_id"], clip_id))
t = time.monotonic()
try:
words = engine.voice.transcribe(wav, f"clipper-edit-{clip_id}-{uuid.uuid4().hex[:12]}")
except Exception as exc: # noqa: BLE001 - erro do serviço de voz vira mensagem
raise editor.EditError(f"transcrição falhou: {str(exc)[:200]}") from exc
# Quem fala: o mesmo das palavras antigas no mesmo instante (a re-transcrição não sabe o falante).
fresh = speakers.transfer([Word(round(w.start + a, 3), round(w.end + a, 3), w.word) for w in words],
_words(clip["session_id"], a - 1, b + 1))
return {"startS": a, "endS": b, "seconds": round(time.monotonic() - t, 1),
"words": [editor.word_item(w) for w in fresh]}
@app.post("/v1/clips/{clip_id}/tts")
def tts(clip_id: int, body: TtsIn):
"""Narração pelo serviço de voz (WAV, para mixar sem perda). Guarda em edit-<corte>/tts-<hash>.wav."""
clip, _session = _context(clip_id)
voice = engine.voice
if not voice.configured:
raise editor.EditError("serviço de voz não instalado")
text = editor.CONTROL_RE.sub(" ", body.text).strip()
digest = hashlib.sha256(f"{body.voice}|{body.speed:.2f}|{text}".encode("utf-8")).hexdigest()[:12]
folder = edit_dir(engine, clip["session_id"], clip_id)
out = folder / f"tts-{digest}.wav"
if not out.is_file():
try:
response = httpx.post(f"{voice.url}/v1/synthesize", timeout=300, headers={"X-Service-Key": voice.key or ""},
json={"requestId": f"clipper-{uuid.uuid4().hex[:24]}", "text": text, "voiceId": body.voice,
"params": {"speed": body.speed, "format": "wav"}})
except httpx.HTTPError as exc:
raise editor.EditError("serviço de voz fora do ar (127.0.0.1:4510)") from exc
if response.status_code != 200:
try:
detail = response.json().get("error") or response.json().get("detail") or response.text
except ValueError:
detail = response.text
raise editor.EditError(f"voz respondeu {response.status_code}: {str(detail)[:200]}")
folder.mkdir(parents=True, exist_ok=True)
out.write_bytes(response.content)
duration = media.probe_duration(settings.ffprobe, out) if settings.ffprobe else 0.0
return {"file": out.relative_to(REPO_ROOT).as_posix(), "durationS": round(duration, 3), "text": text, "voice": body.voice}
@app.post("/v1/clips/{clip_id}/suggest")
def suggest(clip_id: int, body: SuggestIn):
"""IA sugere gancho, título, início/fim ideais, trechos mortos para remover e instantes de zoom."""
clip, session = _context(clip_id)
if not engine.judge.enabled:
raise editor.EditError("IA desligada (página Clipador → Juiz)")
row = load_edit(engine, clip_id)
data = body.project or (row["project"] if row else None) or editor.default_project(
clip, [], session["duration_s"])
project = validate_for(engine, clip, session, data)
lo, hi = project["source"]["lo"], project["source"]["hi"]
tl = engine.load_timeline(clip["session_id"], max(0.0, lo - 5))
words = [Word(w["s"], w["e"], w["w"], w.get("sp") or "") for w in project["captions"]["words"]] or tl["words"]
view = clip_view(clip)
analysis = (view["judge"] or {}).get("analysis") if isinstance(view["judge"], dict) else None
cfg = editor.effective_settings(engine.intel.settings_for(session), project)
prompt = editor.suggest_prompt(engine.streamer_name(session), clip["title"], project, tl["chat"], analysis,
_transcript(words, lo, hi, streamer=engine.streamer_name(session)), _chat_block(tl["chat"], lo, hi, clip["peak_s"]), cfg)
t = time.monotonic()
try:
raw = engine.judge.ask(editor.SUGGEST_SYSTEM, prompt, editor.SUGGEST_SCHEMA, [])
except JudgeError as exc:
raise editor.EditError(f"IA: {exc}") from exc
# Sugestão da IA = caminho automático: mínimo + 1 s e máximo da configuração do corte.
return editor.clean_suggestion(raw, lo, hi, layout.min_target(cfg), float(cfg["duration"]["maxS"])) | {"seconds": round(time.monotonic() - t, 1),
"model": engine.judge.describe().get("model")}