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
+469
View File
@@ -0,0 +1,469 @@
"""Rastreio de reação (face.py) com backends falsos: sem rede, sem modelo, sem FFmpeg."""
import hashlib
import json
import pytest
from app import face as face_mod
from app.db import SCHEMA, Database
from app.face import FaceService, FaceUnavailable, ModelStore
from app.judge import build_prompt
from app.reaction import FaceSample
from tests.test_sources_and_api import KEY, auth, env, seed_session # noqa: F401 - fixture reaproveitada
CAM = {"x": 0.014, "y": 0.4, "w": 0.2, "h": 0.5}
class FakeTracker:
"""Rosto parado no meio do recorte; sorriso alto nos segundos de `laughs`; sem rosto nos de `gone`."""
name = "fake"
def __init__(self, laughs=(), gone=()):
self.laughs, self.gone, self.closed = set(laughs), set(gone), False
def process(self, t, rgb):
if int(t) in self.gone:
return FaceSample(t, False)
smile = 0.9 if int(t) in self.laughs else 0.05 + 0.05 * ((int(t * 6) % 3) / 2)
return FaceSample(t, True, 0.5, 0.4, 0.3, {"mouthSmileLeft": smile, "mouthSmileRight": smile})
def close(self):
self.closed = True
def fake_reader(_ffmpeg, _file, crop_px, out_size, fps=6):
for i in range(30 * fps):
yield i / fps, None
def make_service(engine, laughs=(), gone=(), tracker_factory=None):
service = FaceService(engine, store=object(), tracker_factory=tracker_factory or (lambda _backend=None: FakeTracker(laughs, gone)),
detector_factory=None, reader=fake_reader, grabber=None, sizer=lambda _f: (1280, 720))
engine.face = service
return service
def set_cam(engine, sid, cam=CAM, source="yunet"):
engine.db.run("UPDATE sessions SET cam_json = ? WHERE id = ?",
json.dumps({"hasWebcam": cam is not None, "cam": cam, "source": source}), sid)
def session(engine, sid):
return engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)
# ---------------------------------------------------------------- banco / modelos
def test_migration_creates_face_track(tmp_path):
db = Database(tmp_path / "c.db")
assert db.conn.execute("PRAGMA user_version").fetchone()[0] == len(SCHEMA)
cols = {r["name"] for r in db.all("PRAGMA table_info(face_track)")}
assert {"session_id", "idx", "status", "data_json", "error", "updated_at"} <= cols
def _lock(tmp_path, content: bytes) -> object:
lock = tmp_path / "models.lock.json"
lock.write_text(json.dumps({"dir": "x", "models": [
{"id": "m", "file": "m.onnx", "url": "https://exemplo/m.onnx", "sha256": hashlib.sha256(content).hexdigest()}]}))
return lock
def test_model_store_downloads_lazily_and_checks_sha256(tmp_path):
calls = []
def fetch(url, dest):
calls.append(url)
dest.write_bytes(b"pesos certos")
store = ModelStore(tmp_path / "models", _lock(tmp_path, b"pesos certos"), fetch=fetch)
path = store.path("m")
assert path.read_bytes() == b"pesos certos" and calls == ["https://exemplo/m.onnx"]
assert store.path("m") == path and len(calls) == 1 # conferido uma vez; não baixa de novo
# Arquivo já presente e certo (setup.ps1 baixou): nenhum download.
fresh = ModelStore(tmp_path / "models", _lock(tmp_path, b"pesos certos"), fetch=lambda *_: pytest.fail("baixou"))
assert fresh.path("m") == path
def test_model_store_rejects_wrong_sha256_and_network_errors(tmp_path):
store = ModelStore(tmp_path / "models", _lock(tmp_path, b"pesos certos"),
fetch=lambda _url, dest: dest.write_bytes(b"adulterado"))
with pytest.raises(FaceUnavailable, match="sha256"):
store.path("m")
assert not list((tmp_path / "models").iterdir()) # nem o .part fica
def offline(_url, _dest):
raise OSError("sem rede")
with pytest.raises(FaceUnavailable, match="baixar"):
ModelStore(tmp_path / "models", _lock(tmp_path, b"x"), fetch=offline).path("m")
with pytest.raises(FaceUnavailable):
store.path("nao-existe")
# ---------------------------------------------------------------- laço por bloco
def test_block_is_tracked_in_full_frame_coords(env): # noqa: F811
_client, engine = env
service = make_service(engine, laughs=range(40, 45))
sid = seed_session(engine, duration=120)
assert service.step() is False # câmera ainda não decidida: espera a detecção
set_cam(engine, sid)
for _ in range(4):
assert service.step() is True
assert service.step() is False
rows = engine.db.all("SELECT * FROM face_track WHERE session_id = ? ORDER BY idx", sid)
assert [r["status"] for r in rows] == ["done"] * 4
data = json.loads(rows[1]["data_json"])
assert data["cam"] == CAM and data["backend"] == "fake" and data["frames"] == 180
seconds = data["seconds"]
assert [s["t"] for s in seconds] == list(range(30, 60)) # bloco 30–60 s, sem repetir segundos do vizinho
crop = face_mod.expand(CAM)
assert seconds[0]["cx"] == pytest.approx(crop["x"] + 0.5 * crop["w"], abs=1e-3) # quadro inteiro, não recorte
assert seconds[0]["size"] == pytest.approx(0.3 * crop["h"], abs=1e-3)
assert service.tracked_until(sid) == 120
dense = service.dense(sid, 0, 120)
assert len(dense) == 120 and dense[42].smile == pytest.approx(0.9)
def test_no_cam_and_backend_unavailable(env): # noqa: F811
_client, engine = env
service = make_service(engine)
sid = seed_session(engine, duration=60)
set_cam(engine, sid, cam=None) # detecção rodou e não achou câmera
assert service.step() and service.step()
assert {r["status"] for r in engine.db.all("SELECT status FROM face_track WHERE session_id = ?", sid)} == {"no_cam"}
assert service.for_scoring(session(engine, sid), 0, 60) == (None, 0.0) # pontuação segue como antes
# Backend sem modelo/biblioteca: não marca o bloco (tenta de novo depois).
sid2 = seed_session(engine, duration=60)
set_cam(engine, sid2)
def broken(_backend=None):
raise FaceUnavailable("sem modelo")
service._tracker_factory = broken
with pytest.raises(FaceUnavailable):
service.step()
assert engine.db.get("SELECT COUNT(*) AS n FROM face_track WHERE session_id = ?", sid2)["n"] == 0
def test_block_error_is_recorded(env): # noqa: F811
_client, engine = env
service = make_service(engine)
sid = seed_session(engine, duration=30)
set_cam(engine, sid)
def failing(*_a, **_k):
raise face_mod.FaceError("bloco apagado")
yield # pragma: no cover
service._reader = failing
assert service.step()
row = engine.db.get("SELECT * FROM face_track WHERE session_id = ?", sid)
assert row["status"] == "error" and "apagado" in row["error"]
def test_camera_change_resets_the_track(env): # noqa: F811
_client, engine = env
service = make_service(engine)
sid = seed_session(engine, duration=60)
set_cam(engine, sid)
service.step()
service.step()
assert engine.db.get("SELECT COUNT(*) AS n FROM face_track")["n"] == 2
# Você corrige a câmera no layout da sessão: a série é apagada e refeita com o retângulo novo.
new_cam = {"x": 0.7, "y": 0.6, "w": 0.25, "h": 0.35}
engine.db.run("UPDATE sessions SET settings_json = ? WHERE id = ?", json.dumps({"layout": {"cam": new_cam}}), sid)
assert service.cam_for(session(engine, sid)) == (new_cam, "manual", True)
service.step()
rows = engine.db.all("SELECT data_json FROM face_track WHERE session_id = ?", sid)
assert len(rows) == 1 and json.loads(rows[0]["data_json"])["cam"] == new_cam
def test_find_new_clips_waits_for_face_at_most_two_blocks(env): # noqa: F811
_client, engine = env
service = make_service(engine, laughs=range(300, 306))
sid = seed_session(engine) # pico do chat em 300 s, 600 s gravados, transcrição toda pronta
set_cam(engine, sid)
for _ in range(9): # rosto até 270 s: 11 blocos atrás da transcrição → não segura o corte
service.step()
assert service.must_wait(330, 270, 600) is False
assert service.must_wait(330, 270, 320) is True # rosto 1–2 blocos atrás: espera
while service.step():
pass
assert engine.find_new_clips(session(engine, sid)) == 1
clip = engine.db.get("SELECT * FROM clips WHERE session_id = ?", sid)
reasons = json.loads(clip["reasons_json"])
assert clip["source"] == "chat" and reasons["face"]["label"] == "risada" and 300 <= reasons["face"]["peakS"] <= 306
def test_live_clip_waits_while_face_is_one_block_behind(env): # noqa: F811
_client, engine = env
service = make_service(engine, laughs=range(300, 306))
sid = seed_session(engine)
set_cam(engine, sid)
for _ in range(10): # rosto até 300 s; o corte (≈ 286–306 s + folga) precisa até ~318 s
service.step()
engine.db.run("UPDATE segments SET analyzed = 0 WHERE session_id = ? AND idx >= 12", sid) # transcrição até 360 s
assert engine.find_new_clips(session(engine, sid)) == 0
service.step()
assert engine.find_new_clips(session(engine, sid)) == 1
def test_judge_prompt_gets_face_line(env): # noqa: F811
_client, engine = env
service = make_service(engine, laughs=range(300, 306))
sid = seed_session(engine)
set_cam(engine, sid)
while service.step():
pass
text = service.summary(session(engine, sid), 280, 330)
assert text.startswith("risada forte em 30")
prompt = build_prompt("x", "twitch", 290, 320, 305, [], [], {}, face=text)
assert "Rosto do streamer" in prompt and "risada forte em 30" in prompt
assert "Rosto do streamer" not in build_prompt("x", "twitch", 290, 320, 305, [], [], {})
engine.intel.opts["faceTrack"] = False
assert service.summary(session(engine, sid), 280, 330) == ""
class FakeOsfTracker(FakeTracker):
"""Plano B: rosto e posição, sem blendshapes (como o OpenSeeFace de verdade)."""
name = "openseeface"
def process(self, t, rgb):
return FaceSample(t, True, 0.5, 0.4, 0.3, {})
def test_openseeface_series_does_not_break_signal_nor_lie_to_the_judge(env): # noqa: F811
_client, engine = env
service = make_service(engine, tracker_factory=lambda _backend=None: FakeOsfTracker())
sid = seed_session(engine)
set_cam(engine, sid)
while service.step():
pass
view = service.view(session(engine, sid), 0, None)
assert view["blocks"]["done"] > 0 and view["moments"] == []
assert all(r.get("signal", 0) == 0 for r in view["seconds"])
face, _until = service.for_scoring(session(engine, sid), 0, 300)
from app.scoring import find_moments
assert find_moments(300, [], [None] * 300, [], face=face) == []
# Sem expressões, "sem reação marcante" seria mentira para o analista: a linha não vai.
assert service.summary(session(engine, sid), 100, 200) == ""
# ---------------------------------------------------------------- câmera local
class FakeDetector:
def detect(self, bgr):
return [(18.0, 363.0, 85.0, 109.0, 0.92)]
class FakeFrame:
shape = (720, 1280, 3)
def test_detect_cam_local_first_without_ai(env): # noqa: F811
_client, engine = env
service = make_service(engine)
service._detector_factory = FakeDetector
service._grabber = lambda *_a, **_k: FakeFrame()
engine.judge.provider = "off" # sem IA nenhuma
sid = seed_session(engine)
result = engine.intel.detect_cam(sid, apply=True)
assert result["hasWebcam"] and result["source"] == "yunet" and result["frames"] == 12
cam = result["cam"]
assert cam["y"] < 363 / 720 - 0.5 * 109 / 720 # folga acima da testa
saved = json.loads(session(engine, sid)["settings_json"])
assert saved["layout"]["cam"] == cam # sem canal: vale para a sessão
assert json.loads(session(engine, sid)["cam_json"])["source"] == "yunet"
def test_detect_cam_no_face_falls_back_to_ai_or_records_retry(env): # noqa: F811
_client, engine = env
service = make_service(engine)
service._detector_factory = lambda: type("D", (), {"detect": lambda self, bgr: []})()
service._grabber = lambda *_a, **_k: FakeFrame()
sid = seed_session(engine)
engine.db.run("UPDATE sessions SET status = 'recording' WHERE id = ?", sid)
calls = []
def ai_cam(images):
calls.append(len(images))
return {"has_webcam": True, "x": 0.01, "y": 0.5, "w": 0.2, "h": 0.4, "game_on_screen": ""}
engine.judge.detect_cam = ai_cam
engine.intel.frames = lambda _s, times, _tag: [(t, f"f{int(t)}.jpg") for t in times]
engine.intel.e.rel = lambda p: str(p)
result = engine.intel.detect_cam(sid)
assert result["source"] == "ai" and calls == [3] # local sem rosto → IA (ligada, com visão)
# Sem IA: fica registrado "sem câmera" e tenta de novo daqui a 5 min de gravação.
engine.judge.provider = "off"
engine.db.run("UPDATE sessions SET cam_json = NULL WHERE id = ?", sid)
engine.intel.maybe_detect_cam(session(engine, sid))
saved = json.loads(session(engine, sid)["cam_json"])
assert saved["hasWebcam"] is False and saved["source"] == "yunet" and saved["retryAfterS"] == 900
# ---------------------------------------------------------------- API
def test_face_api_and_reset(env): # noqa: F811
client, engine = env
service = make_service(engine, laughs=range(300, 306))
sid = seed_session(engine)
set_cam(engine, sid)
while service.step():
pass
r = client.get(f"/v1/sessions/{sid}/face?from=290&to=320", headers=auth())
assert r.status_code == 200
body = r.json()
assert body["cam"] == CAM and body["camSource"] == "yunet" and body["coords"] == "frame"
assert body["blocks"]["done"] == 20 and body["trackedUntilS"] == 600
assert [s["t"] for s in body["seconds"]][:2] == [290, 291] and body["seconds"][-1]["t"] == 319
assert 0 < body["seconds"][0]["cx"] < CAM["x"] + CAM["w"] and "signal" in body["seconds"][0]
assert [m["label"] for m in body["moments"]] == ["risada"]
assert client.get(f"/v1/sessions/{sid}/face?from=50&to=10", headers=auth()).status_code == 400
assert client.get("/v1/sessions/999/face", headers=auth()).status_code == 404
r = client.post(f"/v1/sessions/{sid}/face/reset", headers=auth())
assert r.status_code == 200 and r.json() == {"ok": True, "deleted": 20, "scheduled": False}
assert client.get(f"/v1/sessions/{sid}/face", headers=auth()).json()["blocks"]["done"] == 0
def test_face_track_option_persists(env): # noqa: F811
client, engine = env
r = client.put("/v1/judge", json={"provider": "codex", "model": "", "minScore": 6, "faceTrack": False}, headers=auth())
assert r.status_code == 200 and r.json()["options"]["faceTrack"] is False
assert engine.face.enabled is False
saved = {r["key"]: r["value"] for r in engine.db.all("SELECT * FROM settings")}
assert saved["opt_faceTrack"] == "false"
# ---------------------------------------------------------------- correções da revisão (médios)
import sys # noqa: E402
import time # noqa: E402
def _fake_ffmpeg(code: str) -> list[str]:
"""Processo falso no lugar do FFmpeg (Python sem shell): `code` escreve quadros/stderr e sai."""
return [sys.executable, "-c", code]
def test_read_frames_ok_and_nonzero_exit_after_some_frames():
frame = 4 * 2 * 3
ok = face_mod._read_frames(_fake_ffmpeg(f"import sys; sys.stdout.buffer.write(b'x' * {frame * 3})"), (4, 2), 6, 30, "b")
assert len(list(ok)) == 3
# FFmpeg que cai no meio (2 quadros e código 1): erro, não bloco truncado gravado como completo.
code = f"import sys; sys.stdout.buffer.write(b'x' * {frame * 2}); sys.stdout.flush(); sys.exit(1)"
with pytest.raises(face_mod.FaceError, match="código 1 depois de 2 quadros"):
list(face_mod._read_frames(_fake_ffmpeg(code), (4, 2), 6, 30, "b"))
def test_read_frames_drains_big_stderr_and_has_a_deadline():
# ~360 KB no stderr (mais que o buffer do pipe) não trava; o erro traz a última linha.
code = "import sys; sys.stderr.write('ruido\\n' * 60000 + 'fim do erro\\n'); sys.exit(2)"
started = time.perf_counter()
with pytest.raises(face_mod.FaceError, match="fim do erro"):
list(face_mod._read_frames(_fake_ffmpeg(code), (4, 2), 6, 30, "b"))
# Processo que não entrega nada nem sai: morto pelo prazo.
with pytest.raises(face_mod.FaceError, match="passou de 1 s"):
list(face_mod._read_frames(_fake_ffmpeg("import time; time.sleep(60)"), (4, 2), 6, 1, "b"))
assert time.perf_counter() - started < 20
def test_truncated_block_is_error_not_done(env): # noqa: F811
_client, engine = env
service = make_service(engine)
sid = seed_session(engine, duration=30)
set_cam(engine, sid)
def short(*_a, **_k):
for i in range(60): # 10 s de 30
yield i / 6, None
service._reader = short
assert service.step()
row = engine.db.get("SELECT * FROM face_track WHERE session_id = ?", sid)
assert row["status"] == "error" and "truncado" in row["error"]
def test_reset_does_not_block_while_a_block_is_running(env): # noqa: F811
client, engine = env
service = make_service(engine)
sid = seed_session(engine, duration=60)
set_cam(engine, sid)
service.step()
service._busy.acquire() # um bloco "em andamento"
try:
started = time.perf_counter()
r = client.post(f"/v1/sessions/{sid}/face/reset", headers=auth())
assert time.perf_counter() - started < 3
assert r.status_code == 202 and r.json()["scheduled"] is True
finally:
service._busy.release()
assert engine.db.get("SELECT COUNT(*) AS n FROM face_track WHERE session_id = ?", sid)["n"] == 1
service.step() # o laço aplica o reset agendado antes do próximo bloco
rows = engine.db.all("SELECT idx FROM face_track WHERE session_id = ?", sid)
assert [r["idx"] for r in rows] == [0] # apagou e refez só o primeiro
def test_backend_is_fixed_per_session():
seen = []
class Store:
def path(self, model_id):
if model_id == "face_landmarker":
raise FaceUnavailable("sem mediapipe")
seen.append(model_id)
raise FaceUnavailable("sem pesos do plano B")
service = FaceService.__new__(FaceService)
service.store = Store()
# Sessão que começou no MediaPipe: espera ele voltar, não troca para o OpenSeeFace no meio.
with pytest.raises(FaceUnavailable, match="sem mediapipe"):
service._default_tracker("mediapipe")
assert seen == []
# Sessão nova: o plano B só entra aqui.
with pytest.raises(FaceUnavailable, match="plano B"):
service._default_tracker(None)
assert seen == ["osf_landmarks"]
def test_session_backend_comes_from_the_series(env): # noqa: F811
_client, engine = env
asked = []
def factory(backend=None):
asked.append(backend)
return FakeTracker()
service = make_service(engine, tracker_factory=factory)
sid = seed_session(engine, duration=60)
set_cam(engine, sid)
service.step()
service.step()
assert asked == [None, "fake"]
def test_crop_geometry_never_leaves_the_frame():
for crop in ({"x": 0.95, "y": 0.9, "w": 0.3, "h": 0.4}, {"x": -0.1, "y": -0.2, "w": 1.5, "h": 1.5},
{"x": 0.999, "y": 0.999, "w": 0.01, "h": 0.01}):
(x, y, w, h), (ow, oh) = face_mod.crop_geometry(crop, (1280, 720))
assert 0 <= x and 0 <= y and x + w <= 1280 and y + h <= 720 and w >= 2 and h >= 2
assert x % 2 == y % 2 == w % 2 == h % 2 == 0 and ow >= 2 and oh >= 2
def test_transient_detector_failure_is_not_saved_as_no_cam(env): # noqa: F811
_client, engine = env
service = make_service(engine)
def unavailable():
raise FaceUnavailable("download do YuNet falhou")
service._detector_factory = unavailable
engine.judge.provider = "off"
sid = seed_session(engine) # sessão 'processing' (não grava)
engine.intel.maybe_detect_cam(session(engine, sid))
assert session(engine, sid)["cam_json"] is None # nada permanente
assert engine.intel._cam_retry_at[sid] > time.time()
engine.intel.maybe_detect_cam(session(engine, sid)) # dentro da espera: nem tenta
# Falha não passageira (poucos quadros) em sessão parada: grava com nova tentativa pelo relógio.
engine.intel._cam_retry_at.clear()
service._detector_factory = FakeDetector
service._grabber = lambda *_a, **_k: None
engine.intel.maybe_detect_cam(session(engine, sid))
saved = json.loads(session(engine, sid)["cam_json"])
assert saved["hasWebcam"] is False and saved["retryAt"] > time.time() and saved["attempts"] == 1
engine.db.run("UPDATE sessions SET cam_json = ? WHERE id = ?", json.dumps(saved | {"retryAt": 0}), sid)
service._grabber = lambda *_a, **_k: FakeFrame()
engine.intel.maybe_detect_cam(session(engine, sid))
assert json.loads(session(engine, sid)["cam_json"])["hasWebcam"] is True