- editor_api: importa dub e speakers juntos. - voice_chunks (falantes) vira a migração v15, depois da v14 do vídeo final (antes era criada fora das migrações). - dub.voice_for: qualquer voz que não é o streamer (other1, other2…) usa a segunda voz da dublagem. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
826 lines
44 KiB
Python
826 lines
44 KiB
Python
"""API do Clipador (127.0.0.1:4520, faixa 4500–4599 do CenaForge). Toda rota, exceto GET /health, exige
|
||
`X-Service-Key` = CLIPPER_SERVICE_KEY (clipper/.env). Quem chama é o painel (panel/src/lib/clipper.ts)."""
|
||
|
||
from __future__ import annotations
|
||
|
||
import hmac
|
||
import logging
|
||
from contextlib import asynccontextmanager
|
||
from typing import Literal
|
||
|
||
from fastapi import FastAPI, Query, Request
|
||
from fastapi.responses import JSONResponse
|
||
from pydantic import BaseModel, Field
|
||
|
||
from .config import ConfigError, Settings
|
||
import json
|
||
from pathlib import Path
|
||
|
||
from . import capture, layout, media
|
||
from .config import REPO_ROOT
|
||
from .db import Database, loads, now
|
||
from .judge import LANGUAGE_NAMES, JudgeError
|
||
from .scoring import timeline as timeline_series
|
||
from .scoring import Word
|
||
from .sources import SourceError, parse_source
|
||
from .subtitles import build_ass
|
||
from .worker import Engine
|
||
from . import clip_delete, editor_api
|
||
|
||
VERSION = "1.0.0"
|
||
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s")
|
||
|
||
|
||
class UserError(Exception):
|
||
def __init__(self, message: str, status: int = 400):
|
||
super().__init__(message)
|
||
self.message, self.status = message, status
|
||
|
||
|
||
# Idiomas aceitos em `language` (fonte e sessão). '' = padrão do serviço (CLIPPER_LANGUAGE). O painel oferece os mesmos.
|
||
LANGUAGES = tuple(LANGUAGE_NAMES)
|
||
|
||
|
||
def check_language(value: str | None) -> str | None:
|
||
"""None = não mexer; '' = voltar ao padrão; código válido = usar. Outra coisa é erro legível."""
|
||
if value is None:
|
||
return None
|
||
code = value.strip()
|
||
if code and code not in LANGUAGES:
|
||
raise UserError(f"Idioma inválido: use {', '.join(LANGUAGES)} (ou vazio para o padrão).")
|
||
return code
|
||
|
||
|
||
class ChannelIn(BaseModel):
|
||
url: str = Field(min_length=3, max_length=300)
|
||
displayName: str | None = Field(default=None, max_length=60)
|
||
monitor: bool = True
|
||
authorized: bool = False
|
||
language: str | None = Field(default=None, max_length=12)
|
||
|
||
|
||
class ChannelPatch(BaseModel):
|
||
displayName: str | None = Field(default=None, max_length=60)
|
||
monitor: bool | None = None
|
||
authorized: bool | None = None
|
||
language: str | None = Field(default=None, max_length=12)
|
||
|
||
|
||
class SessionIn(BaseModel):
|
||
url: str = Field(min_length=3, max_length=300)
|
||
language: str | None = Field(default=None, max_length=12)
|
||
|
||
|
||
class StopIn(BaseModel):
|
||
"""Parar à mão: `pauseMonitor` (padrão) deixa a fonte com o monitor pausado até você religar."""
|
||
pauseMonitor: bool = True
|
||
|
||
|
||
class ManualClipIn(BaseModel):
|
||
"""Corte manual: os últimos `lastS` segundos gravados, ou o trecho [startS, endS]."""
|
||
lastS: float | None = Field(default=None, ge=5, le=180)
|
||
startS: float | None = Field(default=None, ge=0)
|
||
endS: float | None = Field(default=None, ge=0)
|
||
|
||
|
||
class JudgeIn(BaseModel):
|
||
provider: Literal["codex", "claude", "gemini", "off"]
|
||
model: str = Field(default="", max_length=80, pattern=r"^[A-Za-z0-9._:-]*$")
|
||
minScore: float = Field(default=6, ge=0, le=10)
|
||
# Modelo do ANALISTA (1º juiz, vê os frames); vazio = o mesmo do editor. None = não mexer.
|
||
analystModel: str | None = Field(default=None, max_length=80, pattern=r"^[A-Za-z0-9._:-]*$")
|
||
# Varredura da IA (procura momentos sem pico de chat), visão (frames da tela) e detecção da webcam.
|
||
scanEnabled: bool | None = None
|
||
scanIntervalS: int | None = Field(default=None, ge=60, le=900)
|
||
vision: bool | None = None
|
||
camDetect: bool | None = None
|
||
# Rastreio do rosto do streamer (face.py): reforça/cria cortes e vai em texto para o analista.
|
||
faceTrack: bool | None = None
|
||
|
||
|
||
class GameIn(BaseModel):
|
||
name: str = Field(min_length=1, max_length=120)
|
||
|
||
|
||
class MissionIn(BaseModel):
|
||
name: str = Field(min_length=1, max_length=160)
|
||
chapter: str = Field(default="", max_length=120)
|
||
summary: str = Field(default="", max_length=500)
|
||
completion_triggers: list[str] = Field(default_factory=list, max_length=8)
|
||
|
||
|
||
class GameProfileIn(BaseModel):
|
||
"""Perfil do jogo editado à mão no painel (mesmos campos que a IA devolve), em um dos dois idiomas."""
|
||
name: str = Field(default="", max_length=120)
|
||
aliases: list[str] = Field(default_factory=list, max_length=10) # outros nomes (categoria, abreviação)
|
||
summary: str = Field(default="", max_length=1500)
|
||
genre: str = Field(default="", max_length=120)
|
||
mechanics: list[str] = Field(default_factory=list, max_length=30)
|
||
clip_worthy: list[str] = Field(default_factory=list, max_length=30)
|
||
avoid: list[str] = Field(default_factory=list, max_length=30)
|
||
jargon: list[str] = Field(default_factory=list, max_length=40)
|
||
news: list[str] = Field(default_factory=list, max_length=30)
|
||
hashtags: list[str] = Field(default_factory=list, max_length=20) # do jogo, a principal primeiro (app/hashtags.py)
|
||
sources: list[str] = Field(default_factory=list, max_length=20)
|
||
missions: list[MissionIn] = Field(default_factory=list, max_length=120)
|
||
end_triggers: list[str] = Field(default_factory=list, max_length=12) # sinais gerais de fim de missão
|
||
|
||
|
||
class GameIn(BaseModel):
|
||
"""Jogo cadastrado pelo painel; `notes` = pista para a pesquisa (vira o 1º pedido guardado)."""
|
||
name: str = Field(min_length=2, max_length=120)
|
||
notes: str = Field(default="", max_length=1500)
|
||
|
||
|
||
class ChatTurnIn(BaseModel):
|
||
role: Literal["user", "ai"]
|
||
text: str = Field(max_length=1500)
|
||
|
||
|
||
class GameRefineIn(BaseModel):
|
||
instruction: str = Field(min_length=3, max_length=1500)
|
||
search: bool = True # deixa a IA confirmar na web (mais lento); sem busca é quase instantâneo
|
||
section: Literal["", "summary", "clip_worthy", "avoid", "mechanics", "news", "jargon", "hashtags", "sources",
|
||
"missions", "end_triggers", "aliases"] = ""
|
||
history: list[ChatTurnIn] = Field(default_factory=list, max_length=20) # conversa do chat da seção
|
||
|
||
|
||
class PreviewIn(BaseModel):
|
||
t: float | None = Field(default=None, ge=0)
|
||
settings: dict = Field(default_factory=dict)
|
||
|
||
|
||
class ClipPatch(BaseModel):
|
||
status: Literal["approved", "rejected", "ready", "published"] | None = None
|
||
title: str | None = Field(default=None, max_length=100)
|
||
caption: str | None = Field(default=None, max_length=2200)
|
||
startS: float | None = Field(default=None, ge=0)
|
||
endS: float | None = Field(default=None, ge=0)
|
||
|
||
|
||
ClipStatusName = Literal["candidate", "discarded", "pending", "rendering", "ready", "approved", "rejected", "published", "error"]
|
||
|
||
|
||
class ClipsDeleteIn(BaseModel):
|
||
"""Apagar em lote: `ids` (os cortes escolhidos) OU `statuses` (+ `sessionId` opcional) = todos de uma aba.
|
||
`confirmPublished` libera apagar corte publicado (sem ele, o publicado é recusado com o motivo)."""
|
||
ids: list[int] | None = Field(default=None, min_length=1, max_length=clip_delete.MAX_BATCH)
|
||
statuses: list[ClipStatusName] | None = Field(default=None, min_length=1, max_length=9)
|
||
sessionId: int | None = Field(default=None, ge=1)
|
||
confirmPublished: bool = False
|
||
|
||
|
||
APPROVED = ("approved", "published") # estados em que o corte tem (ou espera) vídeo final
|
||
|
||
|
||
def final_view(row: dict) -> dict | None:
|
||
"""Vídeo final do corte (doc/clipador/REVISAO.md); None = sem final (não aprovado ou a aprovação foi desfeita)."""
|
||
if not row.get("final_status"):
|
||
return None
|
||
return {"status": row["final_status"], "file": row.get("final_file"), "thumb": row.get("final_thumb"),
|
||
"cover": row.get("final_cover"), "error": row.get("final_error"), "at": row.get("final_at"),
|
||
# O vídeo de revisão não tinha nenhuma camada de desenvolvimento: ele mesmo virou o final (sem render novo).
|
||
"reused": bool(row.get("final_file")) and row.get("final_file") == row.get("file")}
|
||
|
||
|
||
def clip_view(row: dict) -> dict:
|
||
return {
|
||
"id": row["id"], "sessionId": row["session_id"], "peakS": row["peak_s"], "startS": row["start_s"],
|
||
"endS": row["end_s"], "durationS": round(row["end_s"] - row["start_s"], 2), "score": row["score"],
|
||
"source": row["source"], "reasons": loads(row["reasons_json"], {}), "judge": loads(row["judge_json"], None),
|
||
"title": row["title"], "caption": row["caption"], "transcript": row["transcript"], "status": row["status"],
|
||
"file": row["file"], "thumb": row["thumb"], "error": row["error"],
|
||
# Formato em que o arquivo foi renderizado (vertical 1080×1920 · horizontal 1920×1080); antes do 1º render,
|
||
# e nos cortes de antes da migração v8, vale o padrão `vertical`.
|
||
"aspect": row.get("aspect") or "vertical",
|
||
"createdAt": row["created_at"], "updatedAt": row["updated_at"],
|
||
"channelId": row.get("channel_id"), "platform": row.get("platform"), "sessionUrl": row.get("url"),
|
||
# Idioma da sessão (resolvido no SELECT: o da sessão ou o padrão do serviço). Ausente só em consultas antigas.
|
||
"language": row.get("language"),
|
||
# Fonte em inglês: a fala do corte em frases com a tradução ({language, startS, endS, model, lines: [{s, e,
|
||
# text, pt}]}); None = sessão em português ou ainda não traduzido (doc/clipador/IDIOMAS.md).
|
||
"translation": loads(row.get("translation_json"), None),
|
||
# Editor de cortes: existe projeto de edição? (o export renderiza por ele; capa gerada no export)
|
||
"edit": ({"updatedAt": row["edit_updated_at"], "exportedAt": row.get("edit_exported_at"), "cover": row.get("edit_cover"),
|
||
"origin": row.get("edit_origin")}
|
||
if row.get("edit_updated_at") else None),
|
||
# Revisão × final (doc/clipador/REVISAO.md). `file` é sempre o vídeo de REVISÃO (o da fila, para aprovar);
|
||
# `review.devLayers` = camadas de teste que entraram nele ([] = nenhuma; None = desconhecido).
|
||
"review": {"devLayers": loads(row.get("review_dev_json"), None)},
|
||
"final": final_view(row),
|
||
# O ÚNICO arquivo que pode ser publicado: o final pronto de um corte aprovado. None = ainda não (esperar).
|
||
"publishFile": row.get("final_file") if row["status"] in APPROVED and row.get("final_status") == "ready" else None,
|
||
}
|
||
|
||
|
||
def session_view(row: dict, engine: Engine) -> dict:
|
||
counts = {r["status"]: r["n"] for r in engine.db.all(
|
||
"SELECT status, COUNT(*) AS n FROM clips WHERE session_id = ? GROUP BY status", row["id"])}
|
||
seg = engine.db.get(
|
||
"SELECT COUNT(*) AS total, SUM(analyzed) AS analyzed, SUM(CASE WHEN transcript_error IS NOT NULL THEN 1 ELSE 0 END) AS errors"
|
||
" FROM segments WHERE session_id = ?", row["id"])
|
||
chat = engine.db.get("SELECT COUNT(*) AS n FROM chat WHERE session_id = ?", row["id"])["n"]
|
||
live_chat = engine.chat_status(row["id"])
|
||
return {
|
||
"id": row["id"], "channelId": row["channel_id"], "platform": row["platform"], "kind": row["kind"],
|
||
"url": row["url"], "title": row["title"], "status": row["status"],
|
||
"chatStatus": live_chat["status"] if live_chat else row["chat_status"], "chatMessages": chat,
|
||
"durationS": row["duration_s"], "startedAt": row["started_at"], "endedAt": row["ended_at"], "error": row["error"],
|
||
"segments": {"total": seg["total"] or 0, "analyzed": seg["analyzed"] or 0, "transcriptErrors": seg["errors"] or 0},
|
||
"clips": counts,
|
||
# Contexto do jogo: categoria da plataforma, o que a IA viu na tela, trocas e se você corrigiu à mão.
|
||
"game": row.get("game", ""), "gameSource": row.get("game_source", ""), "screenGame": row.get("screen_game", ""),
|
||
"gameHistory": loads(row.get("games_json"), []), "gameProfileReady": bool(engine.intel.profile(row.get("game", ""))),
|
||
"scannedUntilS": row.get("scanned_until", 0), "memory": loads(row.get("memory_json"), []),
|
||
"camDetect": loads(row.get("cam_json"), None), "roomId": row.get("room_id"),
|
||
"hasOwnSettings": bool(loads(row.get("settings_json"), {})),
|
||
# O que a captura gravou de fato (1º bloco de cada execução): qualidade pedida, largura, altura, qps, codec,
|
||
# kbps, GB/h e `mixed` (retomada em outra resolução). None = sessão antiga ou ainda sem bloco.
|
||
"capture": loads(row.get("capture_json"), None),
|
||
# Idioma falado na live (resolvido: o da sessão, senão o padrão do serviço).
|
||
"language": row.get("language") or engine.settings.language,
|
||
}
|
||
|
||
|
||
def channel_view(row: dict, default_language: str = "") -> dict:
|
||
return {
|
||
"id": row["id"], "platform": row["platform"], "channel": row["channel"], "url": row["url"],
|
||
"displayName": row["display_name"], "monitor": bool(row["monitor"]), "authorized": bool(row["authorized"]),
|
||
"lastCheckAt": row["last_check_at"], "lastStatus": row["last_status"], "createdAt": row["created_at"],
|
||
# Monitor pausado porque você parou uma sessão à mão (não grava de novo até religar).
|
||
"monitorPausedAt": row.get("monitor_paused_at"), "monitorPausedBySession": row.get("monitor_paused_session"),
|
||
"language": row.get("language") or default_language,
|
||
}
|
||
|
||
|
||
def create_app(settings: Settings | None = None, engine: Engine | None = None, start_engine: bool = True) -> FastAPI:
|
||
settings = settings or Settings.load()
|
||
if not settings.service_key:
|
||
raise ConfigError("CLIPPER_SERVICE_KEY vazio: rode o setup.bat (ou preencha clipper/.env).")
|
||
db = engine.db if engine else Database(settings.data_dir / "clipper.db")
|
||
engine = engine or Engine(settings, db)
|
||
|
||
@asynccontextmanager
|
||
async def lifespan(_app: FastAPI):
|
||
if start_engine:
|
||
engine.start()
|
||
yield
|
||
engine.shutdown()
|
||
|
||
app = FastAPI(title="CenaForge Clipador", version=VERSION, docs_url=None, redoc_url=None, openapi_url=None, lifespan=lifespan)
|
||
app.state.engine = engine
|
||
|
||
@app.middleware("http")
|
||
async def auth(request: Request, call_next):
|
||
if request.url.path != "/health":
|
||
given = request.headers.get("X-Service-Key", "")
|
||
if not hmac.compare_digest(given.encode(), settings.service_key.encode()):
|
||
return JSONResponse({"error": "Chave do serviço ausente ou inválida."}, status_code=401)
|
||
return await call_next(request)
|
||
|
||
@app.exception_handler(UserError)
|
||
async def user_error(_request: Request, exc: UserError):
|
||
return JSONResponse({"error": exc.message}, status_code=exc.status)
|
||
|
||
@app.exception_handler(SourceError)
|
||
async def source_error(_request: Request, exc: SourceError):
|
||
return JSONResponse({"error": str(exc)}, status_code=400)
|
||
|
||
@app.get("/health")
|
||
async def health():
|
||
return {"status": "ok", "version": VERSION}
|
||
|
||
@app.get("/v1/status")
|
||
def status():
|
||
return {
|
||
"version": VERSION,
|
||
"tools": {"streamlink": settings.streamlink, "ffmpeg": settings.ffmpeg},
|
||
"voice": {"configured": engine.voice.configured, "online": engine.voice.healthy()},
|
||
"judge": engine.judge_config(),
|
||
"recording": db.get("SELECT COUNT(*) AS n FROM sessions WHERE status IN ('starting', 'recording')")["n"],
|
||
# A qualidade de gravação agora é por canal/sessão (`capture.quality`); aqui vai o padrão do serviço.
|
||
"settings": {"quality": layout.DEFAULTS["capture"]["quality"], "segmentS": settings.segment_s, "pollS": settings.poll_s,
|
||
"keepHours": settings.keep_hours, "language": settings.language},
|
||
}
|
||
|
||
# ---------- juiz (IA pela CLI: Codex/GPT ou Claude)
|
||
@app.get("/v1/judge")
|
||
def get_judge():
|
||
return engine.judge_config() | {"models": engine.judge.models()}
|
||
|
||
@app.put("/v1/judge")
|
||
def put_judge(body: JudgeIn):
|
||
try:
|
||
engine.intel.set_options({"scanEnabled": body.scanEnabled, "scanIntervalS": body.scanIntervalS,
|
||
"vision": body.vision, "camDetect": body.camDetect, "faceTrack": body.faceTrack})
|
||
return engine.set_judge_config(body.provider, body.model, body.minScore, body.analystModel) | {
|
||
"models": engine.judge.models()}
|
||
except JudgeError as exc:
|
||
raise UserError(str(exc)) from exc
|
||
|
||
# ---------- configuração do corte (layout, câmera, legenda, crédito, duração)
|
||
def _settings_payload(own: dict, channel_layer: dict | None, session_layer: dict | None) -> dict:
|
||
return {"own": own, "effective": layout.merge(channel_layer, session_layer), "defaults": layout.DEFAULTS,
|
||
"modes": list(layout.MODES), "fonts": list(layout.FONTS), "aspects": list(layout.ASPECTS),
|
||
# Fontes empacotadas: {família: arquivo relativo à raiz do repositório} (o painel carrega a mesma).
|
||
# Qualidades de gravação (grupo `capture`): rótulo, teto e disco por hora medido/estimado.
|
||
"captureQualities": capture.OPTIONS,
|
||
"fontFiles": layout.font_files(), "hookStyles": list(layout.HOOK_STYLES), "hookAnims": list(layout.HOOK_ANIMS),
|
||
# Tamanho do vídeo e quadro lógico dos textos (ASS) de cada formato, para o painel desenhar a prévia.
|
||
"frames": {a: {"width": layout.FRAME_SIZES[a][0], "height": layout.FRAME_SIZES[a][1],
|
||
"canvasWidth": layout.CANVAS_SIZES[a][0], "canvasHeight": layout.CANVAS_SIZES[a][1]}
|
||
for a in layout.ASPECTS}}
|
||
|
||
@app.get("/v1/channels/{channel_id}/settings")
|
||
def get_channel_settings(channel_id: str):
|
||
row = db.get("SELECT settings_json FROM channels WHERE id = ?", channel_id)
|
||
if not row:
|
||
raise UserError("Canal não encontrado.", 404)
|
||
own = loads(row["settings_json"], {})
|
||
return _settings_payload(own, own, None)
|
||
|
||
@app.put("/v1/channels/{channel_id}/settings")
|
||
def put_channel_settings(channel_id: str, body: dict):
|
||
if not db.get("SELECT 1 FROM channels WHERE id = ?", channel_id):
|
||
raise UserError("Canal não encontrado.", 404)
|
||
try:
|
||
own = layout.validate(body)
|
||
except (layout.LayoutError, TypeError, ValueError) as exc:
|
||
raise UserError(str(exc)) from exc
|
||
db.run("UPDATE channels SET settings_json = ? WHERE id = ?", json.dumps(own), channel_id)
|
||
return _settings_payload(own, own, None)
|
||
|
||
def _session(session_id: int) -> dict:
|
||
row = db.get("SELECT * FROM sessions WHERE id = ?", session_id)
|
||
if not row:
|
||
raise UserError("Sessão não encontrada.", 404)
|
||
return row
|
||
|
||
def _channel_layer(row: dict) -> dict | None:
|
||
if not row.get("channel_id"):
|
||
return None
|
||
ch = db.get("SELECT settings_json FROM channels WHERE id = ?", row["channel_id"])
|
||
return loads(ch["settings_json"], {}) if ch else None
|
||
|
||
@app.get("/v1/sessions/{session_id}/settings")
|
||
def get_session_settings(session_id: int):
|
||
row = _session(session_id)
|
||
own = loads(row["settings_json"], {})
|
||
return _settings_payload(own, _channel_layer(row), own) | {"channel": _channel_layer(row)}
|
||
|
||
@app.put("/v1/sessions/{session_id}/settings")
|
||
def put_session_settings(session_id: int, body: dict):
|
||
"""Configuração própria da sessão (sobrescreve a do canal campo a campo). Vale para os próximos renders."""
|
||
row = _session(session_id)
|
||
try:
|
||
own = layout.validate(body)
|
||
except (layout.LayoutError, TypeError, ValueError) as exc:
|
||
raise UserError(str(exc)) from exc
|
||
db.run("UPDATE sessions SET settings_json = ? WHERE id = ?", json.dumps(own) if own else None, session_id)
|
||
return _settings_payload(own, _channel_layer(row), own) | {"channel": _channel_layer(row)}
|
||
|
||
def _frame(row: dict, t: float | None, name: str, width: int = 1280) -> tuple[float, Path]:
|
||
segments = [(REPO_ROOT / s["file"], s["start_s"], s["end_s"])
|
||
for s in db.all("SELECT * FROM segments WHERE session_id = ? AND deleted = 0 ORDER BY idx", row["id"])]
|
||
if not segments:
|
||
raise UserError("Ainda não há vídeo gravado nesta sessão.")
|
||
at = segments[-1][2] - 3 if t is None else t
|
||
out = settings.clips_dir / str(row["id"]) / name
|
||
try:
|
||
media.grab_frame(settings.ffmpeg or "ffmpeg", segments, at, out, width)
|
||
except media.MediaError as exc:
|
||
raise UserError(str(exc)) from exc
|
||
return at, out
|
||
|
||
@app.get("/v1/sessions/{session_id}/frame")
|
||
def get_frame(session_id: int, t: float | None = None):
|
||
"""Quadro do vídeo original (1280 px) para o editor desenhar a câmera. Servido por /api/files."""
|
||
at, out = _frame(_session(session_id), t, "frame.jpg")
|
||
return {"t": round(at, 2), "file": out.relative_to(REPO_ROOT).as_posix(), "version": now()}
|
||
|
||
@app.post("/v1/sessions/{session_id}/preview")
|
||
def preview(session_id: int, body: PreviewIn):
|
||
"""Prévia (1080×1920 ou 1920×1080, pelo `format.aspect` efetivo) de como o corte vai ficar com a configuração enviada (sem salvar)."""
|
||
row = _session(session_id)
|
||
try:
|
||
layer = layout.validate(body.settings)
|
||
except (layout.LayoutError, TypeError, ValueError) as exc:
|
||
raise UserError(str(exc)) from exc
|
||
cfg = layout.merge(_channel_layer(row), loads(row["settings_json"], {}), layer)
|
||
at, frame = _frame(row, body.t, "preview-src.jpg", width=0)
|
||
# Legenda de exemplo: 1º bloco começa em 0 s, então o quadro único da prévia já mostra a legenda.
|
||
sample = [Word(i * 0.35, 0.3 + i * 0.35, w) for i, w in enumerate("ASSIM VAI FICAR A LEGENDA".split())]
|
||
# E a fala de outra pessoa (colega no Discord), na linha de baixo, com a cor dela (FALANTES.md).
|
||
sample += [Word(0.05 + i * 0.35, 0.35 + i * 0.35, w, "other1") for i, w in enumerate("E A DO COLEGA".split())]
|
||
ass = build_ass(sample, 0.0, 3.0, engine.channel_label(row), cfg)
|
||
out = settings.clips_dir / str(row["id"]) / "preview.jpg"
|
||
try:
|
||
media.preview_still(settings.ffmpeg or "ffmpeg", frame, cfg, ass, out)
|
||
except media.MediaError as exc:
|
||
raise UserError(str(exc)) from exc
|
||
return {"t": round(at, 2), "file": out.relative_to(REPO_ROOT).as_posix(), "mode": layout.resolved_mode(cfg),
|
||
"version": now()}
|
||
|
||
@app.post("/v1/sessions/{session_id}/detect-cam")
|
||
def detect_cam(session_id: int, ai: bool = False):
|
||
"""Acha a webcam: primeiro local (YuNet em 12 quadros, sem IA); a IA olha 3 quadros se o local não achar
|
||
rosto ou com `?ai=true`. Aplica como padrão do canal (ou da sessão) se ainda não houver."""
|
||
_session(session_id)
|
||
try:
|
||
return engine.intel.detect_cam(session_id, apply=True, use_ai=ai)
|
||
except JudgeError as exc:
|
||
raise UserError(str(exc)) from exc
|
||
|
||
# ---------- rastreio de reação (rosto do streamer)
|
||
@app.get("/v1/sessions/{session_id}/face")
|
||
def get_face(session_id: int, from_: float = Query(default=0.0, alias="from", ge=0),
|
||
to: float | None = Query(default=None, ge=0)):
|
||
"""Série por segundo do rosto (cx/cy/size no quadro inteiro, expressões, `signal` = z da reação) e picos."""
|
||
if to is not None and to < from_:
|
||
raise UserError("`to` precisa ser maior que `from`.")
|
||
return engine.face.view(_session(session_id), from_, to)
|
||
|
||
@app.get("/v1/sessions/{session_id}/speakers")
|
||
def get_speakers(session_id: int):
|
||
"""Vozes da sessão (doc/clipador/FALANTES.md): quantas, qual é o streamer e por quê (boca/volume), fala por
|
||
rótulo. `active: false` = sem prova suficiente: tudo fica como do streamer."""
|
||
_session(session_id)
|
||
return engine.speakers.view(session_id)
|
||
|
||
@app.post("/v1/sessions/{session_id}/face/reset")
|
||
def reset_face(session_id: int):
|
||
"""Apaga a série do rosto da sessão; o laço do rastreio refaz (ex.: depois de corrigir a câmera). Com um bloco
|
||
em andamento não espera: responde 202 com `scheduled: true` e o laço apaga antes do próximo bloco."""
|
||
_session(session_id)
|
||
result = engine.face.reset(session_id)
|
||
return JSONResponse({"ok": True, **result}, status_code=202 if result["scheduled"] else 200)
|
||
|
||
# ---------- jogo
|
||
@app.put("/v1/sessions/{session_id}/game")
|
||
def put_game(session_id: int, body: GameIn):
|
||
"""Corrige o jogo à mão (categoria errada). Fica travado: a checagem automática não troca mais."""
|
||
_session(session_id)
|
||
engine.intel.set_game(session_id, body.name.strip(), "user")
|
||
return session_view(_session(session_id), engine)
|
||
|
||
def game_view(g: dict) -> dict:
|
||
# `profile` = português (o painel mostra); `profileAi` = inglês (vai nos prompts; null = jogo antigo, a IA
|
||
# usa `profile`). Contrato em doc/clipador/JOGOS.md.
|
||
return {"id": g["id"], "name": g["name"], "status": g["status"], "error": g["error"],
|
||
"model": g["model"], "researchedAt": g["researched_at"], "editedAt": g.get("edited_at"),
|
||
"notes": loads(g.get("notes_json"), []), "profile": loads(g["profile_json"], None),
|
||
"profileAi": loads(g.get("profile_ai_json"), None), "aiLanguage": "en-US",
|
||
"translatedAt": g.get("translated_at"), "aliases": loads(g.get("aliases_json"), [])}
|
||
|
||
@app.get("/v1/games")
|
||
def list_games():
|
||
return {"games": [game_view(g) for g in db.all("SELECT * FROM games ORDER BY name")]}
|
||
|
||
@app.post("/v1/games", status_code=201)
|
||
def add_game(body: GameIn):
|
||
"""Cadastra um jogo e pesquisa em segundo plano (o jogo aparece `pending` até a pesquisa terminar)."""
|
||
try:
|
||
gid = engine.intel.add_game(body.name, body.notes)
|
||
except LookupError as exc:
|
||
raise UserError(str(exc), 409) from exc
|
||
except ValueError as exc:
|
||
raise UserError(str(exc)) from exc
|
||
return {**list_games(), "id": gid}
|
||
|
||
@app.delete("/v1/games/{game_id}")
|
||
def delete_game(game_id: str):
|
||
try:
|
||
engine.intel.delete_game(game_id)
|
||
except JudgeError as exc:
|
||
raise UserError(str(exc), 404) from exc
|
||
return list_games()
|
||
|
||
@app.post("/v1/games/{game_id}/research")
|
||
def research_game(game_id: str):
|
||
"""Pesquisa (de novo) o jogo na web pela IA, em inglês, e traduz para português. Leva de 15 s a alguns minutos.
|
||
Os pedidos guardados entram junto."""
|
||
try:
|
||
engine.intel.research(game_id)
|
||
except JudgeError as exc:
|
||
raise UserError(str(exc)) from exc
|
||
return list_games()
|
||
|
||
@app.post("/v1/games/{game_id}/translate")
|
||
def translate_game(game_id: str):
|
||
"""Gera a versão da IA (inglês) a partir da portuguesa (jogos de antes dos perfis bilíngues)."""
|
||
try:
|
||
engine.intel.translate(game_id)
|
||
except JudgeError as exc:
|
||
raise UserError(str(exc)) from exc
|
||
return list_games()
|
||
|
||
@app.put("/v1/games/{game_id}")
|
||
def put_game_profile(game_id: str, body: GameProfileIn, lang: Literal["pt", "en"] = "pt"):
|
||
"""Grava o perfil editado à mão no idioma `lang` e traduz para o outro. A IA passa a usar na hora."""
|
||
try:
|
||
engine.intel.save_profile(game_id, body.model_dump(), lang)
|
||
except JudgeError as exc:
|
||
raise UserError(str(exc), 404) from exc
|
||
return list_games()
|
||
|
||
@app.post("/v1/games/{game_id}/refine")
|
||
def refine_game(game_id: str, body: GameRefineIn):
|
||
"""Pede à IA para acrescentar/corrigir algo no perfil ("acrescente que ..."). O pedido fica guardado."""
|
||
try:
|
||
_, reply = engine.intel.refine(game_id, body.instruction.strip(), body.search, body.section,
|
||
[t.model_dump() for t in body.history])
|
||
except JudgeError as exc:
|
||
raise UserError(str(exc)) from exc
|
||
return {**list_games(), "reply": reply}
|
||
|
||
@app.delete("/v1/games/{game_id}/notes/{index}")
|
||
def delete_game_note(game_id: str, index: int):
|
||
"""Esquece um pedido guardado (não volta mais nas pesquisas; o perfil atual fica como está)."""
|
||
try:
|
||
engine.intel.delete_note(game_id, index)
|
||
except JudgeError as exc:
|
||
raise UserError(str(exc), 404) from exc
|
||
return list_games()
|
||
|
||
# ---------- emotes que o canal usa (e o peso que aprenderam)
|
||
@app.get("/v1/emotes")
|
||
def list_emotes(channel: str, limit: int = 60):
|
||
rows = db.all("SELECT * FROM emotes WHERE channel_key = ? ORDER BY uses DESC LIMIT ?", channel, max(1, min(limit, 300)))
|
||
return {"emotes": [{"name": r["name"], "source": r["source"], "uses": r["uses"], "weight": round(r["weight"], 2),
|
||
"lastSeen": r["last_seen"]} for r in rows]}
|
||
|
||
# ---------- canais
|
||
@app.get("/v1/channels")
|
||
def list_channels():
|
||
return {"channels": [channel_view(r, settings.language) for r in db.all("SELECT * FROM channels ORDER BY display_name")]}
|
||
|
||
@app.post("/v1/channels", status_code=201)
|
||
def create_channel(body: ChannelIn):
|
||
source = parse_source(body.url)
|
||
if source.kind != "live" or not source.channel:
|
||
raise UserError("Para monitorar, use o link do canal (ex.: twitch.tv/alanzoka), não de um vídeo.")
|
||
if db.get("SELECT 1 FROM channels WHERE id = ?", source.channel_id):
|
||
raise UserError("Esse canal já está na lista.", 409)
|
||
language = check_language(body.language) or ""
|
||
db.run("INSERT INTO channels (id, platform, channel, url, display_name, monitor, authorized, created_at, language)"
|
||
" VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
|
||
source.channel_id, source.platform, source.channel, source.url,
|
||
(body.displayName or source.channel.lstrip("@")).strip(), int(body.monitor), int(body.authorized), now(), language)
|
||
return channel_view(db.get("SELECT * FROM channels WHERE id = ?", source.channel_id), settings.language)
|
||
|
||
@app.patch("/v1/channels/{channel_id}")
|
||
def update_channel(channel_id: str, body: ChannelPatch):
|
||
row = db.get("SELECT * FROM channels WHERE id = ?", channel_id)
|
||
if not row:
|
||
raise UserError("Canal não encontrado.", 404)
|
||
language = check_language(body.language)
|
||
db.run("UPDATE channels SET display_name = ?, monitor = ?, authorized = ?, language = ? WHERE id = ?",
|
||
(body.displayName or row["display_name"]).strip(),
|
||
int(body.monitor if body.monitor is not None else row["monitor"]),
|
||
int(body.authorized if body.authorized is not None else row["authorized"]),
|
||
language if language is not None else row.get("language") or "", channel_id)
|
||
if body.monitor is True:
|
||
engine.clear_monitor_pause(channel_id) # "Religar" no painel
|
||
return channel_view(db.get("SELECT * FROM channels WHERE id = ?", channel_id), settings.language)
|
||
|
||
@app.delete("/v1/channels/{channel_id}", status_code=204)
|
||
def delete_channel(channel_id: str):
|
||
for s in db.all("SELECT id FROM sessions WHERE channel_id = ? AND status IN ('starting', 'recording')", channel_id):
|
||
engine.stop_session(s["id"])
|
||
db.run("DELETE FROM channels WHERE id = ?", channel_id)
|
||
|
||
@app.post("/v1/channels/{channel_id}/check")
|
||
def check_channel(channel_id: str):
|
||
row = db.get("SELECT * FROM channels WHERE id = ?", channel_id)
|
||
if not row:
|
||
raise UserError("Canal não encontrado.", 404)
|
||
live, title = engine.check_live(row["url"])
|
||
db.run("UPDATE channels SET last_check_at = ?, last_status = ? WHERE id = ?", now(), "ao vivo" if live else "offline", channel_id)
|
||
return {"live": live, "title": title}
|
||
|
||
# ---------- sessões
|
||
@app.get("/v1/sessions")
|
||
def list_sessions(limit: int = 30):
|
||
rows = db.all("SELECT * FROM sessions ORDER BY id DESC LIMIT ?", max(1, min(limit, 200)))
|
||
return {"sessions": [session_view(r, engine) for r in rows]}
|
||
|
||
@app.post("/v1/sessions", status_code=201)
|
||
def create_session(body: SessionIn):
|
||
source = parse_source(body.url)
|
||
channel = db.get("SELECT id FROM channels WHERE id = ?", source.channel_id) if source.channel else None
|
||
language = check_language(body.language)
|
||
try:
|
||
session_id = engine.start_session(body.url, channel["id"] if channel else None, language=language)
|
||
except RuntimeError as exc:
|
||
raise UserError(str(exc)) from exc
|
||
return session_view(db.get("SELECT * FROM sessions WHERE id = ?", session_id), engine)
|
||
|
||
@app.get("/v1/sessions/{session_id}")
|
||
def get_session(session_id: int):
|
||
row = db.get("SELECT * FROM sessions WHERE id = ?", session_id)
|
||
if not row:
|
||
raise UserError("Sessão não encontrada.", 404)
|
||
return session_view(row, engine)
|
||
|
||
@app.get("/v1/sessions/{session_id}/timeline")
|
||
def get_timeline(session_id: int):
|
||
if not db.get("SELECT 1 FROM sessions WHERE id = ?", session_id):
|
||
raise UserError("Sessão não encontrada.", 404)
|
||
tl = engine.load_timeline(session_id)
|
||
return {"durationS": tl["duration"], **timeline_series(tl["duration"], tl["chat"], tl["loudness"], engine.params)}
|
||
|
||
@app.post("/v1/sessions/{session_id}/clips", status_code=201)
|
||
def manual_clip(session_id: int, body: ManualClipIn):
|
||
session = db.get("SELECT * FROM sessions WHERE id = ?", session_id)
|
||
if not session:
|
||
raise UserError("Sessão não encontrada.", 404)
|
||
duration = session["duration_s"]
|
||
if body.lastS is not None:
|
||
start, end = max(0.0, duration - body.lastS), duration
|
||
elif body.startS is not None and body.endS is not None:
|
||
start, end = body.startS, min(body.endS, duration)
|
||
else:
|
||
raise UserError("Informe lastS ou startS e endS.")
|
||
if end - start < 5:
|
||
raise UserError("Ainda não há gravação suficiente para esse corte.")
|
||
ts = now()
|
||
cur = db.run(
|
||
"INSERT INTO clips (session_id, peak_s, start_s, end_s, score, source, reasons_json, status, created_at, updated_at)"
|
||
" VALUES (?, ?, ?, ?, 0, 'manual', '{}', 'candidate', ?, ?)", session_id, end, start, end, ts, ts)
|
||
engine.wake_clips.set()
|
||
return clip_view(_clip(int(cur.lastrowid)))
|
||
|
||
@app.post("/v1/sessions/{session_id}/stop")
|
||
def stop_session(session_id: int, body: StopIn | None = None):
|
||
"""Para a gravação à mão. Sem corpo (ou `pauseMonitor: true`): a fonte fica com o monitor pausado até religar."""
|
||
engine.stop_session(session_id, pause_monitor=body.pauseMonitor if body else True)
|
||
return {"ok": True}
|
||
|
||
@app.post("/v1/sessions/{session_id}/resume")
|
||
def resume_session(session_id: int):
|
||
"""Volta a gravar uma live interrompida (ex.: o serviço reiniciou) ou parada, na mesma sessão."""
|
||
if not db.get("SELECT 1 FROM sessions WHERE id = ?", session_id):
|
||
raise UserError("Sessão não encontrada.", 404)
|
||
try:
|
||
engine.resume_session(session_id)
|
||
except RuntimeError as exc:
|
||
raise UserError(f"Não deu para retomar: {exc}.") from exc
|
||
return session_view(db.get("SELECT * FROM sessions WHERE id = ?", session_id), engine)
|
||
|
||
@app.post("/v1/sessions/{session_id}/finish")
|
||
def finish_session(session_id: int):
|
||
"""Encerra e processa o que foi gravado: varredura do restante, juízes e render dos cortes."""
|
||
if not db.get("SELECT 1 FROM sessions WHERE id = ?", session_id):
|
||
raise UserError("Sessão não encontrada.", 404)
|
||
engine.finish_session(session_id)
|
||
return session_view(db.get("SELECT * FROM sessions WHERE id = ?", session_id), engine)
|
||
|
||
@app.delete("/v1/sessions/{session_id}", status_code=204)
|
||
def delete_session(session_id: int):
|
||
engine.delete_session(session_id)
|
||
|
||
# ---------- cortes
|
||
@app.get("/v1/clips")
|
||
def list_clips(status: str | None = None, session: int | None = None, limit: int = 100,
|
||
channel: str | None = None, ids: str | None = None):
|
||
"""Filtros opcionais (todos separados por vírgula): `status`, `channel` (fontes, ex.: twitch-alanzoka) e `ids`.
|
||
O despachante de publicação do painel usa `channel` + `status=ready,approved` e `ids` para conferir a fila."""
|
||
sql = "SELECT c.*, s.channel_id, s.platform, s.url, COALESCE(NULLIF(s.language, ''), ?) AS language, e.updated_at AS edit_updated_at, e.exported_at AS edit_exported_at, e.cover AS edit_cover, e.origin AS edit_origin FROM clips c JOIN sessions s ON s.id = c.session_id LEFT JOIN edits e ON e.clip_id = c.id WHERE 1 = 1"
|
||
params: list = [settings.language]
|
||
if status:
|
||
sql += " AND c.status IN (" + ",".join("?" * len(status.split(","))) + ")"
|
||
params += status.split(",")
|
||
if session:
|
||
sql += " AND c.session_id = ?"
|
||
params.append(session)
|
||
if channel:
|
||
channels = [c for c in channel.split(",") if c][:200]
|
||
sql += " AND s.channel_id IN (" + ",".join("?" * len(channels)) + ")"
|
||
params += channels
|
||
if ids:
|
||
try:
|
||
id_list = [int(i) for i in ids.split(",") if i][:500]
|
||
except ValueError as exc:
|
||
raise UserError("`ids` precisa ser uma lista de números separados por vírgula.") from exc
|
||
sql += " AND c.id IN (" + ",".join("?" * len(id_list)) + ")"
|
||
params += id_list
|
||
sql += " ORDER BY c.id DESC LIMIT ?"
|
||
params.append(max(1, min(limit, 500)))
|
||
return {"clips": [clip_view(r) for r in db.all(sql, *params)]}
|
||
|
||
def _clip(clip_id: int) -> dict:
|
||
row = db.get("SELECT c.*, s.channel_id, s.platform, s.url, COALESCE(NULLIF(s.language, ''), ?) AS language, e.updated_at AS edit_updated_at, e.exported_at AS edit_exported_at, e.cover AS edit_cover, e.origin AS edit_origin FROM clips c JOIN sessions s ON s.id = c.session_id LEFT JOIN edits e ON e.clip_id = c.id WHERE c.id = ?", settings.language, clip_id)
|
||
if not row:
|
||
raise UserError("Corte não encontrado.", 404)
|
||
return row
|
||
|
||
@app.post("/v1/clips/delete")
|
||
def delete_clips(body: ClipsDeleteIn):
|
||
"""Apaga vários cortes: os `ids` escolhidos, ou todos nos `statuses` (de uma sessão, com `sessionId`), até
|
||
`clip_delete.MAX_BATCH` por chamada. Cada um segue as regras de `DELETE /v1/clips/{id}`; a resposta diz o
|
||
que saiu (`deleted`) e o que não saiu e por quê (`failed`). `remaining` = quantos passaram do limite."""
|
||
if (body.ids is None) == (body.statuses is None):
|
||
raise UserError("Mande `ids` ou `statuses` (um dos dois).")
|
||
if body.ids is not None and body.sessionId is not None:
|
||
raise UserError("`sessionId` só vale junto com `statuses`.")
|
||
remaining = 0
|
||
if body.ids is not None:
|
||
if any(i < 1 for i in body.ids):
|
||
raise UserError("Id de corte inválido.")
|
||
ids = list(dict.fromkeys(body.ids))
|
||
else:
|
||
ids, remaining = clip_delete.select_ids(db, body.sessionId, list(dict.fromkeys(body.statuses)))
|
||
result = clip_delete.delete_many(engine, ids, body.confirmPublished)
|
||
if result["deleted"]:
|
||
engine.wake_clips.set() # a sessão pode ter acabado de ficar sem pendências (finish_if_done)
|
||
return {"requested": len(ids), "remaining": remaining, **result}
|
||
|
||
@app.delete("/v1/clips/{clip_id}")
|
||
def delete_clip(clip_id: int, confirmPublished: bool = False):
|
||
"""Apaga o corte, o projeto de edição e os arquivos dele (só dentro das pastas do Clipador). Recusa `candidate`
|
||
e `rendering` (409, o motor está mexendo nele) e `published` sem `?confirmPublished=true`. O momento fica
|
||
marcado: a IA não recria o mesmo corte (clip_delete.py)."""
|
||
try:
|
||
result = clip_delete.delete_clip(engine, clip_id, confirmPublished)
|
||
except clip_delete.DeleteRefused as exc:
|
||
message = "Corte não encontrado." if exc.code == "not_found" else f"Não deu para apagar: {exc.message}."
|
||
return JSONResponse({"error": message, "code": exc.code}, status_code=exc.status)
|
||
engine.wake_clips.set()
|
||
return result
|
||
|
||
@app.get("/v1/clips/{clip_id}")
|
||
def get_clip(clip_id: int):
|
||
return clip_view(_clip(clip_id))
|
||
|
||
@app.patch("/v1/clips/{clip_id}")
|
||
def update_clip(clip_id: int, body: ClipPatch):
|
||
row = _clip(clip_id)
|
||
start = body.startS if body.startS is not None else row["start_s"]
|
||
end = body.endS if body.endS is not None else row["end_s"]
|
||
if not 5 <= end - start <= 180:
|
||
raise UserError("O corte precisa ter entre 5 e 180 segundos.")
|
||
retime = (start, end) != (row["start_s"], row["end_s"])
|
||
status = body.status or row["status"]
|
||
if body.status in ("approved", "published") and row["status"] not in ("ready", "approved", "published"):
|
||
raise UserError("Só dá para aprovar um corte já renderizado.")
|
||
if retime:
|
||
status = "pending" # novo trecho → renderiza de novo
|
||
db.run("UPDATE clips SET title = ?, caption = ?, start_s = ?, end_s = ?, status = ?, updated_at = ? WHERE id = ?",
|
||
body.title if body.title is not None else row["title"],
|
||
body.caption if body.caption is not None else row["caption"], start, end, status, now(), clip_id)
|
||
if retime:
|
||
editor_api.retime_edit(engine, clip_id, start, end) # corte com edição: estica/encolhe as pontas do projeto
|
||
engine.wake_clips.set()
|
||
# Aprovou → pede o vídeo final (sem camadas de teste); desaprovou/mudou o trecho → o final deixa de valer.
|
||
if status in APPROVED and row["status"] not in APPROVED:
|
||
engine.queue_final(clip_id)
|
||
elif row["status"] in APPROVED and status not in APPROVED:
|
||
engine.drop_final(clip_id)
|
||
if body.status in ("approved", "rejected") and body.status != row["status"]:
|
||
# Sua decisão é o sinal forte: emotes da reação deste corte ganham/perdem peso no canal (uma vez).
|
||
engine.intel.learn_from_clip(row, positive=body.status == "approved", mark=True)
|
||
return clip_view(_clip(clip_id))
|
||
|
||
@app.post("/v1/clips/{clip_id}/render")
|
||
def rerender(clip_id: int):
|
||
"""Força o render (ex.: corte que a IA descartou ou que deu erro)."""
|
||
_clip(clip_id)
|
||
db.run("UPDATE clips SET status = 'pending', error = NULL, updated_at = ? WHERE id = ?", now(), clip_id)
|
||
engine.drop_final(clip_id)
|
||
engine.wake_clips.set()
|
||
return clip_view(_clip(clip_id))
|
||
|
||
@app.post("/v1/clips/{clip_id}/final")
|
||
def render_final(clip_id: int):
|
||
"""(Re)gera o vídeo final de um corte aprovado ("tentar de novo" depois de um erro). 409 se não aprovado."""
|
||
row = _clip(clip_id)
|
||
if row["status"] not in APPROVED:
|
||
raise UserError("Só corte aprovado tem vídeo final. Aprove o corte primeiro.", 409)
|
||
if row.get("final_status") not in ("pending", "rendering"):
|
||
engine.queue_final(clip_id)
|
||
return clip_view(_clip(clip_id))
|
||
|
||
@app.post("/v1/clips/{clip_id}/translate")
|
||
def translate_clip(clip_id: int):
|
||
"""Traduz (de novo) a fala do corte para o português. Só para fonte em inglês; 409 se não couber."""
|
||
_clip(clip_id)
|
||
if engine.translate_clip(clip_id, force=True) is None:
|
||
raise UserError("Sem tradução: a fonte não está em inglês, a IA está desligada ou não respondeu.", 409)
|
||
return clip_view(_clip(clip_id))
|
||
|
||
@app.post("/v1/clips/{clip_id}/rejudge")
|
||
def rejudge(clip_id: int):
|
||
_clip(clip_id)
|
||
db.run("UPDATE clips SET status = 'candidate', updated_at = ? WHERE id = ?", now(), clip_id)
|
||
engine.drop_final(clip_id)
|
||
engine.wake_clips.set()
|
||
return clip_view(_clip(clip_id))
|
||
|
||
# Editor de cortes (/v1/clips/{id}/edit, proxy, waveform, export, preview-render, retranscribe, tts, suggest).
|
||
editor_api.register(app, engine, clip_view, _clip)
|
||
return app
|
||
|
||
|
||
def build() -> FastAPI: # pragma: no cover - ponto de entrada do uvicorn (--factory)
|
||
return create_app()
|