CenaForge: primeira versão pública

Gerador de vídeos narrativos (Godot + FFmpeg), painel Next.js, serviço de voz,
Clipador de lives e Publicador para YouTube, TikTok e Instagram.

Inclui a leitura das visualizações dos posts para o Dashboard e o botão
"Publicar no <rede>" nos cartões das publicações.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-17 16:35:09 -03:00
co-authored by Claude Opus 5.5
commit 84f30bbc2d
484 changed files with 74826 additions and 0 deletions
+268
View File
@@ -0,0 +1,268 @@
"""Apagar cortes: um, vários ou todos de uma aba (rotas `DELETE /v1/clips/{id}` e `POST /v1/clips/delete`).
O que some com o corte: a linha em `clips`, o projeto de edição (`edits`) e os arquivos dele — vídeo, capa,
miniatura e restos do render em `output/clipper/<sessão>/clip-<id>*`, a pasta do editor `edit-<id>/` (proxy,
forma de onda, narração, prévias) e os quadros que o juiz viu (`<sessão>/frames/clip<id>-*.jpg`). Só apaga
dentro das pastas do Clipador (`CLIPPER_OUTPUT_DIR` e `CLIPPER_DATA_DIR`): o caminho é resolvido antes, link
ou junção nunca é seguido (some só o próprio link) e caminho de fora fica onde está, com o motivo na resposta.
Regras:
- `candidate` (a IA está avaliando) e `rendering` (o FFmpeg está trabalhando) são recusados: o laço do motor
escreveria num corte que não existe mais. Um `pending` que o motor acabou de pegar para renderizar também.
- `published` só com `confirmPublished`: o vídeo já foi postado e a cópia local é o único registro dele aqui.
- **O momento apagado não volta.** A regra anti-duplicado (`worker.find_new_clips`, varredura da IA) compara o
candidato com os cortes existentes, inclusive descartados. Sem o corte, a passada seguinte de uma live em
andamento (ou a passada final da sessão inteira) recriaria o mesmo momento. Por isso fica uma marca mínima em
`deleted_clips` (migração v10): pico, trecho final e janela original do candidato. Ela entra na mesma conta
dos cortes existentes e some junto com a sessão. Apagado que estava pronto, aprovado, rejeitado etc.
(`worker.VETO_STATUSES`) também veta o trecho final depois do juiz ("Duplicado do corte N (que você apagou)");
descartado pela IA não veta, como antes.
- O aprendizado já feito (peso dos emotes, `clips.learned`) fica: ele mora na tabela `emotes`, não no corte.
`judge.duplicateOf` de outros cortes é só texto informativo (nada no código lê esse id de volta).
"""
from __future__ import annotations
import json
import logging
import os
from pathlib import Path
from .config import REPO_ROOT
from .db import loads, now
log = logging.getLogger("cenaforge_clipper.delete")
MAX_BATCH = 500 # mesmo teto da listagem (GET /v1/clips?limit=500), que é o que o painel mostra
# Estados em que o motor ainda está mexendo no corte: recusa com motivo (código, texto para o painel).
BUSY = {
"candidate": ("busy_candidate", "a IA está avaliando este corte"),
"rendering": ("busy_rendering", "está renderizando"),
}
PUBLISHED = ("published", "está publicado: confirme para apagar a cópia local")
NOT_FOUND = ("not_found", "corte não encontrado")
CHANGED = ("changed", "mudou de estado agora há pouco; tente de novo")
class DeleteRefused(Exception):
def __init__(self, code: str, message: str, status: int = 409):
super().__init__(message)
self.code, self.message, self.status = code, message, status
# ---------------------------------------------------------------- marca do momento apagado
def marks(db, session_id: int) -> list[dict]:
"""Momentos apagados da sessão no mesmo formato das linhas de `clips` que o anti-duplicado lê (`id` = o do corte
apagado, que nunca volta a ser usado; `status` = o estado em que ele foi apagado; `peak_s`, `start_s`, `end_s`;
`reasons_json` com a janela original do candidato) e `deleted: True`."""
out = []
for r in db.all("SELECT * FROM deleted_clips WHERE session_id = ?", session_id):
reasons = ({"candidateStartS": r["candidate_start_s"], "candidateEndS": r["candidate_end_s"]}
if r["candidate_start_s"] is not None and r["candidate_end_s"] is not None else {})
out.append({"id": r["clip_id"], "session_id": r["session_id"], "status": r["status"], "peak_s": r["peak_s"],
"start_s": r["start_s"], "end_s": r["end_s"], "title": r["title"],
"reasons_json": json.dumps(reasons), "deleted": True})
return out
def mark_spans(db, session_id: int, lo: float, hi: float) -> list[tuple[float, float, str]]:
"""Trechos apagados que tocam [lo, hi], para a varredura da IA não propor o mesmo momento de novo."""
spans = []
for m in marks(db, session_id):
reasons = loads(m["reasons_json"], {})
a = min(m["start_s"], reasons.get("candidateStartS", m["start_s"]))
b = max(m["end_s"], reasons.get("candidateEndS", m["end_s"]))
if b > lo and a < hi:
spans.append((a, b, "apagado"))
return spans
# ---------------------------------------------------------------- arquivos do corte
def _roots(engine) -> list[Path]:
return [engine.settings.clips_dir.resolve(), engine.settings.data_dir.resolve()]
def _inside(path: Path, roots: list[Path]) -> bool:
try:
resolved = path.resolve()
except OSError:
return False
return any(resolved.is_relative_to(r) for r in roots)
def _is_link(path: Path) -> bool:
return path.is_symlink() or path.is_junction()
def _rel(path: Path) -> str:
try:
return path.relative_to(REPO_ROOT).as_posix()
except ValueError:
return path.as_posix()
def _unlink_link(path: Path) -> None:
"""Remove só o link (símbolo ou junção), nunca o alvo."""
try:
os.unlink(path)
except (IsADirectoryError, PermissionError):
os.rmdir(path) # junção/link de pasta no Windows: rmdir tira o link e não toca no alvo
def _remove_tree(folder: Path, removed: list[str], left: list[dict]) -> None:
"""Apaga a pasta sem seguir link nem junção (o link some; o alvo fica)."""
with os.scandir(folder) as entries:
for entry in entries:
path = Path(entry.path)
try:
if entry.is_symlink() or entry.is_junction():
_unlink_link(path)
elif entry.is_dir(follow_symlinks=False):
_remove_tree(path, removed, left)
continue
else:
path.unlink()
removed.append(_rel(path))
except OSError as exc:
left.append({"file": _rel(path), "reason": f"não deu para apagar ({exc.__class__.__name__})"})
try:
folder.rmdir()
except OSError as exc:
left.append({"file": _rel(folder), "reason": f"pasta não ficou vazia ({exc.__class__.__name__})"})
def clip_paths(engine, clip: dict, session: dict | None, cover: str | None) -> tuple[list[Path], list[Path]]:
"""(arquivos, pastas) que pertencem ao corte. Caminhos do banco são relativos à raiz do repositório."""
out_dir = engine.settings.clips_dir / str(clip["session_id"])
cid = clip["id"]
files: list[Path] = [REPO_ROOT / p for p in (clip.get("file"), clip.get("thumb"), cover) if p]
if out_dir.is_dir():
# vídeo, miniatura, capa (`-cover.jpg`) e restos do render (`.ass`, `.concat.txt`, `.tmp.mp4`, `.graph.txt`,
# `.uniform.mkv`, máscaras das camadas). `clip-1.*`/`clip-1-*` não pegam o `clip-12`.
files += sorted(out_dir.glob(f"clip-{cid}.*")) + sorted(out_dir.glob(f"clip-{cid}-*"))
if session and session.get("dir"):
frames = REPO_ROOT / session["dir"] / "frames"
if frames.is_dir():
files += sorted(frames.glob(f"clip{cid}-*.jpg")) # quadros que o analista/editor viram
folders = [out_dir / f"edit-{cid}"] # editor: proxy, forma de onda, TTS, prévias
return files, folders
def remove_files(engine, files: list[Path], folders: list[Path]) -> tuple[list[str], list[dict]]:
roots = _roots(engine)
removed: list[str] = []
left: list[dict] = []
seen: set[str] = set()
for path in files:
key = os.path.normcase(os.path.abspath(path))
if key in seen:
continue
seen.add(key)
if not (path.exists() or _is_link(path)):
continue
try:
if _is_link(path):
# O link pode apontar para fora: some só ele, e só se ele mesmo estiver dentro das pastas.
if not _inside(path.parent, roots):
left.append({"file": _rel(path), "reason": "fora das pastas do Clipador"})
continue
_unlink_link(path)
elif not _inside(path, roots):
left.append({"file": _rel(path), "reason": "fora das pastas do Clipador"})
continue
elif path.is_file():
path.unlink()
else:
continue
removed.append(_rel(path))
except OSError as exc:
left.append({"file": _rel(path), "reason": f"não deu para apagar ({exc.__class__.__name__})"})
for folder in folders:
if _is_link(folder):
if _inside(folder.parent, roots):
_unlink_link(folder)
removed.append(_rel(folder))
else:
left.append({"file": _rel(folder), "reason": "fora das pastas do Clipador"})
elif folder.is_dir():
if _inside(folder, roots):
_remove_tree(folder, removed, left)
else:
left.append({"file": _rel(folder), "reason": "fora das pastas do Clipador"})
return removed, left
# ---------------------------------------------------------------- apagar
def delete_clip(engine, clip_id: int, confirm_published: bool = False) -> dict:
"""Apaga um corte. Recusa com `DeleteRefused` (código + motivo). Devolve o que foi apagado."""
db = engine.db
# engine.lock: o motor marca `_rendering` sob o mesmo trinco (render_clip), então um corte não começa a
# renderizar no meio da exclusão. db.lock: ler o estado e apagar sem outra thread escrever no meio.
with engine.lock, db.lock:
clip = db.get("SELECT * FROM clips WHERE id = ?", clip_id)
if not clip:
raise DeleteRefused(*NOT_FOUND, status=404)
status = clip["status"]
if status in BUSY:
raise DeleteRefused(*BUSY[status])
if clip_id in engine._rendering:
raise DeleteRefused(*BUSY["rendering"])
if status == "published" and not confirm_published:
raise DeleteRefused(*PUBLISHED)
session = db.get("SELECT * FROM sessions WHERE id = ?", clip["session_id"])
edit = db.get("SELECT cover FROM edits WHERE clip_id = ?", clip_id)
reasons = loads(clip.get("reasons_json"), {})
reasons = reasons if isinstance(reasons, dict) else {}
def number(key: str) -> float | None:
try:
return float(reasons[key])
except (KeyError, TypeError, ValueError):
return None
db.conn.execute("BEGIN")
try:
# A marca vem antes de apagar: o anti-duplicado nunca vê a sessão sem o corte e sem a marca.
db.conn.execute(
"INSERT OR REPLACE INTO deleted_clips (clip_id, session_id, peak_s, start_s, end_s, candidate_start_s,"
" candidate_end_s, status, source, title, deleted_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
(clip_id, clip["session_id"], clip["peak_s"], clip["start_s"], clip["end_s"], number("candidateStartS"),
number("candidateEndS"), status, clip["source"], (clip["title"] or "")[:100], now()))
db.conn.execute("DELETE FROM edits WHERE clip_id = ?", (clip_id,))
gone = db.conn.execute("DELETE FROM clips WHERE id = ? AND status = ?", (clip_id, status)).rowcount
if gone != 1:
raise DeleteRefused(*CHANGED)
db.conn.execute("COMMIT")
except BaseException:
db.conn.execute("ROLLBACK")
raise
# Arquivos fora do trinco (podem demorar); nada mais aponta para eles e o render não pega um id que sumiu.
files, folders = clip_paths(engine, clip, session, edit["cover"] if edit else None)
removed, left = remove_files(engine, files, folders)
log.info("corte %s apagado (%s): %d arquivos, %d ficaram", clip_id, status, len(removed), len(left))
return {"id": clip_id, "sessionId": clip["session_id"], "status": status, "removedFiles": len(removed),
"left": left}
def select_ids(db, session_id: int | None, statuses: list[str], limit: int = MAX_BATCH) -> tuple[list[int], int]:
"""Ids dos cortes nesses estados (e nessa sessão, se vier), do mais novo para o mais velho, até `limit`.
Devolve (ids, quantos ficaram de fora pelo limite)."""
sql = "SELECT id FROM clips WHERE status IN (" + ",".join("?" * len(statuses)) + ")"
params: list = list(statuses)
if session_id is not None:
sql += " AND session_id = ?"
params.append(session_id)
ids = [r["id"] for r in db.all(sql + " ORDER BY id DESC", *params)]
return ids[:limit], max(0, len(ids) - limit)
def delete_many(engine, ids: list[int], confirm_published: bool = False) -> dict:
"""Apaga vários. Cada um passa pelas mesmas regras; o que não pôde vai em `failed` com o motivo."""
deleted, failed = [], []
for clip_id in dict.fromkeys(ids): # sem repetir, na ordem pedida
try:
deleted.append(delete_clip(engine, clip_id, confirm_published))
except DeleteRefused as exc:
failed.append({"id": clip_id, "code": exc.code, "reason": exc.message})
return {"deleted": deleted, "failed": failed}