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:
co-authored by
Claude Opus 5.5
parent
54eac7cebf
commit
dc0917b114
@@ -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]
|
||||
|
||||
@@ -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"])}
|
||||
|
||||
|
||||
@@ -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
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user