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

{python_aidot_cameras-0.7.34/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.34
+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.34 → 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.34"
+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.34 → 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,
@@ -2071,6 +2082,7 @@ class CameraMixin(_CameraControlsMixin):
         sdes_fast_liveplay: Optional[bool] = None,
         sdes_skip_turn: Optional[bool] = None,
         sdes_adaptive: Optional[bool] = None,
+        sdes_audio_gain_db: Optional[float] = None,
     ) -> None:
         """Start a persistent stream that keeps the camera session alive.
 
@@ -2113,6 +2125,8 @@ class CameraMixin(_CameraControlsMixin):
             self._fast_connect_opt = fast_connect
         if sdes_audio is not None:
             self._sdes_audio_opt = sdes_audio
+        if sdes_audio_gain_db is not None:
+            self._sdes_audio_gain_opt = sdes_audio_gain_db
         if live_stream_param is not None:
             self._live_stream_param_opt = live_stream_param
         if serve_relay is not None:
@@ -2734,6 +2748,19 @@ class CameraMixin(_CameraControlsMixin):
         return os.environ.get("AIDOT_SDES_SERVE_AUDIO", "").strip().lower() not in (
             "0", "false", "no", "off")
 
+    def _resolve_sdes_audio_gain_db(self) -> float:
+        """Gain (dB) applied to the served SDES audio (the camera mic runs hot).
+
+        Per-camera ``sdes_audio_gain_db`` (via ``start_keepalive``) wins; else the
+        ``AIDOT_SDES_AUDIO_GAIN_DB`` env; else ``-8``.  A bad value falls back to
+        the default rather than raising."""
+        opt = getattr(self, "_sdes_audio_gain_opt", None)
+        src = opt if opt is not None else os.environ.get("AIDOT_SDES_AUDIO_GAIN_DB", "-8")
+        try:
+            return float(src)
+        except (ValueError, TypeError):
+            return -8.0
+
     def _resolve_sdes_skip_turn(self) -> bool:
         """EXPERIMENTAL (opt-in, default off): skip the blocking SDES TURN relay
         pre-allocation, for cameras reachable LAN-direct.
@@ -4227,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(
@@ -10052,18 +10086,13 @@ class CameraMixin(_CameraControlsMixin):
             if out_dir:
                 os.makedirs(out_dir, exist_ok=True)
         # Build the ffmpeg command (single source of truth: _build_sdes_serve_cmd).
-        _sdes_audio = self._resolve_sdes_serve_audio()
-        try:
-            _sdes_gain_db = float(os.environ.get("AIDOT_SDES_AUDIO_GAIN_DB", "-8"))
-        except (ValueError, TypeError):
-            _sdes_gain_db = -8.0
         cmd = _build_sdes_serve_cmd(
             sdp_path=sdp_path,
             rtsp_push_url=rtsp_push_url,
             output_path=output_path,
             max_seconds=max_seconds,
-            sdes_audio=bool(_sdes_audio),
-            audio_gain_db=_sdes_gain_db,
+            sdes_audio=self._resolve_sdes_serve_audio(),
+            audio_gain_db=self._resolve_sdes_audio_gain_db(),
         )
         # --- H.265 fix: narrow the ffmpeg SDP to the camera's actual codec ----
         # The camera streams H.264 (pt=96) OR H.265 (pt=97), varying per session.

{python_aidot_cameras-0.7.34 → 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.34
+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.34 → 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.34 → python_aidot_cameras-0.7.36}/tests/test_sdes_serve_audio.py

@@ -48,6 +48,28 @@ def test_kwarg_option_wins_over_env(monkeypatch):
     assert cam2._resolve_sdes_serve_audio() is True
 
 
+def test_gain_default(monkeypatch):
+    monkeypatch.delenv("AIDOT_SDES_AUDIO_GAIN_DB", raising=False)
+    assert _cam()._resolve_sdes_audio_gain_db() == -8.0
+
+
+def test_gain_env(monkeypatch):
+    monkeypatch.setenv("AIDOT_SDES_AUDIO_GAIN_DB", "-3.5")
+    assert _cam()._resolve_sdes_audio_gain_db() == -3.5
+
+
+def test_gain_opt_wins(monkeypatch):
+    monkeypatch.setenv("AIDOT_SDES_AUDIO_GAIN_DB", "-3")
+    cam = _cam()
+    cam._sdes_audio_gain_opt = 2.0
+    assert cam._resolve_sdes_audio_gain_db() == 2.0
+
+
+def test_gain_bad_value_falls_back(monkeypatch):
+    monkeypatch.setenv("AIDOT_SDES_AUDIO_GAIN_DB", "loud")
+    assert _cam()._resolve_sdes_audio_gain_db() == -8.0
+
+
 if __name__ == "__main__":
     import traceback
 

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)