Files
MateuusandClaude Opus 5.5 84f30bbc2d 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>
2026-11-17 16:35:09 -03:00

470 lines
20 KiB
Python
Raw Permalink 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.
"""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