"""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//clip-*`, a pasta do editor `edit-/` (proxy, forma de onda, narração, prévias) e os quadros que o juiz viu (`/frames/clip-*.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}