change test params and files

tests/test_cnn_eye_attention_classifier.py

@@ -1,86 +0,0 @@
-import os
-import sys
-
-import numpy as np
-import pytest
-
-PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-if PROJECT_ROOT not in sys.path:
-    sys.path.insert(0, PROJECT_ROOT)
-
-
-def test_load_eye_classifier_geometric_backend():
-    from models.cnn.eye_attention.classifier import load_eye_classifier, GeometricOnlyClassifier
-
-    clf = load_eye_classifier(path="anything.pt", backend="geometric")
-    # Assert that the returned object is indeed a GeometricOnlyClassifier
-    assert isinstance(clf, GeometricOnlyClassifier)
-    assert clf.name == "geometric"
-    # Assert that it can successfully process a dummy black image and return a score
-    assert clf.predict_score([np.zeros((10, 10, 3), dtype=np.uint8)]) == 1.0
-
-
-def test_load_eye_classifier_none_path_falls_back_to_geometric(capsys):
-    from models.cnn.eye_attention.classifier import load_eye_classifier, GeometricOnlyClassifier
-    # Intentionally request the 'yolo' backend but provide no model path
-    clf = load_eye_classifier(path=None, backend="yolo")
-    assert isinstance(clf, GeometricOnlyClassifier)
-    out = capsys.readouterr().out
-    assert "falling back to geometric" in out
-
-
-def test_load_eye_classifier_extension_overrides_backend(monkeypatch, tmp_path):
-    """
-    .pth -> cnn, .pt -> yolo（但不真的加载 torch/ultralytics）
-    """
-    import models.cnn.eye_attention.classifier as m
-
-    created = {}
-    #Create dummy model classes to mock real deep learning models
-    class DummyCNN(m.EyeClassifier):
-        @property
-        def name(self) -> str:
-            return "dummy_cnn"
-
-        def predict_score(self, crops_bgr):
-            return 0.5
-
-    class DummyYOLO(m.EyeClassifier):
-        @property
-        def name(self) -> str:
-            return "dummy_yolo"
-
-        def predict_score(self, crops_bgr):
-            return 0.7
-    # Intercept the original constructors to return our dummy models
-    def fake_cnn_ctor(path, device="cpu"):
-        created["cnn"] = (path, device)
-        return DummyCNN()
-
-    def fake_yolo_ctor(path, device="cpu"):
-        created["yolo"] = (path, device)
-        return DummyYOLO()
-
-    monkeypatch.setattr(m, "EyeCNNClassifier", fake_cnn_ctor)
-    monkeypatch.setattr(m, "YOLOv11Classifier", fake_yolo_ctor)
-    #Test the '.pth' extension logic
-    pth = tmp_path / "eye_model.pth"
-    pth.write_bytes(b"not a real checkpoint")
-    clf = m.load_eye_classifier(path=str(pth), backend="yolo", device="cpu")
-    assert clf.name == "dummy_cnn"
-    assert "cnn" in created and created["cnn"][0] == str(pth)
-    #Test the '.pt' extension logic
-    pt = tmp_path / "eye_model.pt"
-    pt.write_bytes(b"not a real yolo model")
-    clf2 = m.load_eye_classifier(path=str(pt), backend="cnn", device="cpu")
-    assert clf2.name == "dummy_yolo"
-    assert "yolo" in created and created["yolo"][0] == str(pt)
-
-
-def test_load_eye_classifier_unknown_backend_raises():
-    from models.cnn.eye_attention.classifier import load_eye_classifier
-
-    with pytest.raises(ValueError):
-        # Use an unknown extension to prevent the automatic fallback mechanism
-        load_eye_classifier(path="x.unknownext", backend="unknown")
-

tests/test_cnn_eye_attention_crop.py

@@ -1,84 +0,0 @@
-import os
-import sys
-import types
-import importlib
-
-import numpy as np
-
-PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-if PROJECT_ROOT not in sys.path:
-    sys.path.insert(0, PROJECT_ROOT)
-
-
-def _install_fake_facemesh_module():
-    pkg_models = sys.modules.setdefault("models", types.ModuleType("models"))
-    pkg_pretrained = sys.modules.setdefault(
-        "models.pretrained", types.ModuleType("models.pretrained")
-    )
-    pkg_face_mesh = sys.modules.setdefault(
-        "models.pretrained.face_mesh", types.ModuleType("models.pretrained.face_mesh")
-    )
-    mod = types.ModuleType("models.pretrained.face_mesh.face_mesh")
-
-    class FaceMeshDetector:
-        # get landmarks
-        LEFT_EYE_INDICES = [0, 1, 2]
-        RIGHT_EYE_INDICES = [3, 4, 5]
-
-    mod.FaceMeshDetector = FaceMeshDetector
-
-    sys.modules["models.pretrained.face_mesh.face_mesh"] = mod
-    pkg_models.pretrained = pkg_pretrained
-    pkg_pretrained.face_mesh = pkg_face_mesh
-    pkg_face_mesh.face_mesh = mod
-
-
-def test_bbox_from_landmarks_clamps_to_frame():
-    _install_fake_facemesh_module()
-    crop = importlib.import_module("models.cnn.eye_attention.crop")
-    importlib.reload(crop)
-
-    # normalize the cord
-    landmarks = np.array(
-        [
-            [0.1, 0.1, 0.0],
-            [0.2, 0.1, 0.0],
-            [0.15, 0.2, 0.0],
-            [0.8, 0.1, 0.0],
-            [0.9, 0.1, 0.0],
-            [0.85, 0.2, 0.0],
-        ],
-        dtype=np.float32,
-    )
-
-    x1, y1, x2, y2 = crop._bbox_from_landmarks(landmarks, [0, 1, 2], 100, 50, expand=0.0)
-    assert 0 <= x1 < x2 <= 100
-    assert 0 <= y1 < y2 <= 50
-
-
-def test_extract_eye_crops_returns_expected_shapes():
-    _install_fake_facemesh_module()
-    crop = importlib.import_module("models.cnn.eye_attention.crop")
-    importlib.reload(crop)
-
-    frame = np.zeros((60, 120, 3), dtype=np.uint8)
-    landmarks = np.array(
-        [
-            [0.1, 0.2, 0.0],
-            [0.2, 0.2, 0.0],
-            [0.15, 0.3, 0.0],
-            [0.7, 0.2, 0.0],
-            [0.8, 0.2, 0.0],
-            [0.75, 0.3, 0.0],
-        ],
-        dtype=np.float32,
-    )
-
-    left, right, left_bbox, right_bbox = crop.extract_eye_crops(
-        frame, landmarks, expand=0.0, crop_size=32
-    )
-    assert left.shape == (32, 32, 3)
-    assert right.shape == (32, 32, 3)
-    assert len(left_bbox) == 4
-    assert len(right_bbox) == 4
-

tests/test_pipeline_integration.py

@@ -22,7 +22,7 @@ class _DummyDetector:
 
 
 def test_face_mesh_pipeline_no_face_returns_expected_keys():
-    pipe = FaceMeshPipeline(detector=_DummyDetector(landmarks=None), eye_backend="geometric")
+    pipe = FaceMeshPipeline(detector=_DummyDetector(landmarks=None))
     frame = np.zeros((480, 640, 3), dtype=np.uint8)
     out = pipe.process_frame(frame)
 
@@ -35,7 +35,7 @@ def test_face_mesh_pipeline_no_face_returns_expected_keys():
 
 def test_face_mesh_pipeline_with_fake_landmarks_runs():
     fake_lm = np.zeros((478, 2), dtype=np.float32)
-    pipe = FaceMeshPipeline(detector=_DummyDetector(landmarks=fake_lm), eye_backend="geometric")
+    pipe = FaceMeshPipeline(detector=_DummyDetector(landmarks=fake_lm))
     frame = np.zeros((480, 640, 3), dtype=np.uint8)
     out = pipe.process_frame(frame)