Cap hardware-trigger fetch timeout and update tests

Introduce a MAX_HARDWARE_TRIGGER_FETCH_TIMEOUT and cap Harvester.fetch() timeouts when the trigger role waits for external hardware (roles: external, follower) to keep individual fetch calls short and allow prompt shutdown. Preserve legacy behavior for non-waiting roles (e.g. master). Remove a noisy Trigger input LOG.info call. Update tests to expect the capped fetch timeout, verify the original requested timeout is still persisted in trigger_actual, add a test that master mode is not capped, and make test resource cleanup more robust (use try/finally around open/close).

Author: C-Achard

dlclivegui/cameras/backends/gentl_backend.py

@@ -76,6 +76,11 @@ class GenTLCameraBackend(CameraBackend):
     _CTI_FILES_SOURCE_AUTO: ClassVar[str] = "auto"
     _CTI_FILES_SOURCE_USER: ClassVar[str] = "user"
 
+    # Keep individual Harvester.fetch() calls short enough that controller
+    # shutdown can stop worker threads promptly. Hardware-trigger waits are
+    # handled by repeated polling in SingleCameraWorker.
+    _MAX_HARDWARE_TRIGGER_FETCH_TIMEOUT: ClassVar[float] = 1.0
+
     def __init__(self, settings):
         super().__init__(settings)
 
@@ -124,7 +129,16 @@ def __init__(self, settings):
 
         trigger_timeout = self._positive_float(self._trigger_attr(self._trigger, "timeout", None))
         if trigger_timeout is not None:
-            self._timeout = float(trigger_timeout)
+            role = str(self._trigger_attr(self._trigger, "role", "off") or "off").strip().lower()
+
+            if role in {"external", "follower"}:
+                # Do not let a long hardware-trigger wait block shutdown.
+                # SingleCameraWorker treats these fetch timeouts as expected
+                # polling misses while waits_for_hardware_trigger is true.
+                self._timeout = min(float(trigger_timeout), self._MAX_HARDWARE_TRIGGER_FETCH_TIMEOUT)
+            else:
+                # For non-trigger-waiting modes, preserve legacy behavior.
+                self._timeout = float(trigger_timeout)
 
         self._requested_resolution: tuple[int, int] | None = self._get_requested_resolution_or_none()
 
@@ -1176,14 +1190,6 @@ def _configure_trigger_input(self, node_map, cfg, *, strict: bool = False) -> No
             activation_ok,
         )
 
-        LOG.info(
-            "GenTL trigger input configured: role=%s selector=%s source=%s activation=%s",
-            self._trigger_attr(cfg, "role", "external"),
-            selector,
-            source,
-            activation,
-        )
-
     def _configure_trigger_master(self, node_map, cfg, *, strict: bool = False) -> None:
         output_line = str(self._trigger_attr(cfg, "output_line", "Line2") or "Line2")
         output_source = str(self._trigger_attr(cfg, "output_source", "ExposureActive") or "ExposureActive")

tests/cameras/backends/test_gentl_trigger.py

@@ -63,7 +63,7 @@ def test_trigger_external_configures_input_line_and_timeout(patch_gentl_sdk, gen
             "selector": "FrameStart",
             "source": "Line0",
             "activation": "RisingEdge",
-            "timeout": 10.0,
+            "timeout": gb.GenTLCameraBackend._MAX_HARDWARE_TRIGGER_FETCH_TIMEOUT,
         },
     )
     be = gb.GenTLCameraBackend(settings)
@@ -76,7 +76,7 @@ def test_trigger_external_configures_input_line_and_timeout(patch_gentl_sdk, gen
     assert nm.TriggerActivation.value == "RisingEdge"
     assert nm.TriggerMode.value == "On"
     assert be.waits_for_hardware_trigger is True
-    assert be._timeout == pytest.approx(10.0)
+    assert be._timeout == pytest.approx(gb.GenTLCameraBackend._MAX_HARDWARE_TRIGGER_FETCH_TIMEOUT)
 
     ns = settings.properties["gentl"]
     assert ns["trigger_actual"]["role"] == "external"
@@ -265,8 +265,12 @@ def test_trigger_alias_on_maps_to_external(patch_gentl_sdk, gentl_settings_facto
     be.close()
 
 
-def test_trigger_timeout_overrides_default_fetch_timeout(patch_gentl_sdk, gentl_settings_factory):
+def test_trigger_timeout_is_capped_for_hardware_trigger_fetch_polling(
+    patch_gentl_sdk,
+    gentl_settings_factory,
+):
     gb = patch_gentl_sdk
+    expected_fetch_timeout = gb.GenTLCameraBackend._MAX_HARDWARE_TRIGGER_FETCH_TIMEOUT
 
     settings = _gentl_trigger_settings(
         gentl_settings_factory,
@@ -277,18 +281,30 @@ def test_trigger_timeout_overrides_default_fetch_timeout(patch_gentl_sdk, gentl_
     )
     be = gb.GenTLCameraBackend(settings)
 
-    be.open()
-    assert be._timeout == pytest.approx(7.5)
+    try:
+        be.open()
 
-    # Fake acquisition is started, so read should pass and record the timeout.
-    frame, _ = be.read()
-    assert frame is not None
-    assert be._acquirer.fetch_calls[-1] == pytest.approx(7.5)
+        # Hardware-trigger fetch calls are intentionally capped so stop(wait=True)
+        # is not blocked by a long user trigger timeout.
+        assert be._timeout == pytest.approx(expected_fetch_timeout)
 
-    be.close()
+        # Fake acquisition is started, so read should pass and record the capped timeout.
+        frame, _ = be.read()
+        assert frame is not None
+        assert be._acquirer.fetch_calls[-1] == pytest.approx(expected_fetch_timeout)
+
+        # The requested trigger timeout is still preserved in persisted trigger_actual.
+        actual = settings.properties["gentl"]["trigger_actual"]
+        assert actual["timeout"] == pytest.approx(7.5)
 
+    finally:
+        be.close()
 
-def test_trigger_timeout_error_mentions_hardware_trigger_when_waiting(patch_gentl_sdk, gentl_settings_factory):
+
+def test_trigger_timeout_error_mentions_hardware_trigger_when_waiting(
+    patch_gentl_sdk,
+    gentl_settings_factory,
+):
     gb = patch_gentl_sdk
 
     settings = _gentl_trigger_settings(
@@ -297,22 +313,27 @@ def test_trigger_timeout_error_mentions_hardware_trigger_when_waiting(patch_gent
             "role": "external",
             "timeout": 3.0,
         },
-        # fast_start keeps acquisition stopped; fake fetch then raises timeout.
-        # This lets us assert the backend timeout message without hardware.
     )
+    # fast_start keeps acquisition stopped; fake fetch then raises timeout.
+    # This lets us assert the backend timeout message without hardware.
     settings.properties["gentl"]["fast_start"] = True
+
     be = gb.GenTLCameraBackend(settings)
 
-    be.open()
+    try:
+        be.open()
 
-    with pytest.raises(TimeoutError) as ei:
-        be.read()
+        assert be._timeout == pytest.approx(gb.GenTLCameraBackend._MAX_HARDWARE_TRIGGER_FETCH_TIMEOUT)
 
-    msg = str(ei.value).lower()
-    assert "gentl timeout" in msg
-    assert "hardware trigger" in msg or "trigger" in msg
+        with pytest.raises(TimeoutError) as ei:
+            be.read()
 
-    be.close()
+        msg = str(ei.value).lower()
+        assert "gentl timeout" in msg
+        assert "hardware trigger" in msg or "trigger" in msg
+
+    finally:
+        be.close()
 
 
 def test_trigger_actual_is_persisted_for_debugging(patch_gentl_sdk, gentl_settings_factory):
@@ -330,16 +351,22 @@ def test_trigger_actual_is_persisted_for_debugging(patch_gentl_sdk, gentl_settin
     )
     be = gb.GenTLCameraBackend(settings)
 
-    be.open()
+    try:
+        be.open()
 
-    actual = settings.properties["gentl"].get("trigger_actual")
-    assert isinstance(actual, dict)
-    assert actual["role"] == "follower"
-    assert actual["source"] == "Line1"
-    assert actual["activation"] == "FallingEdge"
-    assert actual["timeout"] == pytest.approx(9.0)
+        # Requested timeout remains in trigger_actual for debugging/config visibility.
+        actual = settings.properties["gentl"].get("trigger_actual")
+        assert isinstance(actual, dict)
+        assert actual["role"] == "follower"
+        assert actual["source"] == "Line1"
+        assert actual["activation"] == "FallingEdge"
+        assert actual["timeout"] == pytest.approx(9.0)
 
-    be.close()
+        # But each blocking Harvester.fetch() call is capped for responsive shutdown.
+        assert be._timeout == pytest.approx(gb.GenTLCameraBackend._MAX_HARDWARE_TRIGGER_FETCH_TIMEOUT)
+
+    finally:
+        be.close()
 
 
 def test_trigger_invalid_selector_non_strict_disables_trigger(patch_gentl_sdk, gentl_settings_factory):
@@ -372,3 +399,26 @@ def test_trigger_invalid_selector_non_strict_disables_trigger(patch_gentl_sdk, g
     assert actual["role"] == "off"
 
     be.close()
+
+
+def test_trigger_timeout_not_capped_for_master_mode(patch_gentl_sdk, gentl_settings_factory):
+    gb = patch_gentl_sdk
+
+    settings = _gentl_trigger_settings(
+        gentl_settings_factory,
+        {
+            "role": "master",
+            "timeout": 7.5,
+        },
+    )
+    be = gb.GenTLCameraBackend(settings)
+
+    try:
+        be.open()
+
+        # Master is free-running / trigger-generating, not waiting for hardware input.
+        assert be.waits_for_hardware_trigger is False
+        assert be._timeout == pytest.approx(7.5)
+
+    finally:
+        be.close()