Add Engine helpers for model path detection

Introduce Engine helpers (is_pytorch_model_path, is_tensorflow_model_dir_path) and centralize model-file/TF-dir detection. Replace the old is_model_file usage with these helpers across settings_store and main_window, fixing a bug in suffix checking and ensuring .pb TensorFlow models are validated via their parent directory. Remove legacy is_model_file from utils. Also update camera UI to expect dlg.request_scan_cancel instead of _on_scan_cancel, refine scan-cancel test synchronization, and add/adjust unit tests to cover the new Engine detection logic.

Author: C-Achard

dlclivegui/gui/camera_config/ui_blocks.py

@@ -193,9 +193,8 @@ def build_available_cameras_group(dlg: CameraConfigDialog) -> QGroupBox:
     dlg.scan_cancel_btn.setIcon(dlg.style().standardIcon(QStyle.StandardPixmap.SP_BrowserStop))
     dlg.scan_cancel_btn.setVisible(False)
 
-    # The original UI block connects cancel here; preserve that.
-    # dlg must provide _on_scan_cancel
-    if hasattr(dlg, "_on_scan_cancel"):
+    # dlg must provide request_scan_cancel()
+    if hasattr(dlg, "request_scan_cancel"):
         dlg.scan_cancel_btn.clicked.connect(dlg.request_scan_cancel)  # type: ignore[attr-defined]
 
     available_layout.addWidget(dlg.scan_cancel_btn)

dlclivegui/gui/main_window.py

@@ -876,7 +876,7 @@ def _parse_json(self, value: str) -> dict:
 
     def _dlc_settings_from_ui(self) -> DLCProcessorSettings:
         model_path = self.model_path_edit.text().strip()
-        if Path(model_path).exists() and Path(model_path).suffix in (".pb"):
+        if Path(model_path).exists() and Path(model_path).suffix == ".pb":
             # IMPORTANT NOTE: DLClive expects a directory for TensorFlow models,
             # so if user selects a .pb file, we should pass the parent directory to DLCLive
             model_path = str(Path(model_path).parent)
@@ -1004,7 +1004,10 @@ def _action_browse_model(self) -> None:
                 return
 
             try:
-                DLCLiveProcessor.get_model_backend(str(file_path))
+                if file_path.suffix == ".pb":
+                    # For TensorFlow, DLCLive expects a directory, so we pass the parent directory for validation
+                    model_check_path = file_path.parent
+                DLCLiveProcessor.get_model_backend(str(model_check_path))
             except FileNotFoundError as e:
                 QMessageBox.warning(self, "Model selection error", str(e))
                 return

dlclivegui/temp/engine.py

@@ -2,10 +2,28 @@
 from pathlib import Path
 
 
+# TODO @C-Achard decide if this moves to utils,
+# or if we update dlclive.Engine to have these methods and use that instead of a separate enum here.
+# The latter would be more cohesive but also creates a dependency from utils to dlclive,
+# pending release of dlclive
 class Engine(Enum):
     TENSORFLOW = "tensorflow"
     PYTORCH = "pytorch"
 
+    @staticmethod
+    def is_pytorch_model_path(model_path: str | Path) -> bool:
+        path = Path(model_path)
+        return path.is_file() and path.suffix.lower() in (".pt", ".pth")
+
+    @staticmethod
+    def is_tensorflow_model_dir_path(model_path: str | Path) -> bool:
+        path = Path(model_path)
+        if not path.is_dir():
+            return False
+        has_cfg = (path / "pose_cfg.yaml").is_file()
+        has_pb = any(p.suffix.lower() == ".pb" for p in path.glob("*.pb"))
+        return has_cfg and has_pb
+
     @classmethod
     def from_model_type(cls, model_type: str) -> "Engine":
         if model_type.lower() == "pytorch":
@@ -23,13 +41,10 @@ def from_model_path(cls, model_path: str | Path) -> "Engine":
             raise FileNotFoundError(f"Model path does not exist: {model_path}")
 
         if path.is_dir():
-            has_cfg = (path / "pose_cfg.yaml").is_file()
-            # has_cfg is DLClive specific and is considered a requirement for TF live models.
-            has_pb = any(p.suffix == ".pb" for p in path.glob("*.pb"))
-            if has_cfg and has_pb:
+            if cls.is_tensorflow_model_dir_path(path):
                 return cls.TENSORFLOW
         elif path.is_file():
-            if path.suffix in (".pt", ".pth"):
+            if cls.is_pytorch_model_path(path):
                 return cls.PYTORCH
 
         raise ValueError(f"Could not determine engine from model path: {model_path}")

dlclivegui/utils/settings_store.py

@@ -7,7 +7,7 @@
 from PySide6.QtCore import QSettings
 
 from ..config import ApplicationSettings
-from .utils import is_model_file
+from ..temp import Engine  # type: ignore # TODO use main package enum when released
 
 logger = logging.getLogger(__name__)
 
@@ -132,7 +132,7 @@ def load_last(self) -> str | None:
         try:
             pp = Path(path)
             # Accept a valid model *file*
-            if pp.is_file() and is_model_file(str(pp)):
+            if pp.is_file() and (Engine.is_pytorch_model_path(pp) or Engine.is_tensorflow_model_dir_path(pp.parent)):
                 return str(pp)
         except Exception:
             logger.debug("Last model path not valid/usable: %s", path)
@@ -172,10 +172,12 @@ def save_if_valid(self, path: str) -> None:
                 self._settings.setValue("dlc/last_model_dir", model_dir_norm)
 
             # Persist model path if it is a valid model file, or a TF model directory
-            if p.is_file() and is_model_file(str(p)):
+            if Engine.is_pytorch_model_path(p):
                 self._settings.setValue("dlc/last_model_path", str(p))
-            elif p.is_dir() and self._looks_like_tf_model_dir(p):
+            elif p.parent.is_dir() and Engine.is_tensorflow_model_dir_path(p.parent):
                 self._settings.setValue("dlc/last_model_path", str(p))
+            # elif p.is_dir() and Engine.is_tensorflow_model_dir_path(p):
+            #     self._settings.setValue("dlc/last_model_path", str(p))
 
         except Exception:
             logger.debug("Failed to save model path: %s", path, exc_info=True)
@@ -204,9 +206,9 @@ def resolve(self, config_path: str | None) -> str:
         if cfg:
             try:
                 p = Path(cfg)
-                if p.is_file() and is_model_file(cfg):
+                if p.is_file() and Engine.is_pytorch_model_path(p):
                     return cfg
-                if p.is_dir() and self._looks_like_tf_model_dir(p):
+                if p.is_dir() and Engine.is_tensorflow_model_dir_path(p):
                     return cfg
             except Exception:
                 logger.debug("Config path not usable: %s", cfg)

dlclivegui/utils/utils.py

@@ -8,18 +8,9 @@
 from datetime import datetime
 from pathlib import Path
 
-SUPPORTED_MODELS = [".pt", ".pth", ".pb"]
 _INVALID_CHARS = re.compile(r"[^A-Za-z0-9._-]+")
 
 
-def is_model_file(file_path: Path | str) -> bool:
-    if not isinstance(file_path, Path):
-        file_path = Path(file_path)
-    if not file_path.is_file():
-        return False
-    return file_path.suffix.lower() in SUPPORTED_MODELS
-
-
 def sanitize_name(name: str, *, fallback: str = "session") -> str:
     """Make a user-provided string safe for filesystem paths."""
     name = (name or "").strip()

tests/gui/camera_config/test_cam_dialog_e2e.py

@@ -304,11 +304,13 @@ def slow_detect(backend, max_devices=10, should_cancel=None, progress_cb=None, *
 
     qtbot.mouseClick(dialog.scan_cancel_btn, Qt.LeftButton)
 
+    # scan_finished = UI stable, not necessarily worker fully stopped / controls unlocked
     with qtbot.waitSignal(dialog.scan_finished, timeout=3000):
         pass
 
-    assert dialog.refresh_btn.isEnabled()
-    assert dialog.backend_combo.isEnabled()
+    # Wait until scan controls are unlocked (worker finished)
+    qtbot.waitUntil(lambda: dialog.refresh_btn.isEnabled(), timeout=3000)
+    qtbot.waitUntil(lambda: dialog.backend_combo.isEnabled(), timeout=3000)
 
 
 @pytest.mark.gui

tests/utils/test_settings_store.py

@@ -235,19 +235,21 @@ def test_model_path_store_resolve_prefers_config_path_when_valid(tmp_path: Path)
     assert mps.resolve(str(model)) == str(model)
 
 
-def test_model_path_store_resolve_falls_back_to_persisted(tmp_path: Path):
+def test_model_path_store_resolve_falls_back_to_persisted_tf_dir(tmp_path: Path):
     settings = InMemoryQSettings()
     mps = store.ModelPathStore(settings=settings)
 
-    persisted = tmp_path / "persisted.pb"
-    persisted.write_text("x")
-    settings.setValue("dlc/last_model_path", str(persisted))
+    tf_dir = tmp_path / "tf_model"
+    tf_dir.mkdir()
+    (tf_dir / "pose_cfg.yaml").write_text("cfg: 1\n")
+    (tf_dir / "graph.pb").write_text("pb")
+
+    settings.setValue("dlc/last_model_path", str(tf_dir / "graph.pb"))
 
-    # invalid config path
     bad = tmp_path / "notamodel.onnx"
     bad.write_text("x")
 
-    assert mps.resolve(str(bad)) == str(persisted)
+    assert mps.resolve(str(bad)) == str(tf_dir / "graph.pb")
 
 
 def test_model_path_store_resolve_returns_empty_when_nothing_valid(tmp_path: Path):

tests/utils/test_utils.py

@@ -1,41 +1,138 @@
+from __future__ import annotations
+
 from pathlib import Path
 
 import pytest
 
 import dlclivegui.utils.utils as u
+from dlclivegui.temp.engine import Engine  # e.g. dlclivegui/utils/engine.py
 
 pytestmark = pytest.mark.unit
 
 
+# NOTE @C-Achard: These tests are currently in test_utils.py for convenience,
+# but we may want to use dlclive.Engine directly
+# and possibly move these tests to dlclive's test suite
 # -----------------------------
-# is_model_file
+# Engine.from_model_type
 # -----------------------------
-@pytest.mark.unit
-def test_is_model_file_true_for_supported_extensions(tmp_path: Path):
-    for ext in [".pt", ".pth", ".pb"]:
-        p = tmp_path / f"model{ext}"
-        p.write_text("x")
-        assert u.is_model_file(p) is True
-        assert u.is_model_file(str(p)) is True  # also accepts str
+@pytest.mark.parametrize(
+    "inp, expected",
+    [
+        ("pytorch", Engine.PYTORCH),
+        ("PYTORCH", Engine.PYTORCH),
+        ("tensorflow", Engine.TENSORFLOW),
+        ("TensorFlow", Engine.TENSORFLOW),
+        ("base", Engine.TENSORFLOW),
+        ("tensorrt", Engine.TENSORFLOW),
+        ("lite", Engine.TENSORFLOW),
+    ],
+)
+def test_engine_from_model_type(inp: str, expected: Engine):
+    assert Engine.from_model_type(inp) == expected
+
+
+def test_engine_from_model_type_unknown():
+    with pytest.raises(ValueError):
+        Engine.from_model_type("onnx")
 
-    # case-insensitive
-    p2 = tmp_path / "MODEL.PT"
-    p2.write_text("x")
-    assert u.is_model_file(p2) is True
 
+# -----------------------------
+# Engine.is_pytorch_model_path
+# -----------------------------
+@pytest.mark.parametrize("ext", [".pt", ".pth"])
+def test_engine_is_pytorch_model_path_true(tmp_path: Path, ext: str):
+    p = tmp_path / f"model{ext}"
+    p.write_text("x")
+    assert Engine.is_pytorch_model_path(p) is True
+    assert Engine.is_pytorch_model_path(str(p)) is True
 
-@pytest.mark.unit
-def test_is_model_file_false_for_missing_or_dir(tmp_path: Path):
-    missing = tmp_path / "missing.pt"
-    assert u.is_model_file(missing) is False
 
+def test_engine_is_pytorch_model_path_false_for_missing(tmp_path: Path):
+    p = tmp_path / "missing.pt"
+    assert Engine.is_pytorch_model_path(p) is False
+
+
+def test_engine_is_pytorch_model_path_false_for_dir(tmp_path: Path):
     d = tmp_path / "model.pt"
     d.mkdir()
-    assert u.is_model_file(d) is False
+    assert Engine.is_pytorch_model_path(d) is False
+
+
+def test_engine_is_pytorch_model_path_case_insensitive(tmp_path: Path):
+    # only include if you applied the .lower() patch
+    p = tmp_path / "MODEL.PT"
+    p.write_text("x")
+    assert Engine.is_pytorch_model_path(p) is True
+
+
+# -----------------------------
+# Engine.is_tensorflow_model_dir_path
+# -----------------------------
+def _make_tf_dir(tmp_path: Path, *, with_cfg: bool = True, with_pb: bool = True, pb_name: str = "graph.pb") -> Path:
+    d = tmp_path / "tf_model"
+    d.mkdir()
+    if with_cfg:
+        (d / "pose_cfg.yaml").write_text("cfg: 1\n")
+    if with_pb:
+        (d / pb_name).write_text("pbdata")
+    return d
+
+
+def test_engine_is_tensorflow_model_dir_path_true(tmp_path: Path):
+    d = _make_tf_dir(tmp_path, with_cfg=True, with_pb=True)
+    assert Engine.is_tensorflow_model_dir_path(d) is True
+    assert Engine.is_tensorflow_model_dir_path(str(d)) is True
+
+
+def test_engine_is_tensorflow_model_dir_path_false_missing_cfg(tmp_path: Path):
+    d = _make_tf_dir(tmp_path, with_cfg=False, with_pb=True)
+    assert Engine.is_tensorflow_model_dir_path(d) is False
+
+
+def test_engine_is_tensorflow_model_dir_path_false_missing_pb(tmp_path: Path):
+    d = _make_tf_dir(tmp_path, with_cfg=True, with_pb=False)
+    assert Engine.is_tensorflow_model_dir_path(d) is False
+
+
+def test_engine_is_tensorflow_model_dir_path_case_insensitive_pb(tmp_path: Path):
+    # only include if you applied the .lower() patch for pb suffix
+    d = _make_tf_dir(tmp_path, with_cfg=True, with_pb=True, pb_name="GRAPH.PB")
+    assert Engine.is_tensorflow_model_dir_path(d) is True
+
+
+# -----------------------------
+# Engine.from_model_path
+# -----------------------------
+def test_engine_from_model_path_missing_raises(tmp_path: Path):
+    missing = tmp_path / "does_not_exist.pt"
+    with pytest.raises(FileNotFoundError):
+        Engine.from_model_path(missing)
+
+
+def test_engine_from_model_path_pytorch_file(tmp_path: Path):
+    p = tmp_path / "net.pth"
+    p.write_text("x")
+    assert Engine.from_model_path(p) == Engine.PYTORCH
+
+
+def test_engine_from_model_path_tensorflow_dir(tmp_path: Path):
+    d = _make_tf_dir(tmp_path, with_cfg=True, with_pb=True)
+    assert Engine.from_model_path(d) == Engine.TENSORFLOW
+
+
+def test_engine_from_model_path_dir_not_tf_raises(tmp_path: Path):
+    d = tmp_path / "some_dir"
+    d.mkdir()
+    with pytest.raises(ValueError):
+        Engine.from_model_path(d)
+
 
-    bad = tmp_path / "model.onnx"
-    bad.write_text("x")
-    assert u.is_model_file(bad) is False
+def test_engine_from_model_path_file_not_pytorch_raises(tmp_path: Path):
+    p = tmp_path / "model.pb"
+    p.write_text("x")  # PB file alone is not a TF dir
+    with pytest.raises(ValueError):
+        Engine.from_model_path(p)
 
 
 # -----------------------------