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>
269 lines
13 KiB
Python
269 lines
13 KiB
Python
"""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}
|