Fix queue wait timing and harden POET tests

Updated pose processing to stop the loop on queue timeout and compute `queue_wait_time` from enqueue timestamp (`enq`) instead of local get-call timing, improving latency accounting. Expanded POET tests by introducing a reusable `urlopen` stub fixture, validating request/timeout behavior, asserting no `finished` signal on download failure, checking error-free successful downloads, and covering `skeleton_id` metadata in empty-detection pose packets.

Author: C-Achard

dlclivegui/services/inference/processor.py

@@ -266,14 +266,21 @@ def _worker_loop(self, init_frame: np.ndarray, init_timestamp: float) -> None:
                         continue
 
             try:
-                wait_start = time.perf_counter()
-                frame, ts, enq = self._queue.get(timeout=0.05)
-                qwait = time.perf_counter() - wait_start
+                frame, ts, enq = self._queue.get(
+                    timeout=0.05,
+                )
             except queue.Empty:
-                continue
+                break
+            else:
+                queue_wait_time = max(0.0, time.perf_counter() - enq)
 
             try:
-                self._process_frame(frame, ts, enq, queue_wait_time=qwait)
+                self._process_frame(
+                    frame,
+                    ts,
+                    enq,
+                    queue_wait_time=queue_wait_time,
+                )
             except Exception as exc:
                 logger.exception("Pose inference failed", exc_info=exc)
                 self.error.emit(str(exc))

tests/services/inference/models/test_poet.py

@@ -1,5 +1,10 @@
+from __future__ import annotations
+
 import urllib.request
+from collections.abc import Callable
+from dataclasses import dataclass, field
 from io import BytesIO
+from typing import Any
 
 import numpy as np
 import pytest
@@ -11,7 +16,93 @@
     POET_SKELETON_ID,
     POETBackend,
 )
-from dlclivegui.services.inference.models.poet.weights import WeightsDownloadWorker
+from dlclivegui.services.inference.models.poet.weights import (
+    WeightsDownloadWorker,
+)
+
+TEST_WEIGHTS_URL = "https://example.invalid/weights"
+
+
+class FakeResponse(BytesIO):
+    """In-memory response implementing the context-manager protocol."""
+
+    def __init__(self, content: bytes) -> None:
+        super().__init__(content)
+        self.length = len(content)
+
+    def __enter__(self) -> FakeResponse:
+        return self
+
+    def __exit__(
+        self,
+        exc_type,
+        exc_value,
+        traceback,
+    ) -> None:
+        self.close()
+
+
+@dataclass
+class UrlopenStub:
+    """Configurable replacement for urllib.request.urlopen."""
+
+    content: bytes = b""
+    error: Exception | None = None
+    before_error: Callable[[], None] | None = None
+    expected_timeout: float = 30
+    calls: list[tuple[Any, float | None]] = field(default_factory=list)
+
+    def __call__(
+        self,
+        request,
+        *,
+        timeout: float | None = None,
+    ) -> FakeResponse:
+        self.calls.append((request, timeout))
+
+        assert timeout == self.expected_timeout
+
+        if self.before_error is not None:
+            self.before_error()
+
+        if self.error is not None:
+            raise self.error
+
+        return FakeResponse(self.content)
+
+
+@pytest.fixture
+def urlopen_factory(
+    monkeypatch,
+) -> Callable[..., UrlopenStub]:
+    """Install and return a configurable urlopen test stub."""
+
+    def install(
+        *,
+        content: bytes = b"",
+        error: Exception | None = None,
+        before_error: Callable[[], None] | None = None,
+        expected_timeout: float = 30,
+    ) -> UrlopenStub:
+        if error is None and before_error is not None:
+            raise ValueError("before_error requires an error.")
+
+        stub = UrlopenStub(
+            content=content,
+            error=error,
+            before_error=before_error,
+            expected_timeout=expected_timeout,
+        )
+
+        monkeypatch.setattr(
+            urllib.request,
+            "urlopen",
+            stub,
+        )
+
+        return stub
+
+    return install
 
 
 def test_poet_backend_rejects_missing_checkpoint(
@@ -44,7 +135,10 @@ def test_make_pose_packet_contains_poet_metadata(
     checkpoint.touch()
 
     backend = POETBackend(str(checkpoint))
-    pose = np.zeros((2, 17, 3), dtype=np.float32)
+    pose = np.zeros(
+        (2, 17, 3),
+        dtype=np.float32,
+    )
 
     packet = backend.make_pose_packet(pose)
 
@@ -72,6 +166,7 @@ def test_make_pose_packet_without_detections_keeps_metadata(
     assert packet.keypoints is None
     assert packet.individual_ids == []
     assert packet.keypoint_names == list(POET_KEYPOINT_NAMES)
+    assert packet.skeleton_id == POET_SKELETON_ID
     assert packet.skeleton_edges == POET_SKELETON_EDGES
 
 
@@ -83,12 +178,11 @@ def test_download_worker_reuses_existing_file(
     destination.write_bytes(b"existing")
 
     worker = WeightsDownloadWorker(
-        "https://example.invalid/weights",
+        TEST_WEIGHTS_URL,
         destination,
     )
 
     progress: list[int] = []
-
     worker.progress.connect(progress.append)
 
     with qtbot.waitSignal(
@@ -102,82 +196,86 @@ def test_download_worker_reuses_existing_file(
     assert destination.read_bytes() == b"existing"
 
 
-class FakeResponse(BytesIO):
-    def __init__(self, content: bytes) -> None:
-        super().__init__(content)
-        self.length = len(content)
-
-    def __enter__(self):
-        return self
-
-    def __exit__(
-        self,
-        exc_type,
-        exc_value,
-        traceback,
-    ) -> None:
-        self.close()
-
-
 def test_download_worker_writes_destination(
     qtbot,
-    monkeypatch,
     tmp_path,
+    urlopen_factory,
 ) -> None:
     destination = tmp_path / "weights.pth"
     content = b"model-data"
 
-    monkeypatch.setattr(
-        urllib.request,
-        "urlopen",
-        lambda _request: FakeResponse(content),
+    urlopen_stub = urlopen_factory(
+        content=content,
     )
 
     worker = WeightsDownloadWorker(
-        "https://example.invalid/weights",
+        TEST_WEIGHTS_URL,
         destination,
     )
 
+    errors: list[str] = []
+    worker.error.connect(errors.append)
+
     with qtbot.waitSignal(
         worker.finished,
         timeout=1000,
     ) as blocker:
         worker.run()
 
+    assert errors == []
     assert blocker.args == [str(destination)]
     assert destination.read_bytes() == content
     assert not destination.with_suffix(".pth.part").exists()
 
+    assert len(urlopen_stub.calls) == 1
+    request, timeout = urlopen_stub.calls[0]
+
+    assert isinstance(
+        request,
+        urllib.request.Request,
+    )
+    assert request.full_url == TEST_WEIGHTS_URL
+    assert timeout == 30
+
 
 def test_download_worker_reports_failure_and_cleans_partial_file(
     qtbot,
-    monkeypatch,
     tmp_path,
+    urlopen_factory,
 ) -> None:
     destination = tmp_path / "weights.pth"
     partial_path = destination.with_suffix(".pth.part")
 
-    def failing_urlopen(_request):
-        partial_path.write_bytes(b"partial")
-        raise OSError("download failed")
-
-    monkeypatch.setattr(
-        urllib.request,
-        "urlopen",
-        failing_urlopen,
+    urlopen_stub = urlopen_factory(
+        error=OSError("download failed"),
+        before_error=lambda: partial_path.write_bytes(b"partial"),
     )
 
     worker = WeightsDownloadWorker(
-        "https://example.invalid/weights",
+        TEST_WEIGHTS_URL,
         destination,
     )
 
+    finished_paths: list[str] = []
+    worker.finished.connect(finished_paths.append)
+
     with qtbot.waitSignal(
         worker.error,
         timeout=1000,
     ) as blocker:
         worker.run()
 
     assert blocker.args == ["download failed"]
+    assert finished_paths == []
     assert not partial_path.exists()
     assert not destination.exists()
+
+    assert len(urlopen_stub.calls) == 1
+    request, timeout = urlopen_stub.calls[0]
+
+    assert isinstance(
+        request,
+        urllib.request.Request,
+    )
+    assert request.full_url == TEST_WEIGHTS_URL
+    assert timeout == 30