python-aidot-cameras 0.11.3__tar.gz → 0.11.5__tar.gz

{python_aidot_cameras-0.11.3/python_aidot_cameras.egg-info → python_aidot_cameras-0.11.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.11.3
+Version: 0.11.5
 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
@@ -12,7 +12,7 @@ Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp>=3.9
-Requires-Dist: paho-mqtt>=2.0
+Requires-Dist: paho-mqtt>=1.6.1
 Requires-Dist: cryptography>=42.0
 Requires-Dist: pycryptodome>=3.20
 Requires-Dist: dacite>=1.8

{python_aidot_cameras-0.11.3 → python_aidot_cameras-0.11.5}/aidot/camera/client.py

@@ -565,6 +565,14 @@ def _get_stream_slots() -> "asyncio.Semaphore":
 
 
 
+# Battery cameras re-sleep on their own low-power timer ~25 s after the last
+# keep-alive, even mid-view. Renew setKeepAliveTime INSIDE that window so there
+# is no sleep gap (the official app renews every 30 s, which leaves a ~5 s gap
+# against the 25 s window). See CameraMixin._keepalive_renew_loop.
+_KEEPALIVE_WINDOW_S = 25
+_KEEPALIVE_RENEW_S = 20
+
+
 class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
     """All camera/streaming methods, mixed into DeviceClient via inheritance."""
 
@@ -2169,6 +2177,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
         if self._stream_task is not None and not self._stream_task.done():
             return
         self._streaming_active = True
+        self._start_keepalive_renew()   # battery: renew keep-alive on this path too
         self._stream_task = asyncio.ensure_future(self._streaming_loop())
 
     async def async_stop_streaming(self) -> None:
@@ -2196,6 +2205,13 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                 await task
             except (asyncio.CancelledError, Exception):
                 _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), 'async_stop_streaming', exc_info=True)
+        ka_task, self._keepalive_task = getattr(self, "_keepalive_task", None), None
+        if ka_task is not None and not ka_task.done():
+            ka_task.cancel()
+            try:
+                await ka_task
+            except (asyncio.CancelledError, Exception):
+                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), 'async_stop_streaming', exc_info=True)
         # Reap a persistent-MQTT stream drain that no session stopped (e.g. an
         # open cancelled mid-handshake) so its handler is removed from the shared
         # connection and its blocked executor thread is released.
@@ -2307,6 +2323,65 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
             except asyncio.CancelledError:
                 return
 
+    async def _async_set_keep_alive(self, keep_alive_s: int = _KEEPALIVE_WINDOW_S) -> None:
+        """POST setKeepAliveTime so a battery camera stays awake for keep_alive_s
+        seconds. Best-effort (errors swallowed). Wire format matches the app
+        (n.java: keepAliveTime=25)."""
+        try:
+            import aiohttp as _aiohttp
+            async with _aiohttp.ClientSession() as _s:
+                async with _s.post(
+                    f"{self._aidot_v32_base}/devices/{self.device_id}/setKeepAliveTime",
+                    json={"keepAliveTime": keep_alive_s},
+                    headers=self._aidot_headers(),
+                    timeout=_aiohttp.ClientTimeout(total=8),
+                ) as _r:
+                    _LOGGER.debug(
+                        "setKeepAliveTime HTTP %d for %s", _r.status, self.device_id
+                    )
+        except Exception as _exc:
+            _LOGGER.debug(
+                "setKeepAliveTime HTTP failed for %s: %s", self.device_id, _exc
+            )
+
+    def _start_keepalive_renew(self) -> None:
+        """Start the battery keep-alive renew loop - battery-only and
+        single-instance: cancel any prior loop first so a re-view within the
+        renew sleep window can't orphan one (an orphan keeps POSTing
+        setKeepAliveTime until _streaming_active next clears). No-op for mains
+        cameras, which never sleep."""
+        if not self.is_battery_camera:
+            return
+        prev = getattr(self, "_keepalive_task", None)
+        if prev is not None and not prev.done():
+            prev.cancel()
+        self._keepalive_task = asyncio.ensure_future(self._keepalive_renew_loop())
+
+    def _cancel_keepalive_renew(self) -> None:
+        """Cancel the battery keep-alive renew loop if running (fire-and-forget)."""
+        task, self._keepalive_task = getattr(self, "_keepalive_task", None), None
+        if task is not None and not task.done():
+            task.cancel()
+
+    async def _keepalive_renew_loop(self) -> None:
+        """Renew setKeepAliveTime while a BATTERY camera is streaming (app parity).
+
+        The camera's own low-power timer returns it to sleep ~25 s after the last
+        keep-alive even mid-view, so a one-shot keep-alive at open lets the stream
+        drop partway through. The official app renews it throughout a live view;
+        we renew every _KEEPALIVE_RENEW_S seconds (inside the 25 s window, so no
+        sleep gap). Mains cameras never sleep, so this is battery-only."""
+        if not self.is_battery_camera:
+            return
+        try:
+            while self._streaming_active:
+                await asyncio.sleep(_KEEPALIVE_RENEW_S)
+                if not self._streaming_active:
+                    break
+                await self._async_set_keep_alive()
+        except asyncio.CancelledError:
+            pass
+
     async def start_keepalive(
         self,
         rtsp_push_url: Optional[str] = None,
@@ -2381,6 +2456,10 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
         self._keepalive_rtsp_url = rtsp_push_url
         self._go2rtc_url = go2rtc_url
         self._streaming_active = True
+        # App parity: keep a battery camera awake for the whole view (mains cams
+        # never sleep, so this is a no-op there). Single-instance; cancelled in
+        # stop / idle-release.
+        self._start_keepalive_renew()
         if self.is_sdes_camera:
             self._stream_task = asyncio.ensure_future(self._sdes_keepalive_loop())
         elif rtsp_push_url and rtsp_push_url.startswith("http"):
@@ -2703,6 +2782,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                 except Exception:
                     _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_sdes_keepalive_loop', exc_info=True)
                 self._streaming_active = False
+                self._cancel_keepalive_renew()
                 self._keepalive_rtsp_url = None
                 self._serve_ready.clear()
                 _LOGGER.debug(
@@ -3490,6 +3570,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                 # No viewer - go dormant; camera.stream_source() restarts us when
                 # someone opens the live view again.
                 self._streaming_active = False
+                self._cancel_keepalive_renew()
                 self._keepalive_rtsp_url = None
                 self._serve_ready.clear()
                 _LOGGER.debug(

{python_aidot_cameras-0.11.3 → python_aidot_cameras-0.11.5}/aidot/camera/protocol.py

@@ -1219,7 +1219,12 @@ def _mqtt_session_sync(
                    else str(msg.payload))
         msg_q.put((msg.topic, payload))
 
-    def _on_disconnect(c, ud, disconnect_flags=None, reason_code=None, props=None):
+    def _on_disconnect(c, ud, *args):
+        # paho >=2 calls (disconnect_flags, reason_code, properties); paho <2
+        # calls (rc,).  Pull the reason code from whichever slot it lands in so
+        # the log is truthful on both (a fixed 5-arg signature put paho 1.x's rc
+        # in disconnect_flags and logged reason_code as None).
+        reason_code = args[1] if len(args) >= 2 else (args[0] if args else None)
         # If _on_connect was never fired (WebSocket upgrade failed, auth refused
         # at TCP level, etc.) signal conn_ev now so the caller doesn't time out.
         if not conn_ev.is_set():

{python_aidot_cameras-0.11.3 → python_aidot_cameras-0.11.5}/aidot/camera/webrtc_open.py

@@ -1000,32 +1000,13 @@ class _WebRTCOpenMixin:
                         "lowPowerActiveState HTTP failed for %s: %s", device_id, _we
                     )
 
-            async def _http_keepalive() -> None:
-                # setKeepAliveTime keeps the camera in active state for 25 s
-                # after wake (n.java:224 - keepAliveTime=25, not 20).
-                # Without this call the camera's built-in timer may return it
-                # to sleep before SCTP + LIVING completes (~10-15 s).
-                try:
-                    import aiohttp as _aiohttp_k
-                    async with _aiohttp_k.ClientSession() as _ks:
-                        async with _ks.post(
-                            f"{self._aidot_v32_base}/devices/{device_id}"
-                            "/setKeepAliveTime",
-                            json={"keepAliveTime": 25},
-                            headers=self._aidot_headers(),
-                            timeout=_aiohttp_k.ClientTimeout(total=8),
-                        ) as _kr:
-                            _LOGGER.debug(
-                                "setKeepAliveTime HTTP %d for %s",
-                                _kr.status, device_id,
-                            )
-                except Exception as _ke:
-                    _LOGGER.debug(
-                        "setKeepAliveTime HTTP failed for %s: %s", device_id, _ke
-                    )
-
             _spawn_bg(_http_wake())
-            _spawn_bg(_http_keepalive())
+            # setKeepAliveTime keeps the camera active for ~25 s after wake so the
+            # SCTP + LIVING handshake can complete. For BATTERY cameras a renewal
+            # loop (CameraMixin._keepalive_renew_loop, started by start_keepalive)
+            # then re-issues it every 20 s for the whole view - app parity so the
+            # camera doesn't return to sleep mid-stream.
+            _spawn_bg(self._async_set_keep_alive())
 
             outgoing_q.put_nowait(
                 (f"iot/v1/s/{user_id}/IPC/getIceConfigReq", _ice_req_payload)

{python_aidot_cameras-0.11.3 → python_aidot_cameras-0.11.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-aidot-cameras"
-version = "0.11.3"
+version = "0.11.5"
 description = "Control AiDot/Leedarson WiFi lights and cameras (WebRTC streaming, two-way audio, PTZ, controls)"
 readme = "README.md"
 license = "MIT"
@@ -22,7 +22,7 @@ classifiers = [
 # after re-validating against it.
 dependencies = [
     "aiohttp>=3.9",
-    "paho-mqtt>=2.0",
+    "paho-mqtt>=1.6.1",
     "cryptography>=42.0",
     "pycryptodome>=3.20",
     "dacite>=1.8",

{python_aidot_cameras-0.11.3 → python_aidot_cameras-0.11.5/python_aidot_cameras.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.11.3
+Version: 0.11.5
 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
@@ -12,7 +12,7 @@ Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp>=3.9
-Requires-Dist: paho-mqtt>=2.0
+Requires-Dist: paho-mqtt>=1.6.1
 Requires-Dist: cryptography>=42.0
 Requires-Dist: pycryptodome>=3.20
 Requires-Dist: dacite>=1.8

{python_aidot_cameras-0.11.3 → python_aidot_cameras-0.11.5}/python_aidot_cameras.egg-info/SOURCES.txt

@@ -85,6 +85,7 @@ tests/test_go2rtc.py
 tests/test_go2rtc_cli.py
 tests/test_highport_nomination.py
 tests/test_ice_config_cache.py
+tests/test_keepalive_renew.py
 tests/test_keyframe_prompter.py
 tests/test_lan_control.py
 tests/test_live_stream_param.py

{python_aidot_cameras-0.11.3 → python_aidot_cameras-0.11.5}/python_aidot_cameras.egg-info/requires.txt

@@ -1,5 +1,5 @@
 aiohttp>=3.9
-paho-mqtt>=2.0
+paho-mqtt>=1.6.1
 cryptography>=42.0
 pycryptodome>=3.20
 dacite>=1.8

python_aidot_cameras-0.11.5/tests/test_keepalive_renew.py

@@ -0,0 +1,119 @@
+"""Battery-camera setKeepAliveTime renewal during streaming (app parity).
+
+The official app re-issues setKeepAliveTime throughout a live view so a battery
+camera's low-power timer doesn't return it to sleep mid-stream. We renew inside
+the 25 s window; mains cameras never sleep and are skipped.
+"""
+import asyncio
+from unittest.mock import AsyncMock, MagicMock, patch
+
+from aidot.camera.client import CameraMixin
+
+
+def _obj(battery=True, streaming=True):
+    o = MagicMock()
+    o.is_battery_camera = battery
+    o._streaming_active = streaming
+    o.device_id = "cam1"
+    o._async_set_keep_alive = AsyncMock()
+    return o
+
+
+def test_renew_loop_skips_mains_cameras():
+    o = _obj(battery=False)
+    asyncio.run(CameraMixin._keepalive_renew_loop(o))
+    o._async_set_keep_alive.assert_not_awaited()
+
+
+def test_renew_loop_renews_battery_until_stream_stops():
+    o = _obj(battery=True)
+    n = {"i": 0}
+
+    async def fake_sleep(_s):
+        n["i"] += 1
+        if n["i"] >= 3:
+            o._streaming_active = False   # stop after the 3rd sleep
+
+    with patch("aidot.camera.client.asyncio.sleep", fake_sleep):
+        asyncio.run(CameraMixin._keepalive_renew_loop(o))
+    # sleep(renew), sleep(renew), sleep(stop -> break): 2 renewals
+    assert o._async_set_keep_alive.await_count == 2
+
+
+def test_renew_loop_swallows_cancel():
+    o = _obj(battery=True)
+
+    async def _run():
+        t = asyncio.ensure_future(CameraMixin._keepalive_renew_loop(o))
+        await asyncio.sleep(0)   # let it reach the first (real) sleep
+        t.cancel()               # cancel interrupts the sleep immediately
+        await t                  # CancelledError is swallowed inside the loop
+
+    asyncio.run(_run())
+    o._async_set_keep_alive.assert_not_awaited()
+
+
+def test_start_renew_is_noop_for_mains_cameras():
+    # Mains cameras never sleep - no throwaway task should be scheduled.
+    o = _obj(battery=False)
+    with patch("aidot.camera.client.asyncio.ensure_future") as ef:
+        CameraMixin._start_keepalive_renew(o)
+    ef.assert_not_called()
+
+
+def test_start_renew_cancels_a_still_running_prior_loop():
+    # Re-view within the renew sleep window must not orphan the prior loop.
+    o = _obj(battery=True)
+    prior = MagicMock()
+    prior.done.return_value = False
+    o._keepalive_task = prior
+    with patch("aidot.camera.client.asyncio.ensure_future", return_value="new") as ef:
+        CameraMixin._start_keepalive_renew(o)
+    prior.cancel.assert_called_once()   # old loop stopped
+    ef.assert_called_once()             # exactly one new loop
+    assert o._keepalive_task == "new"
+
+
+def test_cancel_renew_stops_the_loop_and_clears_the_ref():
+    o = _obj(battery=True)
+    task = MagicMock()
+    task.done.return_value = False
+    o._keepalive_task = task
+    CameraMixin._cancel_keepalive_renew(o)
+    task.cancel.assert_called_once()
+    assert o._keepalive_task is None
+
+
+def test_set_keep_alive_posts_expected_request():
+    o = MagicMock()
+    o.device_id = "cam1"
+    o._aidot_v32_base = "https://api.example/v3.2"
+    o._aidot_headers = MagicMock(return_value={"Authorization": "x"})
+    cap = {}
+
+    class _Resp:
+        status = 200
+
+        async def __aenter__(self):
+            return self
+
+        async def __aexit__(self, *a):
+            return False
+
+    class _Sess:
+        async def __aenter__(self):
+            return self
+
+        async def __aexit__(self, *a):
+            return False
+
+        def post(self, url, json=None, headers=None, timeout=None):
+            cap.update(url=url, json=json, headers=headers)
+            return _Resp()
+
+    with patch("aiohttp.ClientSession", lambda: _Sess()):
+        asyncio.run(CameraMixin._async_set_keep_alive(o))
+
+    assert cap["url"] == "https://api.example/v3.2/devices/cam1/setKeepAliveTime"
+    assert cap["json"] == {"keepAliveTime": 25}
+    assert cap["headers"] == {"Authorization": "x"}