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>
191 lines
11 KiB
Python
191 lines
11 KiB
Python
"""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"
|