Files
CenaForge/clipper/tests/test_render_and_duplicates.py
T
MateuusandClaude Opus 5.5 20a9805d2a Clipador: fontes em inglês (juízes em inglês, painel em português) e monitor de uso da IA
Clipador em inglês (doc/clipador/IDIOMAS.md):
- Fonte en-US: analista, editor e varredura com prompts, glossário de chat e saída em inglês;
  a mesma resposta traz o bloco `pt` (tradução para o painel, sem chamada extra).
- Fala do corte traduzida por frase (clips.translation_json, migração v13) e
  POST /v1/clips/{id}/translate.
- caption.translation (só para desenvolver): português embaixo da legenda em inglês.
- Risada e gírias do chat em inglês na heurística (LMAO, LOL, 💀, 😭, no way, bruh...).
- Idioma do público → código do Whisper (en-US dava 422 no serviço de voz).
- Painel: bloco "Em português" no corte, análise/resumo em PT, título traduzido na lista,
  coluna "Ao vivo" mostra a gravação ativa da fonte.

IA: monitor de uso do limite (ai-usage) e 4º provedor (Antigravity CLI).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 03:07:09 -03:00

191 lines
11 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Bugs de produção de 16–17/11/2026 (sessão 3 do skipnho):
1. corte preso em 'rendering' quando o render levantava uma exceção não prevista (KeyError da legenda);
2. o mesmo momento virando vários cortes (pico 1149 → cortes 42, 47, 49, 51, 52 em cima do 9, já pronto)."""
import json
from datetime import datetime, timedelta, timezone
from pathlib import Path
import app.editor_api as editor_api
import app.worker as worker_module
from app.judge import Judge, Verdict
from app.scoring import Moment
from .test_sources_and_api import env, seed_session # noqa: F401 - fixture reaproveitada
class RecuoJudge(Judge):
"""Juiz falso (nunca chama a CLI): mantém e recua o início para `back_to`, como o juiz real fez no corte 42."""
def __init__(self, back_to: float | None = None):
super().__init__("codex", "fake", Path("."))
self.back_to = back_to
def analyze(self, prompt, images, lang="pt"):
return {"situation": "lag_ou_bug", "confidence": 0.9, "action_start_s": 0, "reaction_end_s": 0, "hook": ""}
def judge(self, prompt, start_s, end_s, images=None, **_limits):
start = self.back_to if self.back_to is not None else start_s
return Verdict(True, 8.0, start, end_s, "O lag colocou ele em três lugares", "legenda", "motivo", "fake")
def add_clip(engine, sid, cid, status, peak, start, end, source="chat", reasons=None):
engine.db.run("INSERT INTO clips (id, session_id, peak_s, start_s, end_s, score, source, reasons_json, status, title, "
"created_at, updated_at) VALUES (?, ?, ?, ?, ?, 5, ?, ?, ?, 't', 'x', ?)",
cid, sid, peak, start, end, source, json.dumps(reasons or {}), status, worker_module.now())
def status(engine, cid):
return engine.db.get("SELECT status FROM clips WHERE id = ?", cid)["status"]
# ---------------------------------------------------------------- bug 1: render
def test_render_that_explodes_becomes_error_and_next_clip_runs(env, monkeypatch): # noqa: F811
_client, engine = env
monkeypatch.setattr(worker_module, "REPO_ROOT", engine.settings.data_dir.parent)
sid = seed_session(engine)
add_clip(engine, sid, 1, "pending", 100, 90, 120)
add_clip(engine, sid, 2, "pending", 300, 290, 320)
def ensure_edit(eng, clip, session):
if clip["id"] == 1:
raise KeyError(2413111138480) # o erro medido na versão intermediária da legenda
return {"project": {}}
monkeypatch.setattr(editor_api, "ensure_edit", ensure_edit)
monkeypatch.setattr(editor_api, "render_clip_edit", lambda *a, **k: None)
engine.render_pending()
first = engine.db.get("SELECT status, error FROM clips WHERE id = 1")
assert first["status"] == "error" and "KeyError" in first["error"]
assert status(engine, 2) == "ready" and engine._rendering == set()
def test_orphan_rendering_goes_back_to_queue_then_error(env, monkeypatch): # noqa: F811
_client, engine = env
sid = seed_session(engine)
old = (datetime.now(timezone.utc) - timedelta(minutes=10)).isoformat(timespec="seconds")
add_clip(engine, sid, 1, "rendering", 100, 90, 120)
add_clip(engine, sid, 2, "rendering", 300, 290, 320) # recente: pode estar renderizando ainda
add_clip(engine, sid, 3, "rendering", 500, 490, 520)
engine.db.run("UPDATE clips SET updated_at = ? WHERE id IN (1, 3)", old)
engine._rendering.add(3) # este processo está renderizando o 3 agora
engine.recover_orphan_renders()
assert [status(engine, c) for c in (1, 2, 3)] == ["pending", "rendering", "rendering"]
for _ in range(worker_module.MAX_RENDER_ATTEMPTS - 1):
engine.db.run("UPDATE clips SET status = 'rendering', updated_at = ? WHERE id = 1", old)
engine.recover_orphan_renders()
assert status(engine, 1) == "error"
# ---------------------------------------------------------------- bug 2: duplicados
def test_judge_backtrack_onto_ready_clip_is_discarded_as_duplicate(env): # noqa: F811
_client, engine = env
sid = seed_session(engine, duration=1300)
add_clip(engine, sid, 9, "ready", 1084, 1045, 1100)
engine.judge = RecuoJudge(back_to=1012)
add_clip(engine, sid, 42, "candidate", 1149, 1095, 1155)
engine.judge_clip(engine.db.get("SELECT * FROM clips WHERE id = 42"))
row = engine.db.get("SELECT status, start_s, judge_json FROM clips WHERE id = 42")
judge = json.loads(row["judge_json"])
assert row["status"] == "discarded" and judge["duplicateOf"] == 9 and "Duplicado do corte 9" in judge["reason"]
# "cortar agora" nunca é bloqueado: só avisa
add_clip(engine, sid, 43, "candidate", 1080, 1040, 1100, source="manual")
engine.judge_clip(engine.db.get("SELECT * FROM clips WHERE id = 43"))
manual = engine.db.get("SELECT status, judge_json FROM clips WHERE id = 43")
assert manual["status"] == "pending" and json.loads(manual["judge_json"])["warning"] == "mesmo momento do corte 9"
def test_repeated_passes_never_recreate_the_same_peak(env, monkeypatch): # noqa: F811
_client, engine = env
sid = seed_session(engine, duration=1300)
engine.db.run("UPDATE sessions SET status = 'stopped' WHERE id = ?", sid)
moment = Moment(peak_s=1149.0, start_s=1095.0, end_s=1155.0, score=5.0, source="chat", reasons={"onsetS": 1142})
monkeypatch.setattr(worker_module, "find_moments", lambda *a, **k: [moment])
assert engine.find_new_clips(engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)) == 1
clip = engine.db.get("SELECT * FROM clips WHERE session_id = ?", sid)
assert json.loads(clip["reasons_json"])["candidateStartS"] == 1095.0 # janela original guardada
# O juiz recuou o corte para 1012–1100: o candidato do mesmo pico já não sobrepõe o trecho final…
engine.db.run("UPDATE clips SET start_s = 1012, end_s = 1100, status = 'discarded' WHERE id = ?", clip["id"])
for _ in range(3): # …mas passadas seguidas não recriam (nem com o corte descartado)
assert engine.find_new_clips(engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)) == 0
assert engine.db.get("SELECT COUNT(*) AS n FROM clips WHERE session_id = ?", sid)["n"] == 1
# Corte antigo sem janela guardada: o pico igual também bloqueia.
engine.db.run("UPDATE clips SET reasons_json = '{}' WHERE id = ?", clip["id"])
assert engine.find_new_clips(engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)) == 0
def test_startup_queue_drops_pending_duplicates(env): # noqa: F811
"""Caso real da sessão 3: 42, 47, 51 e 52 (pico 1149, recuados para 1012–1100) em cima do 9, pronto."""
_client, engine = env
sid = seed_session(engine, duration=9000)
add_clip(engine, sid, 9, "ready", 1084, 1045, 1100)
for cid, start, end in ((42, 1012.2, 1099.68), (47, 1012.2, 1099.68), (51, 1012.86, 1099.68), (52, 1012.86, 1102.86)):
add_clip(engine, sid, cid, "pending", 1149, start, end)
add_clip(engine, sid, 53, "pending", 7850, 7793.484, 7860.114) # momento próprio (o 54 parecido foi descartado)
add_clip(engine, sid, 54, "discarded", 7928, 7792.57, 7852.57)
add_clip(engine, sid, 70, "pending", 1150, 1012, 1100, source="manual") # seu: nunca sai da fila
dropped = engine.discard_pending_duplicates()
assert sorted(dropped) == [(42, 9), (47, 9), (51, 9), (52, 9)]
assert status(engine, 53) == "pending" and status(engine, 70) == "pending"
assert json.loads(engine.db.get("SELECT judge_json FROM clips WHERE id = 47")["judge_json"])["duplicateOf"] == 9
def test_same_moment_rule():
a = {"peak_s": 1084, "start_s": 1045, "end_s": 1100}
assert worker_module.same_moment(a, {"peak_s": 1149, "start_s": 1012, "end_s": 1100}) # cobre 100 % do 9
assert worker_module.same_moment(a, {"peak_s": 1090, "start_s": 1200, "end_s": 1260}) # mesmo pico
# momentos vizinhos de 60–90 s que só encostam não são duplicados
assert not worker_module.same_moment({"peak_s": 1221, "start_s": 1184, "end_s": 1239},
{"peak_s": 1287, "start_s": 1253, "end_s": 1308})
assert not worker_module.same_moment({"peak_s": 100, "start_s": 40, "end_s": 130},
{"peak_s": 170, "start_s": 100, "end_s": 190}) # 30 s de 90 s = 33 %
# ---------------------------------------------------------------- 17/11/2026: "não está gerando os clipes"
def test_rejected_moment_vetoes_judge_backtrack(env): # noqa: F811
"""Caso 61/64 da sessão 3: o juiz recua o candidato (pico 8909) para a cena de um corte que você rejeitou."""
_client, engine = env
sid = seed_session(engine, duration=9000)
add_clip(engine, sid, 61, "rejected", 8816, 8794.2, 8838.0)
add_clip(engine, sid, 64, "candidate", 8909, 8878.0, 8939.1)
engine.judge = RecuoJudge(back_to=8790)
engine.judge_clip(engine.db.get("SELECT * FROM clips WHERE id = 64"))
row = engine.db.get("SELECT status, judge_json FROM clips WHERE id = 64")
judge = json.loads(row["judge_json"])
assert row["status"] == "discarded" and judge["duplicateOf"] == 61 and "que você rejeitou" in judge["reason"]
# descartado pela IA NÃO veta o trecho final de outro momento (só o candidato do mesmo pico)
engine.db.run("UPDATE clips SET status = 'discarded' WHERE id = 61")
add_clip(engine, sid, 65, "candidate", 8909, 8878.0, 8939.1)
engine.judge_clip(engine.db.get("SELECT * FROM clips WHERE id = 65"))
assert status(engine, 65) == "pending"
def test_scan_memory_records_proposals_and_created(env): # noqa: F811
from .test_intel import ScanJudge
_client, engine = env
engine.judge = ScanJudge() # 2 propostas: nota 8 (vira candidato) e nota 3 (barrada)
engine.intel.opts["vision"] = False
sid = seed_session(engine)
engine.db.run("UPDATE sessions SET status = 'recording' WHERE id = ?", sid)
assert engine.intel.scan_session(engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)) == 1
memory = json.loads(engine.db.get("SELECT memory_json FROM sessions WHERE id = ?", sid)["memory_json"])
assert memory[-1]["proposals"] == 2 and memory[-1]["created"] == 1 and memory[-1]["summary"] == "tiroteio na base"
def test_queue_cleanup_uses_the_same_veto_as_the_judge(env): # noqa: F811
"""Fila antes do render: pendente igual a rejeitado ou a apagado-que-estava-pronto sai; igual a descartado pela IA
fica; manual nunca sai."""
_client, engine = env
sid = seed_session(engine, duration=9000)
add_clip(engine, sid, 61, "rejected", 8816, 8794.2, 8838.0)
add_clip(engine, sid, 70, "pending", 8820, 8790.0, 8858.0) # = rejeitado
add_clip(engine, sid, 71, "discarded", 5000, 4970.0, 5030.0)
add_clip(engine, sid, 72, "pending", 5004, 4968.0, 5032.0) # = descartado pela IA: fica
engine.db.run("INSERT INTO deleted_clips (clip_id, session_id, peak_s, start_s, end_s, status, source, deleted_at)"
" VALUES (80, ?, 3000, 2970, 3040, 'ready', 'chat', 'x')", sid)
add_clip(engine, sid, 73, "pending", 3002, 2968.0, 3038.0) # = apagado que estava pronto
add_clip(engine, sid, 74, "pending", 8818, 8790.0, 8850.0, source="manual") # manual: nunca sai
assert sorted(engine.discard_pending_duplicates()) == [(70, 61), (73, 80)]
reasons = {cid: json.loads(engine.db.get("SELECT judge_json FROM clips WHERE id = ?", cid)["judge_json"])["reason"]
for cid in (70, 73)}
assert "que você rejeitou" in reasons[70] and "que você apagou" in reasons[73]
assert status(engine, 72) == "pending" and status(engine, 74) == "pending"