Files
CenaForge/clipper/app/main.py
T
MateuusandClaude Opus 5.5 439e111052 Integração: falantes + dublagem + vídeo final
- 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>
2026-11-18 03:59:44 -03:00

826 lines
44 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""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()