python-aidot-cameras 0.7.35__tar.gz → 0.7.36__tar.gz

{python_aidot_cameras-0.7.35/src/python_aidot_cameras.egg-info → python_aidot_cameras-0.7.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.7.35
+Version: 0.7.36
 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.7.35 → python_aidot_cameras-0.7.36}/pyproject.toml

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

{python_aidot_cameras-0.7.35 → python_aidot_cameras-0.7.36}/src/aidot/camera/client.py

@@ -584,6 +584,7 @@ class CameraMixin(_CameraControlsMixin):
         self._streaming_active: bool = False
         self._stream_session: Optional[Any] = None
         self._stream_task: Optional["asyncio.Task[None]"] = None
+        self._stream_mqtt_drain: Optional["asyncio.Future"] = None
         self._last_frame_time: float = 0.0
         self._keepalive_rtsp_url: Optional[str] = None  # local serve URL (go2rtc pulls)
         self._go2rtc_url: Optional[str] = None           # go2rtc API base (prefer-go2rtc)
@@ -1981,6 +1982,16 @@ class CameraMixin(_CameraControlsMixin):
                 await task
             except (asyncio.CancelledError, Exception):
                 _LOGGER.debug("camera %s: swallowed exception", 'async_stop_streaming', exc_info=True)
+        # Reap a persistent-MQTT stream drain that no session stopped (e.g. an
+        # open cancelled mid-handshake): cancelling it runs its finally, which
+        # removes the handler from the shared persistent connection.
+        drain, self._stream_mqtt_drain = getattr(self, "_stream_mqtt_drain", None), None
+        if drain is not None and not drain.done():
+            drain.cancel()
+            try:
+                await drain
+            except (asyncio.CancelledError, Exception):
+                _LOGGER.debug("camera %s: swallowed exception", 'async_stop_streaming', exc_info=True)
 
     async def async_start_motion_polling(
         self, callback: Callable, interval: float = 30.0, lookback_s: int = 600,
@@ -4243,6 +4254,13 @@ class CameraMixin(_CameraControlsMixin):
                     _pm_stream.remove_handler(_on_mqtt_message)
 
             mqtt_fut = asyncio.ensure_future(_pm_stream_drain())
+            # Track the drain so teardown can reap it even if this open is
+            # cancelled before a WebRTCSession takes ownership (the session
+            # normally stops it via the outgoing_q sentinel).  Without this an
+            # open cancelled mid-handshake leaves the drain blocked on
+            # outgoing_q.get forever and its handler registered on the shared
+            # persistent connection.
+            self._stream_mqtt_drain = mqtt_fut
             _on_mqtt_ready({"connected": True, "rc": 0, "rc_str": "persistent"})
         else:
             mqtt_fut = loop.run_in_executor(

{python_aidot_cameras-0.7.35 → python_aidot_cameras-0.7.36/src/python_aidot_cameras.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.7.35
+Version: 0.7.36
 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.7.35 → python_aidot_cameras-0.7.36}/src/python_aidot_cameras.egg-info/SOURCES.txt

@@ -57,6 +57,7 @@ tests/test_serve_relay.py
 tests/test_speak.py
 tests/test_stream_cap.py
 tests/test_stream_idle.py
+tests/test_stream_teardown.py
 tests/test_talk.py
 tests/test_terminal_ack.py
 tests/test_token_refresh.py

python_aidot_cameras-0.7.36/tests/test_stream_teardown.py

@@ -0,0 +1,75 @@
+"""Unit test: async_stop_streaming reaps an orphaned persistent-MQTT drain.
+
+If a stream open is cancelled before a WebRTCSession takes ownership of the
+drain task, the drain would otherwise block forever on outgoing_q.get with its
+handler still registered. async_stop_streaming must cancel it (its finally then
+removes the handler). No camera needed.
+"""
+import asyncio
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "src"))
+
+import aidot.camera.client as cc
+
+_CAM = next(v for v in vars(cc).values()
+            if isinstance(v, type) and "async_stop_streaming" in v.__dict__)
+
+
+def _bare_client():
+    c = _CAM.__new__(_CAM)
+    c._streaming_active = True
+    c._serve_ready = asyncio.Event()
+    c._go2rtc_task = None
+    c._stream_session = None
+    c._stream_task = None
+    c._stream_mqtt_drain = None
+
+    async def _noop_deregister():
+        return None
+    c._deregister_go2rtc = _noop_deregister
+    return c
+
+
+def test_orphaned_drain_is_cancelled():
+    async def _run():
+        c = _bare_client()
+        handler_removed = {"v": False}
+
+        async def _drain():
+            try:
+                await asyncio.Event().wait()      # blocks forever, like outgoing_q.get
+            finally:
+                handler_removed["v"] = True       # the real finally calls remove_handler
+        c._stream_mqtt_drain = asyncio.ensure_future(_drain())
+        await asyncio.sleep(0)                     # let the drain start blocking
+
+        await c.async_stop_streaming()
+
+        assert c._stream_mqtt_drain is None        # cleared
+        assert handler_removed["v"] is True        # drain's finally ran (handler removed)
+    asyncio.run(_run())
+
+
+def test_no_drain_is_safe():
+    async def _run():
+        c = _bare_client()                         # _stream_mqtt_drain is None
+        await c.async_stop_streaming()             # must not raise
+        assert c._streaming_active is False
+    asyncio.run(_run())
+
+
+if __name__ == "__main__":
+    import traceback
+    _fail = 0
+    for _k, _v in sorted(globals().items()):
+        if _k.startswith("test_"):
+            try:
+                _v()
+                print(f"PASS {_k}")
+            except Exception:
+                _fail += 1
+                print(f"FAIL {_k}")
+                traceback.print_exc()
+    raise SystemExit(1 if _fail else 0)