CenaForge: primeira versão pública

Gerador de vídeos narrativos (Godot + FFmpeg), painel Next.js, serviço de voz,
Clipador de lives e Publicador para YouTube, TikTok e Instagram.

Inclui a leitura das visualizações dos posts para o Dashboard e o botão
"Publicar no <rede>" nos cartões das publicações.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-17 16:35:09 -03:00
co-authored by Claude Opus 5.5
commit 84f30bbc2d
484 changed files with 74826 additions and 0 deletions
+190
View File
@@ -0,0 +1,190 @@
"""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):
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"