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>
284 lines
15 KiB
Python
284 lines
15 KiB
Python
"""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),
|
||
}
|