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:
@@ -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}
|
||||
Reference in New Issue
Block a user