Clipador: vídeo final sem camadas de teste ao aprovar; publicação só usa o final

Pedido do dono: o vídeo da fila é de revisão (com as camadas `dev`, ex.: tradução);
ao aprovar, o serviço renderiza de novo sem elas, e só esse vai para as redes.

- db v14: clips.review_dev_json (camadas que entraram na revisão) e final_status/
  final_file/final_thumb/final_cover/final_error/final_at; backfill dos cortes antigos.
- Motor: queue_final/drop_final/render_final; fila renderiza finais primeiro com
  render_clip_edit(dev=False) em clip-<id>-final.mp4; revisão sem camada de teste
  vira o final sem render novo; prune guarda os blocos de quem ainda precisa do final.
- API: clip traz review.devLayers, final e publishFile; aprovar enfileira o final;
  desaprovar, mudar trecho, exportar, re-render e rejudge derrubam o final;
  POST /v1/clips/{id}/final (tentar de novo).
- Painel: etiqueta na lista, player Final/Revisão e estado do final no modal
  (gerando/pronto/erro com "Tentar de novo"), aviso no "Publicar"; o despachante
  relê o corte antes de enviar e espera o final (clipPublishFile), nunca a revisão.
- Testes: clipper/tests/test_final_render.py e testes do despachante no painel.
- Doc: doc/clipador/REVISAO.md.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Mateuus
2026-11-18 03:27:26 -03:00
co-authored by Claude Opus 5.5
parent 54eac7cebf
commit dc0917b114
16 changed files with 819 additions and 23 deletions
+21
View File
@@ -212,6 +212,26 @@ SCHEMA = [
"""
ALTER TABLE clips ADD COLUMN translation_json TEXT;
""",
# v14: vídeo de revisão × vídeo final (doc/clipador/REVISAO.md). O render da fila é o de REVISÃO (com as camadas
# `dev` ligadas); ao aprovar, sai o FINAL (`dev=False`) em `clip-<id>-final.mp4`, que é o único que se publica.
# `review_dev_json` = camadas de desenvolvimento que entraram no arquivo de revisão (["translation", ...]; [] =
# nenhuma → o de revisão já é o final; NULL = desconhecido → renderiza o final). `final_status`: pending |
# rendering | ready | error (NULL = sem final: não aprovado, ou a aprovação foi desfeita/editada).
# Cortes de antes da v14: a única camada de desenvolvimento era a tradução, que só entra com `translation_json`;
# sem ela o arquivo já é limpo ([]).
"""
ALTER TABLE clips ADD COLUMN review_dev_json TEXT;
ALTER TABLE clips ADD COLUMN final_status TEXT CHECK (final_status IN ('pending', 'rendering', 'ready', 'error'));
ALTER TABLE clips ADD COLUMN final_file TEXT;
ALTER TABLE clips ADD COLUMN final_thumb TEXT;
ALTER TABLE clips ADD COLUMN final_cover TEXT;
ALTER TABLE clips ADD COLUMN final_error TEXT;
ALTER TABLE clips ADD COLUMN final_at TEXT;
UPDATE clips SET review_dev_json = '[]' WHERE file IS NOT NULL AND translation_json IS NULL;
UPDATE clips SET final_status = 'pending' WHERE status = 'approved' AND review_dev_json IS NULL AND file IS NOT NULL;
UPDATE clips SET final_status = 'ready', final_file = file, final_thumb = thumb, final_at = updated_at
WHERE status IN ('approved', 'published') AND review_dev_json = '[]';
""",
]
@@ -237,6 +257,7 @@ class Database:
# Chat só fica "conectado" enquanto grava (sessões antigas ficaram com o estado velho gravado).
self.run("UPDATE sessions SET chat_status = 'off' WHERE status NOT IN ('starting', 'recording') AND chat_status != 'off'")
self.run("UPDATE clips SET status = 'pending' WHERE status = 'rendering'")
self.run("UPDATE clips SET final_status = 'pending' WHERE final_status = 'rendering'") # vídeo final idem
def _migrate(self) -> None:
version = self.conn.execute("PRAGMA user_version").fetchone()[0]
+20 -3
View File
@@ -93,8 +93,10 @@ def load_edit(engine, clip_id: int) -> dict | None:
return row
def render_clip_edit(engine, clip: dict, session: dict, edit: dict, out: Path, thumb: Path) -> str | None:
"""Render do corte pelo projeto de edição (chamado pela fila do motor). Devolve o caminho da capa (ou None)."""
def render_clip_edit(engine, clip: dict, session: dict, edit: dict, out: Path, thumb: Path, dev: bool = True) -> str | None:
"""Render do corte pelo projeto de edição (chamado pela fila do motor). Devolve o caminho da capa (ou None).
`dev=True` = vídeo de REVISÃO (com as camadas `dev` ligadas; grava quais entraram em `clips.review_dev_json`);
`dev=False` = vídeo FINAL, depois de aprovar (sem nenhuma camada de desenvolvimento) — doc/clipador/REVISAO.md."""
project = validate_for(engine, clip, session, edit["project"])
segments = session_segments(engine, clip["session_id"])
if engine._encoder is None:
@@ -111,9 +113,13 @@ def render_clip_edit(engine, clip: dict, session: dict, edit: dict, out: Path, t
except media.MediaError as exc: # capa é extra: o vídeo vale mesmo sem ela
log.warning("capa do corte %s falhou: %s", clip["id"], exc)
cover = None
translation = translation_for(engine, clip, project, base, dev=dev)
editor_render.render_project(ffmpeg, engine.settings.ffprobe, engine._encoder, segments, project, base, credit, out,
REPO_ROOT, chat=chat_for(engine, project), cover_file=cover,
translation=translation_for(engine, clip, project, base))
translation=translation, dev=dev)
if dev:
layers = review_layers(editor.effective_settings(base, project), translation)
engine.db.run("UPDATE clips SET review_dev_json = ? WHERE id = ?", json.dumps(layers), clip["id"])
total = editor.output_duration(project["cuts"])
media.thumbnail(ffmpeg, out, min(3.0, total / 2), thumb)
# Formato em que ESTE arquivo saiu (camadas padrão ← canal ← sessão ← projeto): a fila desenha o player por ele.
@@ -121,6 +127,16 @@ def render_clip_edit(engine, clip: dict, session: dict, edit: dict, out: Path, t
return cover.relative_to(REPO_ROOT).as_posix() if cover else None
def review_layers(cfg: dict, translation: list[dict] | None) -> list[str]:
"""Camadas de desenvolvimento que entraram no vídeo de revisão (vazio = ele já é o vídeo final). A tradução só
conta se havia frases para desenhar (fonte em português nunca tem); as outras chaves do grupo `dev` (dublagem…)
contam pela configuração, por cautela: na dúvida, o final é renderizado de novo."""
flags = dict(layout.dev_flags(cfg, True))
if not translation:
flags["translation"] = False
return sorted(k for k, on in flags.items() if on)
def translation_for(engine, clip: dict, project: dict, base: dict, dev: bool = True) -> list[dict] | None:
"""Frases traduzidas para a legenda de desenvolvimento (doc/clipador/IDIOMAS.md): só com `dev.translation`
ligado, render de desenvolvimento e fonte em inglês. Traduz o trecho do projeto se ainda não houver tradução."""
@@ -401,6 +417,7 @@ def register(app: FastAPI, engine, clip_view, get_clip) -> None:
db.run("UPDATE clips SET start_s = ?, end_s = ?, status = 'pending', error = NULL, transcript = ?, updated_at = ? WHERE id = ?",
start, end, " ".join(w.word for w in words)[:4000], ts, clip_id)
db.run("UPDATE edits SET exported_at = ? WHERE clip_id = ?", ts, clip_id)
engine.drop_final(clip_id) # editou: o final antigo deixa de valer; volta a ser revisão (aprovar de novo)
engine.wake_clips.set()
return clip_view(get_clip(clip_id)) | {"editedDurationS": editor.output_duration(project["cuts"])}
+36
View File
@@ -170,6 +170,19 @@ class ClipsDeleteIn(BaseModel):
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"],
@@ -191,6 +204,12 @@ def clip_view(row: dict) -> dict:
"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,
}
@@ -743,6 +762,11 @@ def create_app(settings: Settings | None = None, engine: Engine | None = None, s
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)
@@ -753,9 +777,20 @@ def create_app(settings: Settings | None = None, engine: Engine | None = None, s
"""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."""
@@ -768,6 +803,7 @@ def create_app(settings: Settings | None = None, engine: Engine | None = None, s
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))
+91 -1
View File
@@ -1000,6 +1000,12 @@ class Engine:
def render_pending(self) -> None:
self.recover_orphan_renders()
self.discard_pending_duplicates()
# Vídeos finais primeiro: o corte já foi aprovado e a publicação está esperando por ele (REVISAO.md).
for clip in self.db.all("SELECT * FROM clips WHERE final_status = 'pending' AND status IN ('approved', 'published')"
" ORDER BY updated_at, id LIMIT 3"):
if self.stop_event.is_set():
return
self.render_final(clip)
for clip in self.db.all("SELECT * FROM clips WHERE status = 'pending' ORDER BY score DESC, id LIMIT 3"):
if self.stop_event.is_set():
return
@@ -1105,8 +1111,87 @@ class Engine:
self.db.run("UPDATE edits SET cover = ? WHERE clip_id = ?", cover, clip["id"])
self.db.run("UPDATE clips SET status = 'ready', file = ?, thumb = ?, error = NULL, updated_at = ? WHERE id = ?",
rel(out), rel(thumb), now(), clip["id"])
self.drop_final(clip["id"]) # vídeo de revisão novo = conteúdo novo: o final antigo deixa de valer
self._render_attempts.pop(clip["id"], None)
# ---------- vídeo final (doc/clipador/REVISAO.md)
def queue_final(self, clip_id: int) -> str | None:
"""Corte aprovado: pede o vídeo FINAL (sem camadas de desenvolvimento). Se o vídeo de revisão não teve nenhuma
camada `dev` (`review_dev_json` = []), ele já é o final: reaproveita sem renderizar. Devolve o `final_status`."""
with self.db.lock:
clip = self.db.get("SELECT c.*, e.cover AS edit_cover FROM clips c LEFT JOIN edits e ON e.clip_id = c.id"
" WHERE c.id = ?", clip_id)
if not clip or clip["status"] not in ("approved", "published"):
return None
if loads(clip["review_dev_json"], None) == [] and clip["file"]:
self.db.run("UPDATE clips SET final_status = 'ready', final_file = ?, final_thumb = ?, final_cover = ?,"
" final_error = NULL, final_at = ? WHERE id = ?",
clip["file"], clip["thumb"], clip["edit_cover"], now(), clip_id)
return "ready"
self.db.run("UPDATE clips SET final_status = 'pending', final_file = NULL, final_thumb = NULL, final_cover = NULL,"
" final_error = NULL, final_at = NULL WHERE id = ?", clip_id)
self.wake_clips.set()
return "pending"
def drop_final(self, clip_id: int) -> None:
"""O final deixa de valer (aprovação desfeita, corte editado ou renderizado de novo). O arquivo fica no disco
até o próximo final (mesmo nome) ou até apagar o corte; nada mais aponta para ele."""
self.db.run("UPDATE clips SET final_status = NULL, final_file = NULL, final_thumb = NULL, final_cover = NULL,"
" final_error = NULL, final_at = NULL WHERE id = ?", clip_id)
def render_final(self, clip: dict) -> None:
"""Renderiza o vídeo final de um corte aprovado. Falha vira `final_status = 'error'` (o corte continua
aprovado; "tentar de novo" no painel = POST /v1/clips/{id}/final)."""
with self.lock:
# Apagado depois de a fila ler a lista, ou já em render: não começa (clip_delete recusa enquanto estiver aqui).
if clip["id"] in self._rendering or not self.db.get("SELECT 1 FROM clips WHERE id = ?", clip["id"]):
return
self._rendering.add(clip["id"])
try:
self._render_final(clip)
except Exception as exc: # noqa: BLE001 - nunca fica preso em 'rendering'
log.exception("vídeo final do corte %s falhou", clip["id"])
self._final_error(clip["id"], f"falha inesperada no render final: {type(exc).__name__}: {exc}")
finally:
with self.lock:
self._rendering.discard(clip["id"])
def _render_final(self, clip: dict) -> None:
taken = self.db.run("UPDATE clips SET final_status = 'rendering', final_error = NULL WHERE id = ? AND final_status = 'pending'"
" AND status IN ('approved', 'published')", clip["id"]).rowcount
if not taken:
return
session = self.db.get("SELECT * FROM sessions WHERE id = ?", clip["session_id"])
if not session:
self._final_error(clip["id"], "sessão do corte não existe mais")
return
segments = self.db.all("SELECT deleted FROM segments WHERE session_id = ? AND end_s > ? AND start_s < ?",
clip["session_id"], clip["start_s"], clip["end_s"])
if not segments or any(s["deleted"] for s in segments):
self._final_error(clip["id"], "os blocos gravados deste trecho já foram apagados")
return
out_dir = self.settings.clips_dir / str(clip["session_id"])
out = out_dir / f"clip-{clip['id']}-final.mp4"
thumb = out_dir / f"clip-{clip['id']}-final.jpg"
from . import editor, editor_api # import tardio (ver _render_clip)
t = time.monotonic()
try:
edit = editor_api.ensure_edit(self, clip, session)
cover = editor_api.render_clip_edit(self, clip, session, edit, out, thumb, dev=False)
except (media.MediaError, editor.EditError) as exc:
self._final_error(clip["id"], str(exc))
return
# Só grava se ninguém desfez a aprovação (ou editou) durante o render: aí `final_status` já não é 'rendering'.
done = self.db.run("UPDATE clips SET final_status = 'ready', final_file = ?, final_thumb = ?, final_cover = ?, final_error = NULL,"
" final_at = ? WHERE id = ? AND final_status = 'rendering'",
rel(out), rel(thumb), cover, now(), clip["id"]).rowcount
log.info("vídeo final do corte %s em %.1f s%s", clip["id"], time.monotonic() - t,
"" if done else " (descartado: o corte mudou durante o render)")
def _final_error(self, clip_id: int, message: str) -> None:
self.db.run("UPDATE clips SET final_status = 'error', final_error = ? WHERE id = ? AND final_status IN ('pending', 'rendering')",
message[:500], clip_id)
def _clip_error(self, clip_id: int, message: str) -> None:
self.db.run("UPDATE clips SET status = 'error', error = ?, updated_at = ? WHERE id = ?", message[:500], now(), clip_id)
@@ -1128,8 +1213,13 @@ class Engine:
return
limit = time.time() - self.settings.keep_hours * 3600
for seg in self.db.all("SELECT * FROM segments WHERE deleted = 0 AND analyzed = 1 AND wall_end < ? LIMIT 200", limit):
# Também guarda o trecho de quem ainda vai precisar do vídeo final: aprovado com final por fazer ou com erro, e
# pronto para aprovar cujo vídeo de revisão tem camadas de desenvolvimento (ou não se sabe) — REVISAO.md.
needed = self.db.get(
"SELECT 1 FROM clips WHERE session_id = ? AND status IN ('candidate', 'pending', 'rendering') AND start_s < ? AND end_s > ?",
"SELECT 1 FROM clips WHERE session_id = ? AND start_s < ? AND end_s > ? AND ("
"status IN ('candidate', 'pending', 'rendering')"
" OR (status IN ('approved', 'published') AND final_status IN ('pending', 'rendering', 'error'))"
" OR (status = 'ready' AND COALESCE(review_dev_json, '') != '[]'))",
seg["session_id"], seg["end_s"], seg["start_s"])
if needed:
continue