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
+283
View File
@@ -0,0 +1,283 @@
"""Vídeo de revisão × vídeo final (doc/clipador/REVISAO.md, pedido do dono 18/11/2026): "quando o clipe está ali para
a gente aprovar, a legenda é só de dev. Quando a gente aprovar, ele vai renderizar o vídeo de novo, removendo as coisas
de dev". O render da fila é o de revisão (dev=True); aprovar enfileira o final (dev=False); publicar só usa o final."""
import json
import sqlite3
from pathlib import Path
import app.db as db_module
import app.editor_api as editor_api
import app.worker as worker_module
from app import layout
from app.db import Database
from .test_sources_and_api import auth, env, seed_session # noqa: F401 - fixture reaproveitada
def add_ready_clip(engine, sid, cid=1, layers: list[str] | None = None, status="ready"):
engine.db.run(
"INSERT INTO clips (id, session_id, peak_s, start_s, end_s, score, source, status, title, file, thumb, review_dev_json,"
" created_at, updated_at) VALUES (?, ?, 100, 90, 160, 8, 'chat', ?, 't', ?, ?, ?, 'x', 'x')",
cid, sid, status, f"output/clipper/{sid}/clip-{cid}.mp4", f"output/clipper/{sid}/clip-{cid}.jpg",
None if layers is None else json.dumps(layers))
class RenderSpy:
"""Troca o render de verdade: guarda com que `dev` e para qual arquivo cada render foi pedido."""
def __init__(self, monkeypatch, engine, fail: bool = False):
self.calls: list[dict] = []
self.fail = fail
monkeypatch.setattr(worker_module, "REPO_ROOT", engine.settings.data_dir.parent) # caminhos relativos do teste
monkeypatch.setattr(editor_api, "ensure_edit", lambda eng, clip, session: {"project": {}})
monkeypatch.setattr(editor_api, "render_clip_edit", self)
def __call__(self, engine, clip, session, edit, out: Path, thumb: Path, dev: bool = True):
self.calls.append({"clip": clip["id"], "out": out.name, "thumb": thumb.name, "dev": dev})
if self.fail:
from app import media
raise media.MediaError("ffmpeg caiu")
return f"output/clipper/{clip['session_id']}/{out.stem}-cover.jpg"
def view(client, cid=1) -> dict:
return client.get(f"/v1/clips/{cid}", headers=auth()).json()
def approve(client, cid=1, status="approved") -> dict:
r = client.patch(f"/v1/clips/{cid}", json={"status": status}, headers=auth())
assert r.status_code == 200, r.text
return r.json()
# ---------------------------------------------------------------- aprovar → final com dev=False
def test_approve_queues_final_render_without_dev_layers(env, monkeypatch): # noqa: F811
client, engine = env
sid = seed_session(engine)
add_ready_clip(engine, sid, layers=["translation"])
spy = RenderSpy(monkeypatch, engine)
before = view(client)
assert before["review"]["devLayers"] == ["translation"] and before["final"] is None and before["publishFile"] is None
body = approve(client)
assert body["status"] == "approved"
assert body["final"]["status"] == "pending" and body["publishFile"] is None # nada publicável ainda
assert engine.wake_clips.is_set()
engine.render_pending()
assert spy.calls == [{"clip": 1, "out": "clip-1-final.mp4", "thumb": "clip-1-final.jpg", "dev": False}]
after = view(client)
final = after["final"]
assert final["status"] == "ready" and not final["reused"] and final["error"] is None
assert final["file"].endswith("clip-1-final.mp4") and final["thumb"].endswith("clip-1-final.jpg")
assert final["cover"].endswith("clip-1-final-cover.jpg")
assert after["publishFile"] == final["file"] != after["file"] # o de revisão continua sendo `file`
engine.render_pending()
assert len(spy.calls) == 1 # pronto não renderiza de novo
def test_review_render_of_the_queue_stays_dev_true(env, monkeypatch): # noqa: F811
client, engine = env
monkeypatch.setattr(worker_module, "REPO_ROOT", engine.settings.data_dir.parent)
sid = seed_session(engine)
add_ready_clip(engine, sid, layers=None, status="pending")
spy = RenderSpy(monkeypatch, engine)
engine.render_pending()
assert spy.calls == [{"clip": 1, "out": "clip-1.mp4", "thumb": "clip-1.jpg", "dev": True}]
assert view(client)["status"] == "ready" and view(client)["final"] is None
def test_unknown_layers_render_final(env, monkeypatch): # noqa: F811
"""Sem saber o que entrou no vídeo de revisão (`review_dev_json` NULL), o final é renderizado por cautela."""
client, engine = env
sid = seed_session(engine)
add_ready_clip(engine, sid, layers=None)
spy = RenderSpy(monkeypatch, engine)
assert approve(client)["final"]["status"] == "pending"
engine.render_pending()
assert [c["dev"] for c in spy.calls] == [False]
# ---------------------------------------------------------------- sem camadas dev: reaproveita
def test_without_dev_layers_review_is_already_final(env, monkeypatch): # noqa: F811
client, engine = env
sid = seed_session(engine)
add_ready_clip(engine, sid, layers=[])
engine.db.run("INSERT INTO edits (clip_id, project_json, created_at, updated_at, cover) VALUES (1, '{}', 'x', 'x', ?)",
f"output/clipper/{sid}/clip-1-cover.jpg")
spy = RenderSpy(monkeypatch, engine)
body = approve(client)
assert body["final"]["status"] == "ready" and body["final"]["reused"]
assert body["publishFile"] == body["file"] and body["final"]["cover"].endswith("clip-1-cover.jpg")
engine.render_pending()
assert spy.calls == [] # não renderizou de novo
# ---------------------------------------------------------------- publicação nunca pega o de revisão
def test_publish_file_is_never_the_review_video(env, monkeypatch): # noqa: F811
client, engine = env
sid = seed_session(engine)
add_ready_clip(engine, sid, 1, layers=["translation"])
add_ready_clip(engine, sid, 2, layers=["dub", "translation"])
spy = RenderSpy(monkeypatch, engine, fail=True)
def publishable() -> dict[int, str | None]:
clips = client.get("/v1/clips?status=ready,approved,published", headers=auth()).json()["clips"]
return {c["id"]: c["publishFile"] for c in clips}
assert publishable() == {1: None, 2: None} # pronto para aprovar = só revisão
approve(client, 1)
approve(client, 2, status="published") # marcado publicado direto também pede o final
assert publishable() == {1: None, 2: None} # final na fila
engine.render_pending() # o render final falha
for cid in (1, 2):
v = view(client, cid)
assert v["final"]["status"] == "error" and "ffmpeg caiu" in v["final"]["error"]
assert v["publishFile"] is None and v["status"] in ("approved", "published") # erro não vira revisão publicável
# "Tentar de novo" (POST /final): volta à fila e, desta vez, sai.
spy.fail = False
assert client.post("/v1/clips/1/final", headers=auth()).json()["final"]["status"] == "pending"
engine.render_pending()
v = view(client, 1)
assert v["publishFile"] and v["publishFile"] != v["file"] and v["publishFile"].endswith("-final.mp4")
assert all(f is None or f.endswith("-final.mp4") for f in publishable().values())
# Só corte aprovado tem final.
client.patch("/v1/clips/2", json={"status": "ready"}, headers=auth())
assert client.post("/v1/clips/2/final", headers=auth()).status_code == 409
# ---------------------------------------------------------------- desaprovar / editar
def test_unapprove_edit_and_rerender_drop_the_final(env, monkeypatch): # noqa: F811
client, engine = env
monkeypatch.setattr(worker_module, "REPO_ROOT", engine.settings.data_dir.parent)
sid = seed_session(engine)
add_ready_clip(engine, sid, layers=["translation"])
spy = RenderSpy(monkeypatch, engine)
approve(client)
engine.render_pending()
assert view(client)["publishFile"]
# Desaprovar (voltar para pronto) ou rejeitar: o final deixa de valer.
body = client.patch("/v1/clips/1", json={"status": "ready"}, headers=auth()).json()
assert body["final"] is None and body["publishFile"] is None
approve(client)
assert view(client)["final"]["status"] == "pending" # aprovar de novo = final novo
engine.render_pending()
# Mudar o trecho de um aprovado: volta a ser revisão (renderiza de novo) e o final some.
body = client.patch("/v1/clips/1", json={"startS": 95, "endS": 160}, headers=auth()).json()
assert body["status"] == "pending" and body["final"] is None and body["publishFile"] is None
# Render de revisão novo também derruba qualquer final (ex.: export do editor).
engine.db.run("UPDATE clips SET status = 'approved', final_status = 'ready', final_file = 'x-final.mp4' WHERE id = 1")
engine.render_pending() # o final está pronto; nada pendente
engine.db.run("UPDATE clips SET status = 'pending' WHERE id = 1")
engine.render_pending()
v = view(client)
assert v["status"] == "ready" and v["final"] is None and spy.calls[-1]["dev"] is True
# Pedir render de novo (botão) também.
approve(client)
engine.render_pending()
assert client.post("/v1/clips/1/render", headers=auth()).json()["final"] is None
def test_unapprove_during_final_render_discards_it(env, monkeypatch): # noqa: F811
client, engine = env
sid = seed_session(engine)
add_ready_clip(engine, sid, layers=["translation"])
approve(client)
def slow_render(eng, clip, session, edit, out, thumb, dev=True):
client.patch("/v1/clips/1", json={"status": "ready"}, headers=auth()) # desaprovou no meio do render
return None
monkeypatch.setattr(editor_api, "ensure_edit", lambda eng, clip, session: {"project": {}})
monkeypatch.setattr(editor_api, "render_clip_edit", slow_render)
engine.render_pending()
v = view(client)
assert v["final"] is None and v["publishFile"] is None and engine._rendering == set()
# ---------------------------------------------------------------- quais camadas entraram na revisão
def test_review_layers():
lines = [{"s": 0, "e": 1, "text": "hi", "pt": "oi"}]
on = layout.merge({"dev": {"translation": True}})
assert editor_api.review_layers(on, lines) == ["translation"]
assert editor_api.review_layers(on, None) == [] # fonte em português: nada desenhado
assert editor_api.review_layers(layout.merge(), lines) == []
assert editor_api.review_layers(layout.merge({"dev": {"dub": True}}), None) == ["dub"]
legacy = layout.merge({"caption": {"translation": True}})
assert editor_api.review_layers(legacy, lines) == ["translation"]
def test_render_clip_edit_passes_dev_and_records_layers(env, monkeypatch): # noqa: F811
"""render_clip_edit: dev=True grava as camadas da revisão; dev=False não pede tradução nem mexe no registro."""
_client, engine = env
sid = seed_session(engine)
add_ready_clip(engine, sid, layers=None)
seen: list[dict] = []
project = {"cover": {"enabled": False}, "cuts": [{"start": 90, "end": 150, "mode": None}]}
monkeypatch.setattr(editor_api, "validate_for", lambda eng, clip, session, data: project)
monkeypatch.setattr(editor_api.editor, "effective_settings", lambda base, p: layout.merge({"dev": {"translation": True}}))
monkeypatch.setattr(editor_api, "translation_for",
lambda eng, clip, p, base, dev=True: [{"s": 0, "e": 1, "text": "hi", "pt": "oi"}] if dev else None)
monkeypatch.setattr(editor_api.editor_render, "render_project",
lambda *a, **k: seen.append({"dev": k["dev"], "translation": k["translation"]}))
monkeypatch.setattr(editor_api.media, "thumbnail", lambda *a, **k: None)
monkeypatch.setattr(editor_api.media, "pick_encoder", lambda *a, **k: [])
session = engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)
clip = engine.db.get("SELECT * FROM clips WHERE id = 1")
out = engine.settings.clips_dir / "clip-1.mp4"
editor_api.render_clip_edit(engine, clip, session, {"project": project}, out, out.with_suffix(".jpg"))
assert seen[-1]["dev"] is True and seen[-1]["translation"]
assert json.loads(engine.db.get("SELECT review_dev_json FROM clips WHERE id = 1")["review_dev_json"]) == ["translation"]
final = engine.settings.clips_dir / "clip-1-final.mp4"
editor_api.render_clip_edit(engine, clip, session, {"project": project}, final, final.with_suffix(".jpg"), dev=False)
assert seen[-1] == {"dev": False, "translation": None}
assert json.loads(engine.db.get("SELECT review_dev_json FROM clips WHERE id = 1")["review_dev_json"]) == ["translation"]
# ---------------------------------------------------------------- limpeza e migração
def test_prune_keeps_segments_that_the_final_still_needs(env, monkeypatch): # noqa: F811
_client, engine = env
monkeypatch.setattr(worker_module, "REPO_ROOT", engine.settings.data_dir.parent)
sid = seed_session(engine) # blocos de 30 s, todos "velhos" (wall_end ≈ 1970)
engine.db.run("INSERT INTO clips (id, session_id, peak_s, start_s, end_s, score, source, status, review_dev_json, created_at,"
" updated_at) VALUES (1, ?, 100, 90, 110, 8, 'chat', 'ready', '[\"translation\"]', 'x', 'x')", sid)
engine.db.run("INSERT INTO clips (id, session_id, peak_s, start_s, end_s, score, source, status, review_dev_json, created_at,"
" updated_at) VALUES (2, ?, 200, 190, 200, 8, 'chat', 'ready', '[]', 'x', 'x')", sid)
engine.db.run("INSERT INTO clips (id, session_id, peak_s, start_s, end_s, score, source, status, final_status, created_at,"
" updated_at) VALUES (3, ?, 400, 400, 410, 8, 'chat', 'approved', 'error', 'x', 'x')", sid)
engine.prune()
kept = {r["idx"] for r in engine.db.all("SELECT idx FROM segments WHERE session_id = ? AND deleted = 0", sid)}
assert kept == {3, 13} # 90–110 s (revisão com tradução) e 400–410 s (final com erro); o 190–200 s (limpo) saiu
def test_migration_v14_backfills_old_clips(tmp_path):
path = tmp_path / "clipper.db"
conn = sqlite3.connect(path) # banco como estava na v13
for script in db_module.SCHEMA[:13]:
for statement in db_module._split(script):
conn.execute(statement)
conn.execute("PRAGMA user_version = 13")
conn.execute("INSERT INTO sessions (id, platform, kind, url, status, dir, started_at) VALUES (1, 'twitch', 'live', 'u', 'done', '', 'x')")
rows = [(1, "approved", "a.mp4", None), (2, "approved", "b.mp4", '{"lines": []}'), (3, "published", "c.mp4", '{"lines": []}'),
(4, "ready", "d.mp4", None), (5, "published", "e.mp4", None), (6, "candidate", None, None)]
for cid, status, file, translation in rows:
conn.execute("INSERT INTO clips (id, session_id, peak_s, start_s, end_s, score, source, status, file, translation_json,"
" created_at, updated_at) VALUES (?, 1, 1, 0, 10, 1, 'chat', ?, ?, ?, 'x', 'u')", (cid, status, file, translation))
conn.commit()
conn.close()
db = Database(path)
got = {r["id"]: (r["review_dev_json"], r["final_status"], r["final_file"])
for r in db.all("SELECT id, review_dev_json, final_status, final_file FROM clips")}
db.close()
assert got == {
1: ("[]", "ready", "a.mp4"), # sem tradução: o arquivo já era limpo → é o final
2: (None, "pending", None), # com tradução e aprovado: renderiza o final
3: (None, None, None), # publicado (já saiu): só gera final se pedirem (POST /final)
4: ("[]", None, None),
5: ("[]", "ready", "e.mp4"),
6: (None, None, None),
}