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:
@@ -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
|
||||
Reference in New Issue
Block a user