"""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