Files
CenaForge/clipper/app/editor_api.py
T
MateuusandClaude Opus 5.5 cb8450399d Clipador: Equipe de IA (papéis com IA própria), juiz de contexto e linha do tempo JSON
- roles.py: varredura, analista, editor e juiz, cada um com provedor, modelo, raciocínio
  (Codex), liga/desliga (o editor não desliga) e instruções do administrador somadas às
  padrão; gravado em settings `judge.roles`, com migração automática da configuração antiga
  (provedor/modelo único vira o de todos; o modelo do analista é respeitado). A reserva vale
  por papel.
- Juiz de contexto (só texto): vê só o que vai no corte (+20 s antes/15 s depois marcados
  out=1), escreve o que um espectador frio entende e responde sim/não; context_judge.decide
  decide pelo código: aprova, ajusta o trecho e confere uma vez de novo, frase de contexto
  na tela (vira o texto de abertura do projeto) ou descarta com motivo em português
  (forçável). Corte manual só recebe aviso.
- timeline.py: linha do tempo JSON curta (fala com falante, chat, rosto, volume e a frase
  de tela que a varredura/analista escrevem ao ver os quadros, em scene_notes); mosaico 4x2
  (media.mosaic) no lugar dos quadros soltos; perfil do jogo enxuto. O formato antigo fica
  atrás da opção timelineJson.
- Medição (F0): ai_calls por chamada (papel, IA, tamanho do prompt/imagens, tokens quando a
  CLI informa: codex --json, claude e gemini), avaliação do dono (owner_label: bom/ruim/sem
  contexto) e GET /v1/judge/report (taxa de aprovação, decisões do juiz, concordância).
- Banco v17 (v16 fica reservada às expressões, como marcador sem efeito).
- Testes: test_roles.py e test_context_judge.py; os testes bloqueiam qualquer CLI de IA real.

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

511 lines
28 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 dub, 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, dev: bool = True) -> str | None:
"""Render do corte pelo projeto de edição (chamado pela fila do motor). Devolve o caminho da capa (ou None).
`dev=True` = vídeo de REVISÃO (com as camadas `dev` ligadas; grava quais entraram em `clips.review_dev_json`);
`dev=False` = vídeo FINAL, depois de aprovar (sem nenhuma camada de desenvolvimento) — doc/clipador/REVISAO.md."""
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
translation = translation_for(engine, clip, project, base, dev=dev)
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, dev=dev, dubber=dub.for_engine(engine))
if dev:
layers = review_layers(editor.effective_settings(base, project), translation)
engine.db.run("UPDATE clips SET review_dev_json = ? WHERE id = ?", json.dumps(layers), clip["id"])
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 review_layers(cfg: dict, translation: list[dict] | None) -> list[str]:
"""Camadas de desenvolvimento que entraram no vídeo de revisão (vazio = ele já é o vídeo final). A tradução só
conta se havia frases para desenhar (fonte em português nunca tem); as outras chaves do grupo `dev` (dublagem…)
contam pela configuração, por cautela: na dúvida, o final é renderizado de novo. A dublagem sai das mesmas frases
traduzidas (DUBLAGEM.md): sem frase, também não houve dublagem."""
flags = dict(layout.dev_flags(cfg, True))
if not translation:
flags["translation"] = flags["dub"] = False
return sorted(k for k, on in flags.items() if on)
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) e a dublagem
(doc/clipador/DUBLAGEM.md): só com `dev.translation` ou `dev.dub` 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)
flags = layout.dev_flags(cfg, dev)
if not (flags["translation"] or flags["dub"]):
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"]
analysis = judge.get("analysis")
context = judge.get("context") if isinstance(judge.get("context"), dict) else {}
if context.get("decision") in ("approve", "adjust", "warn") and (context.get("contextLine") or context.get("window")):
analysis = dict(analysis or {})
# Juiz de contexto (EQUIPE-IA.md): a frase de contexto vira o texto do começo do corte (no lugar do gancho)…
if context.get("contextLine"):
analysis["hook"] = context["contextLine"]
# …e, se ele ajustou o trecho, o início/fim do analista não desfaz o ajuste (ex.: recuou para pegar o começo).
if context.get("window"):
analysis.pop("action_start_s", None)
analysis.pop("reaction_end_s", None)
return editor.auto_project(clip, 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),
dubber=dub.for_engine(engine))
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.drop_final(clip_id) # editou: o final antigo deixa de valer; volta a ser revisão (aprovar de novo)
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")}