python-aidot-cameras 0.11.12__tar.gz → 0.11.14__tar.gz

{python_aidot_cameras-0.11.12/python_aidot_cameras.egg-info → python_aidot_cameras-0.11.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.11.12
+Version: 0.11.14
 Summary: Control AiDot/Leedarson WiFi lights and cameras (WebRTC streaming, two-way audio, PTZ, controls)
 Author-email: cbrightly <chris.brightly@gmail.com>
 License-Expression: MIT

{python_aidot_cameras-0.11.12 → python_aidot_cameras-0.11.14}/aidot/camera/client.py

@@ -117,6 +117,26 @@ _SLOW_PROBE_LOG_EVERY = int(os.environ.get("AIDOT_DTLS_SLOW_PROBE_LOG_EVERY", "6
 # asyncio.sleep(interval) call, so stop() is not delayed by up to 10 minutes.
 _SLOW_PROBE_SLEEP_CHUNK_S = float(os.environ.get("AIDOT_DTLS_SLOW_PROBE_CHUNK_S", "5"))
 
+
+def _parse_env_float(name: str, default: float) -> float:
+    """Parse a float env var, falling back to ``default`` on any missing or
+    malformed value (matches the try/except idiom used by
+    _get_webrtc_open_gate / _get_stream_slots below for AIDOT_MAX_CONCURRENT_*
+    rather than raising at import time)."""
+    try:
+        return float(os.environ.get(name, str(default)))
+    except (ValueError, TypeError):
+        return default
+
+
+# DTLS serve-open timeout: how long a single async_open_webrtc_stream() call
+# in the serve loop is allowed to take before giving up. Left at the
+# _async_open_webrtc_stream_impl default (30.0s) so battery cameras that need
+# the full window to wake still work; tunable via
+# AIDOT_DTLS_SERVE_OPEN_TIMEOUT_S for operators who want faster-failing
+# retries against a known-dead camera.
+_DTLS_SERVE_OPEN_TIMEOUT_S = _parse_env_float("AIDOT_DTLS_SERVE_OPEN_TIMEOUT_S", 30.0)
+
 # Strong refs to fire-and-forget tasks: asyncio only keeps weak refs, so a
 # discarded task can be garbage-collected mid-flight. Discarded on completion.
 _BG_TASKS: set = set()
@@ -3499,7 +3519,9 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                     return
             _last_open_at = loop.time()
             try:
-                session = await self.async_open_webrtc_stream(on_frame=lambda _f: None)
+                session = await self.async_open_webrtc_stream(
+                    on_frame=lambda _f: None, timeout=_DTLS_SERVE_OPEN_TIMEOUT_S,
+                )
             except asyncio.CancelledError:
                 return
             except AidotCameraBusy as busy:

{python_aidot_cameras-0.11.12 → python_aidot_cameras-0.11.14}/aidot/camera/sdes_open.py

@@ -63,6 +63,24 @@ def _classify_ffmpeg_exit(rc: int, teardown_requested: bool) -> int:
     return logging.WARNING
 
 
+def _bridge_should_break(rc, teardown_requested: bool) -> bool:
+    """Whether the bridge observe loop should end on this poll() result.
+
+    rc is the held proc's poll() result (None while it is still running).
+    Ending the loop is only correct when ffmpeg has actually exited AND no
+    locally-initiated teardown is in flight for it: a non-None rc seen while
+    teardown_requested is True is the key-restart window (or any other
+    flagged local kill) - the OLD proc's exit, not a reason to stop.  That
+    window always resolves promptly one of two ways, so skipping the break
+    here cannot hang the bridge thread: either the key-restart repoints
+    _proc_holder[0] at the live new proc (next poll() is None again), or a
+    genuine teardown closes the loopback sockets, which makes the loop's
+    select() raise and exit via its own except-break.  Pure function so the
+    policy is unit-testable without a live bridge thread.
+    """
+    return rc is not None and not teardown_requested
+
+
 class _SdesOpenMixin:
     async def _open_sdes_stream(self, **kwargs) -> "SdesSession":
         """Allocate-and-hand-off wrapper around _open_sdes_stream_impl.
@@ -2145,6 +2163,13 @@ class _SdesOpenMixin:
             _trigger_bsrc       = None    # camera addr for trigger
             _sdes_probe_received = False  # True after first 0xC8 probe from camera
             _last_hb_ts         = 0.0     # time of last AVIO HEARTBEAT send
+            # One-shot guard for the "ffmpeg exited" log below: while the held
+            # proc keeps reporting the same stale exit code across a
+            # teardown-window skip (see _bridge_should_break), only the first
+            # tick logs it.  Reset to False whenever the held proc is next
+            # seen alive (poll() None), so a later, genuine exit of THAT proc
+            # still gets its own line.
+            _br_exit_logged = False
             _lo_a = _socket_br.socket(_socket_br.AF_INET, _socket_br.SOCK_DGRAM)
             _lo_v = _socket_br.socket(_socket_br.AF_INET, _socket_br.SOCK_DGRAM)
             try:
@@ -2155,15 +2180,24 @@ class _SdesOpenMixin:
                         )
                     except Exception:
                         break
-                    # Stop the bridge when ffmpeg exits (normal end or crash).
+                    # Stop the bridge when ffmpeg exits (normal end or crash) -
+                    # but NOT on a stale exit seen during a flagged teardown
+                    # window (key-restart proc replace, stop(), _reap(), the
+                    # DTLS-fallback abort): _bridge_should_break() skips the
+                    # break there, and the loop resolves it either via the
+                    # key-restart's _proc_holder[0] repoint (next poll() None,
+                    # below) or via a genuine teardown closing the loopback
+                    # sockets, which raises out of the select() above.
                     _br_proc = _proc_holder[0]
                     if _br_proc is not None:
                         _br_rc = _br_proc.poll()
                         if _br_rc is not None:
-                            if _br_rc != 0:
+                            _br_teardown_requested = bool(_teardown_holder[0])
+                            if _br_rc != 0 and not _br_exit_logged:
+                                _br_exit_logged = True
                                 import logging as _log_br
                                 _br_level = _classify_ffmpeg_exit(
-                                    _br_rc, bool(_teardown_holder[0])
+                                    _br_rc, _br_teardown_requested
                                 )
                                 _br_msg = (
                                     "SDES bridge: ffmpeg exited with code %d"
@@ -2175,7 +2209,12 @@ class _SdesOpenMixin:
                                 _log_br.getLogger(__name__).log(
                                     _br_level, _br_msg, _br_rc
                                 )
-                            break
+                            if _bridge_should_break(
+                                _br_rc, _br_teardown_requested
+                            ):
+                                break
+                        else:
+                            _br_exit_logged = False
 
                     # AVIO HEARTBEAT (cmd=5156) every 10s, sent as an ENCRYPTED SCTP
                     # DATA chunk (PPID=53) - exactly like LIVING - NOT a raw 0xC8 AVIO

{python_aidot_cameras-0.11.12 → python_aidot_cameras-0.11.14}/aidot/device_client.py

@@ -56,6 +56,7 @@ class DeviceStatusData:
     rgbw: tuple[int, int, int, int] = (255, 0, 0, 0)
     cct: int = 2700
     dimming: int = 100
+    active_color_mode: "str | None" = None
 
     def update(self, attr: DeviceAttr) -> None:
         """Update status from DeviceAttr model."""
@@ -82,6 +83,20 @@ class DeviceStatusData:
         if attr.CCT is not None:
             self.cct = attr.CCT
 
+        # Track which color mode is actually active. Bulbs report state as
+        # deltas: a CCT-mode push carries only CCT, an RGB-mode push carries
+        # only RGBW. The getDevAttr login-sync instead returns BOTH the
+        # retained RGBW register and CCT together, which is ambiguous about
+        # which mode is active; that case (and RGBW==0, which is just the
+        # register's power-on default rather than a real color pick) must
+        # update the values above without changing active_color_mode.
+        rgbw_present = attr.RGBW is not None
+        cct_present = attr.CCT is not None
+        if rgbw_present and not cct_present and attr.RGBW != 0:
+            self.active_color_mode = "rgbw"
+        elif cct_present and not rgbw_present:
+            self.active_color_mode = "cct"
+
 
 class DeviceInformation:
     """Static device metadata and capability flags parsed from the cloud record."""

{python_aidot_cameras-0.11.12 → python_aidot_cameras-0.11.14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-aidot-cameras"
-version = "0.11.12"
+version = "0.11.14"
 description = "Control AiDot/Leedarson WiFi lights and cameras (WebRTC streaming, two-way audio, PTZ, controls)"
 readme = "README.md"
 license = "MIT"

{python_aidot_cameras-0.11.12 → python_aidot_cameras-0.11.14/python_aidot_cameras.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.11.12
+Version: 0.11.14
 Summary: Control AiDot/Leedarson WiFi lights and cameras (WebRTC streaming, two-way audio, PTZ, controls)
 Author-email: cbrightly <chris.brightly@gmail.com>
 License-Expression: MIT

{python_aidot_cameras-0.11.12 → python_aidot_cameras-0.11.14}/python_aidot_cameras.egg-info/SOURCES.txt

@@ -80,6 +80,7 @@ tests/test_device_user_info_cache.py
 tests/test_dtls_not_ready_burst.py
 tests/test_dtls_pinning.py
 tests/test_dtls_serve_decode_skip.py
+tests/test_dtls_serve_open_timeout.py
 tests/test_dtls_skip_signaling_wait.py
 tests/test_dtls_slow_probe.py
 tests/test_egress_guard.py
@@ -91,6 +92,7 @@ tests/test_ice_config_cache.py
 tests/test_keepalive_renew.py
 tests/test_keyframe_prompter.py
 tests/test_lan_control.py
+tests/test_light_active_color_mode.py
 tests/test_live_stream_param.py
 tests/test_logging_caps.py
 tests/test_motion_poll.py
@@ -106,6 +108,7 @@ tests/test_playback_tls.py
 tests/test_post_merge_hardening.py
 tests/test_retry_policy.py
 tests/test_sdes_adaptive.py
+tests/test_sdes_bridge_break_gate.py
 tests/test_sdes_echo_wait_timeout.py
 tests/test_sdes_fast_liveplay.py
 tests/test_sdes_ffmpeg_stderr_log.py

python_aidot_cameras-0.11.14/tests/test_dtls_serve_open_timeout.py

@@ -0,0 +1,75 @@
+"""AIDOT_DTLS_SERVE_OPEN_TIMEOUT_S: env-tunable timeout for the DTLS serve
+loop's async_open_webrtc_stream call (aidot/camera/client.py, ~line 3502).
+
+Without a ``timeout`` kwarg that call is hard-pinned to the 30.0s default in
+_async_open_webrtc_stream_impl (webrtc_open.py ~146-151); a dead/wedged DTLS
+camera then burns a full 30s per open attempt.  This makes it tunable while
+keeping the default unchanged (battery cameras can legitimately need the full
+30s to wake).
+
+Repo convention: no pytest-asyncio; drive coroutines with asyncio.run().
+"""
+import asyncio
+import types
+
+import aidot.camera.client as camera_client
+from aidot.camera.client import CameraMixin, _parse_env_float
+
+
+# --- _parse_env_float: the try/except-fallback idiom used elsewhere in this
+# module for numeric AIDOT_* env vars (see _get_webrtc_open_gate /
+# _get_stream_slots' AIDOT_MAX_CONCURRENT_OPENS / _STREAMS handling). ------- #
+
+def test_parse_env_float_defaults_when_unset(monkeypatch):
+    monkeypatch.delenv("AIDOT_DTLS_SERVE_OPEN_TIMEOUT_S", raising=False)
+    assert _parse_env_float("AIDOT_DTLS_SERVE_OPEN_TIMEOUT_S", 30.0) == 30.0
+
+
+def test_parse_env_float_override(monkeypatch):
+    monkeypatch.setenv("AIDOT_DTLS_SERVE_OPEN_TIMEOUT_S", "12.5")
+    assert _parse_env_float("AIDOT_DTLS_SERVE_OPEN_TIMEOUT_S", 30.0) == 12.5
+
+
+def test_parse_env_float_malformed_falls_back_to_default(monkeypatch):
+    monkeypatch.setenv("AIDOT_DTLS_SERVE_OPEN_TIMEOUT_S", "not-a-number")
+    assert _parse_env_float("AIDOT_DTLS_SERVE_OPEN_TIMEOUT_S", 30.0) == 30.0
+
+
+def test_module_constant_defaults_to_30():
+    # Guards the preserved-behavior requirement: unset env -> 30.0, matching
+    # _async_open_webrtc_stream_impl's prior hard-pinned default exactly.
+    assert camera_client._DTLS_SERVE_OPEN_TIMEOUT_S == 30.0
+
+
+# --- Nice-to-have: the serve loop passes the configured timeout through ---- #
+
+class _Ready:
+    def clear(self):
+        pass
+
+    def set(self):
+        pass
+
+
+def test_dtls_serve_loop_passes_configured_timeout(monkeypatch):
+    calls = []
+
+    class _Fake:
+        _streaming_active = True
+        _keepalive_rtsp_url = "http://127.0.0.1:8999/cam.ts"
+        device_id = "TESTCAM"
+        _serve_ready = _Ready()
+
+        async def async_open_webrtc_stream(self, *a, **k):
+            calls.append(k)
+            raise asyncio.CancelledError
+
+    fake = _Fake()
+
+    async def _run():
+        await types.MethodType(CameraMixin._dtls_serve_loop_inner, fake)()
+
+    asyncio.run(_run())
+
+    assert calls, "async_open_webrtc_stream was never called"
+    assert calls[0].get("timeout") == camera_client._DTLS_SERVE_OPEN_TIMEOUT_S

python_aidot_cameras-0.11.14/tests/test_light_active_color_mode.py

@@ -0,0 +1,58 @@
+"""Tests for DeviceStatusData.active_color_mode tracking.
+
+AiDot RGBW+CCT bulbs report state as deltas: a CCT-mode push carries only
+CCT (RGBW is None); an RGB-mode push carries only RGBW (CCT is None). But
+the getDevAttr login-sync returns BOTH the retained RGBW register and CCT
+together, which is ambiguous about which mode is actually active. This
+must update the retained values but must NOT change active_color_mode.
+"""
+
+from aidot.device_client import DeviceStatusData
+from aidot.models.device_client_model import DeviceAttr
+
+
+def test_cct_only_delta_sets_cct_mode():
+    status = DeviceStatusData()
+    status.update(DeviceAttr(OnOff=1, Dimming=100, CCT=3000))
+    assert status.active_color_mode == "cct"
+    assert status.cct == 3000
+
+
+def test_rgbw_only_delta_sets_rgbw_mode():
+    status = DeviceStatusData()
+    status.update(DeviceAttr(RGBW=0x00FF0000))
+    assert status.active_color_mode == "rgbw"
+    assert status.rgbw == (0, 255, 0, 0)
+
+
+def test_ambiguous_sync_does_not_change_mode_from_unknown():
+    # Starting from a fresh (unknown/None) mode, an ambiguous sync carrying
+    # both RGBW and CCT must update the values but leave the mode None.
+    status = DeviceStatusData()
+    assert status.active_color_mode is None
+    status.update(DeviceAttr(OnOff=1, Dimming=100, RGBW=-1660909312, CCT=3000))
+    assert status.active_color_mode is None
+    assert status.rgbw == (157, 0, 137, 0)
+    assert status.cct == 3000
+
+
+def test_ambiguous_sync_does_not_revert_established_mode():
+    status = DeviceStatusData()
+    # Unambiguous CCT-only delta establishes "cct".
+    status.update(DeviceAttr(OnOff=1, Dimming=100, CCT=3000))
+    assert status.active_color_mode == "cct"
+    # A subsequent ambiguous sync (both RGBW and CCT present) must NOT flip
+    # the mode back to "rgbw", even though RGBW is present in the payload.
+    status.update(DeviceAttr(OnOff=1, Dimming=100, RGBW=-1660909312, CCT=3000))
+    assert status.active_color_mode == "cct"
+    assert status.rgbw == (157, 0, 137, 0)
+    assert status.cct == 3000
+
+
+def test_rgbw_zero_only_does_not_set_rgbw_mode():
+    status = DeviceStatusData()
+    status.update(DeviceAttr(RGBW=0))
+    assert status.active_color_mode is None
+    # Existing default-red value behavior must be unchanged.
+    assert status.rgdb == 0xFF000000
+    assert status.rgbw == (255, 0, 0, 0)

python_aidot_cameras-0.11.14/tests/test_sdes_bridge_break_gate.py

@@ -0,0 +1,229 @@
+"""Gate the SDES bridge observe-loop break on the teardown flag.
+
+During a key-restart (sdes_open.py's SRTP-key-mismatch branch, ~3680-3739) the
+OLD ffmpeg proc is terminated and the shared teardown flag is set BEFORE the
+NEW proc is spawned and _proc_holder[0] is repointed to it.  If the bridge
+thread's observe-loop tick lands in that window, it used to see the OLD
+proc's non-None exit code and break unconditionally - tearing down the bridge
+loop, closing the loopback sockets, and starving the freshly restarted
+ffmpeg (NO_MEDIA until the liveness watchdog forces a 40-60s reconnect).
+
+The break decision is extracted into a pure helper, _bridge_should_break(rc,
+teardown_requested), so the policy is unit-testable in isolation; the loop
+itself is embedded in a large closure inside _open_sdes_stream_impl that
+cannot be invoked standalone, so the composed loop-level tests below drive a
+small mirror of the loop's shape (select-gated wait / proc-holder poll / the
+pre-existing except-break on socket close) using the real, imported
+_bridge_should_break to make the decision - the same function the production
+loop calls - plus a source-inspection check that the production loop really
+does call it, so the mirror cannot silently drift from the real code.
+"""
+import inspect
+import select
+import socket
+
+import aidot.camera.sdes_open as sdes_open
+from aidot.camera.sdes_open import _bridge_should_break
+
+
+# --------------------------------------------------------------------- #
+# Pure helper truth table
+# --------------------------------------------------------------------- #
+
+def test_break_on_clean_exit_without_teardown():
+    assert _bridge_should_break(0, False) is True
+
+
+def test_break_on_signal_death_without_teardown():
+    assert _bridge_should_break(-9, False) is True
+
+
+def test_no_break_on_signal_death_during_teardown():
+    assert _bridge_should_break(-9, True) is False
+
+
+def test_no_break_on_clean_exit_during_teardown():
+    assert _bridge_should_break(0, True) is False
+
+
+def test_no_break_while_still_running():
+    assert _bridge_should_break(None, False) is False
+    assert _bridge_should_break(None, True) is False
+
+
+# --------------------------------------------------------------------- #
+# Source-structure guard: the real loop must call the pure helper, not
+# reimplement (or bypass) the decision inline.
+# --------------------------------------------------------------------- #
+
+def test_production_loop_calls_the_shared_helper():
+    src = inspect.getsource(sdes_open)
+    start = src.index("def _bridge_fn():")
+    end = src.index("def _bridge_fn():", start + 1) if src.count(
+        "def _bridge_fn():"
+    ) > 1 else len(src)
+    block = src[start:end]
+    assert "_bridge_should_break(" in block, (
+        "the bridge observe loop must delegate the break decision to "
+        "_bridge_should_break so the policy stays unit-testable and in sync"
+    )
+
+
+# --------------------------------------------------------------------- #
+# Loop-level behavior with fakes
+# --------------------------------------------------------------------- #
+
+class _FakeProc:
+    """Minimal Popen stand-in: poll() returns the fixed rc once "exited"."""
+
+    def __init__(self, rc):
+        self._rc = rc
+
+    def poll(self):
+        return self._rc
+
+
+def _run_observe_loop(sock_a, sock_b, proc_holder, teardown_holder,
+                       max_ticks=100):
+    """Mirror of the sdes_open.py bridge observe loop's shape.
+
+    Same structure as the production loop: a select()-gated wait whose
+    except clause breaks (the socket-close escape hatch), then a proc poll
+    that only breaks when the real _bridge_should_break helper says so, with
+    an exit-code log fired at most once per skip window.  Returns
+    (outcome, ticks, log_count) so tests can assert on all three without any
+    real sleeping or threading - select's timeout is kept tiny since the
+    real 0.5s constant is not itself under test here.
+    """
+    exit_logged = False
+    log_count = 0
+    for tick in range(1, max_ticks + 1):
+        try:
+            select.select([sock_a, sock_b], [], [], 0.01)
+        except Exception:
+            return "closed", tick, log_count
+        proc = proc_holder[0]
+        if proc is not None:
+            rc = proc.poll()
+            if rc is not None:
+                if rc != 0 and not exit_logged:
+                    exit_logged = True
+                    log_count += 1
+                if _bridge_should_break(rc, bool(teardown_holder[0])):
+                    return "broke", tick, log_count
+                continue
+            exit_logged = False
+    return "exhausted", max_ticks, log_count
+
+
+def _udp_pair():
+    a = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    b = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    return a, b
+
+
+def test_teardown_window_exit_does_not_break_the_loop():
+    # Old proc reports a signal death while teardown is flagged (the
+    # key-restart window) - the loop must NOT break on that tick.
+    a, b = _udp_pair()
+    try:
+        proc_holder = [_FakeProc(-9)]
+        teardown_holder = [True]
+        outcome, ticks, log_count = _run_observe_loop(
+            a, b, proc_holder, teardown_holder, max_ticks=3
+        )
+        assert outcome == "exhausted"
+        assert log_count == 1  # logged once, not suppressed entirely
+    finally:
+        a.close()
+        b.close()
+
+
+def test_repoint_to_live_proc_resumes_normal_operation():
+    # Same window, but the key-restart repoints _proc_holder[0] to the new,
+    # live proc after the first tick - the loop must keep running (not
+    # break) and must not re-log once the new proc is polling clean.
+    a, b = _udp_pair()
+    try:
+        proc_holder = [_FakeProc(-9)]
+        teardown_holder = [True]
+
+        exit_logged = False
+        log_count = 0
+        outcomes = []
+        for i in range(4):
+            if i == 1:
+                proc_holder[0] = _FakeProc(None)  # key-restart repoint
+            try:
+                select.select([a, b], [], [], 0.01)
+            except Exception:
+                outcomes.append("closed")
+                break
+            proc = proc_holder[0]
+            rc = proc.poll()
+            if rc is not None:
+                if rc != 0 and not exit_logged:
+                    exit_logged = True
+                    log_count += 1
+                if _bridge_should_break(rc, bool(teardown_holder[0])):
+                    outcomes.append("broke")
+                    break
+            else:
+                exit_logged = False
+            outcomes.append("continued")
+        assert outcomes == ["continued", "continued", "continued", "continued"]
+        assert log_count == 1
+    finally:
+        a.close()
+        b.close()
+
+
+def test_genuine_teardown_closes_sockets_and_exits_via_except_break():
+    # No key-restart repoint arrives; instead a real teardown (stop(), the
+    # DTLS-fallback abort, or _reap()) closes the loopback sockets - select()
+    # must raise and the loop must exit via the pre-existing except-break.
+    a, b = _udp_pair()
+    proc_holder = [_FakeProc(-9)]
+    teardown_holder = [True]
+
+    a.close()
+    b.close()
+
+    outcome, ticks, log_count = _run_observe_loop(
+        a, b, proc_holder, teardown_holder, max_ticks=10
+    )
+    assert outcome == "closed"
+    assert ticks == 1
+
+
+def test_genuine_crash_without_teardown_still_breaks():
+    # No teardown in flight: an unexpected ffmpeg crash must still break the
+    # loop immediately, exactly as before this fix.
+    a, b = _udp_pair()
+    try:
+        proc_holder = [_FakeProc(-9)]
+        teardown_holder = [False]
+        outcome, ticks, log_count = _run_observe_loop(
+            a, b, proc_holder, teardown_holder, max_ticks=10
+        )
+        assert outcome == "broke"
+        assert ticks == 1
+        assert log_count == 1
+    finally:
+        a.close()
+        b.close()
+
+
+def test_log_fires_at_most_once_across_a_multi_tick_skip_window():
+    a, b = _udp_pair()
+    try:
+        proc_holder = [_FakeProc(-9)]
+        teardown_holder = [True]
+        outcome, ticks, log_count = _run_observe_loop(
+            a, b, proc_holder, teardown_holder, max_ticks=20
+        )
+        assert outcome == "exhausted"
+        assert log_count == 1
+    finally:
+        a.close()
+        b.close()