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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.11.3
+Version: 0.11.6
 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.6}/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."""
 
@@ -976,7 +984,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
 
         Mirrors the official app's wake (DeviceWakeUpRepos.k()), which fires the
         HTTP wake so a sleeping camera (no live MQTT session) still gets the signal
-        through the cloud, and retries on failure (n.java onError "正在重试").  The
+        through the cloud, and retries on failure (n.java onError "retrying").  The
         MQTT ``lowPowerActiveStateReq`` is also published by the streaming /
         attribute paths; this adds the reliable cloud-side channel.  Non-battery
         cameras are always reachable, so this is a no-op for them.
@@ -1886,7 +1894,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
 
         _MIME = {1: "video/mp4", 2: "application/x-mpegURL"}
 
-        try:
+        async def _fetch():
             async with aiohttp.ClientSession() as session:
                 async with session.post(
                     f"{self._aidot_v32_base}/playback/getEventVideoUrl",
@@ -1897,7 +1905,12 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                     headers=self._aidot_headers(),
                     timeout=aiohttp.ClientTimeout(total=15),
                 ) as resp:
-                    body = await resp.json(content_type=None)
+                    return await resp.json(content_type=None)
+
+        try:
+            body = await _fetch()
+            if self._is_auth_error(body) and await self._async_refresh_auth_token():
+                body = await _fetch()  # retry once with the refreshed token
 
             _LOGGER.debug("getEventVideoUrl raw for %s uuid=%s: %s", self.device_id, event_uuid, body)
 
@@ -1958,7 +1971,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
         end_ts = int(time.time() * 1000)
         start_ts = end_ts - 30 * 86_400_000  # look back 30 days
 
-        try:
+        async def _fetch():
             async with aiohttp.ClientSession() as session:
                 async with session.post(
                     f"{self._aidot_v32_base}/playback/eventRecordingList",
@@ -1972,7 +1985,12 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                     headers=self._aidot_headers(),
                     timeout=aiohttp.ClientTimeout(total=15),
                 ) as resp:
-                    body = await resp.json(content_type=None)
+                    return await resp.json(content_type=None)
+
+        try:
+            body = await _fetch()
+            if self._is_auth_error(body) and await self._async_refresh_auth_token():
+                body = await _fetch()  # retry once with the refreshed token
 
             _LOGGER.debug("thumbnail eventRecordingList for %s: %s", self.device_id, body)
             if body.get("code") != 200:
@@ -2169,6 +2187,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 +2215,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.
@@ -2228,6 +2254,20 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
         except (asyncio.CancelledError, Exception):
             _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_reap_stream_drain', exc_info=True)
 
+    def _release_stream_drain_to_session(self):
+        """Hand ownership of the persistent-MQTT signaling drain to the session
+        that just opened successfully.
+
+        The returned WebRTCSession/SdesSession reaps its own outgoing_q + mqtt_fut
+        on stop(); ``_stream_mqtt_drain``/``_stream_mqtt_outq`` are only a backstop
+        for a drain whose open was cancelled *before* a session took ownership.
+        Clearing the slot on hand-off means a concurrent open on this same camera
+        (e.g. a snapshot taken during a live view) no longer reaps - and so no
+        longer kills - the live session's drain; the slot from then on only ever
+        holds a genuinely orphaned (cancelled mid-handshake) drain."""
+        self._stream_mqtt_drain = None
+        self._stream_mqtt_outq = None
+
     async def async_start_motion_polling(
         self, callback: Callable, interval: float = 30.0, lookback_s: int = 600,
     ) -> None:
@@ -2307,6 +2347,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 +2480,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 +2806,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 +3594,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.6}/aidot/camera/protocol.py

@@ -536,6 +536,11 @@ def _extract_param_sets_from_rtp(pkt: bytes) -> dict:
         while i + 2 <= len(payload):
             size = int.from_bytes(payload[i:i + 2], "big")
             i += 2
+            if i + size > len(payload):
+                # Truncated STAP-A: the advertised NAL size runs past the end of
+                # the packet, so the remaining bytes are garbage.  Stop rather
+                # than slice a short NAL and cache a corrupt SPS/PPS.
+                break
             nal = payload[i:i + size]
             i += size
             if nal:
@@ -1211,6 +1216,16 @@ def _mqtt_session_sync(
         status["connected"] = (rc == 0)
         status["rc"]        = rc
         status["rc_str"]    = str(reason_code)
+        if rc == 0:
+            # (Re)subscribe on EVERY successful connect.  paho's loop_start
+            # auto-reconnects after a transient drop, but with clean_session the
+            # broker retains no subscriptions, so a reconnected client would be
+            # deaf unless they are re-established here rather than only once below.
+            for _sub in subscribe_topics:
+                try:
+                    c.subscribe(_sub)
+                except Exception:
+                    _LOGGER.debug("_mqtt_session: resubscribe failed for %s", _sub, exc_info=True)
         conn_ev.set()
 
     def _on_message(c, ud, msg):
@@ -1219,14 +1234,32 @@ 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():
+            # Never connected (WS upgrade failed, auth refused at TCP level, ...):
+            # unblock the caller and end the receive loop - the connect failed.
             status["connected"] = False
             status["rc_str"]    = f"disconnect-before-connect rc={reason_code}"
             conn_ev.set()
-        msg_q.put(None)   # sentinel to unblock the receive loop
+            msg_q.put(None)   # sentinel: end the receive loop
+            return
+        # Already connected once: this is a transient drop.  paho's loop_start
+        # auto-reconnects and _on_connect re-subscribes, so DON'T end the receive
+        # loop here - a broker blip must not tear down a long-lived stream's
+        # signaling (the non-persistent transport runs one session for the whole
+        # stream).  A real teardown ends the loop via the outgoing-queue None
+        # sentinel or the duration deadline instead.
+        _LOGGER.debug(
+            "_mqtt_session: transient disconnect rc=%s (paho will reconnect)",
+            reason_code,
+        )
 
     def _on_log(c, ud, level, buf):
         if len(status["log"]) < 500:
@@ -1274,9 +1307,9 @@ def _mqtt_session_sync(
 
     _LOGGER.info("_mqtt_session: connected to %s:%d clientId=%s", hostname, port, client_id)
 
-    for topic in subscribe_topics:
-        client.subscribe(topic)
-        _LOGGER.debug("_mqtt_session: subscribed %s", topic)
+    # Subscriptions are (re)established in _on_connect so they survive a paho
+    # auto-reconnect; nothing to subscribe here.
+    _LOGGER.debug("_mqtt_session: subscribed (in on_connect) %s", subscribe_topics)
 
     for pub_topic, pub_payload in publish_items:
         client.publish(pub_topic, pub_payload)

{python_aidot_cameras-0.11.3 → python_aidot_cameras-0.11.6}/aidot/camera/sdes_open.py

@@ -47,9 +47,38 @@ def _sdes_echo_wait_timeout(skip_liveplay: bool) -> float:
 
 
 class _SdesOpenMixin:
-    async def _open_sdes_stream(
+    async def _open_sdes_stream(self, **kwargs) -> "SdesSession":
+        """Allocate-and-hand-off wrapper around _open_sdes_stream_impl.
+
+        The impl reserves two UDP sockets, starts a bridge thread, launches
+        ffmpeg and writes a temp SDP, then hands them to the returned
+        SdesSession (whose stop() releases them).  If the cold open is cancelled
+        mid-handshake (25-70s) - or raises before that hand-off - none of that
+        has an owner yet, so a plain call leaks the fds, the thread and a /tmp
+        file on every cancelled attempt (eventually "Too many open files").
+        The impl registers each resource on an ExitStack as it is allocated;
+        close the stack unless the impl actually returned a session.
+        """
+        from contextlib import ExitStack
+
+        _cleanup = ExitStack()
+        _ok = False
+        try:
+            _session = await self._open_sdes_stream_impl(_cleanup=_cleanup, **kwargs)
+            _ok = True
+            return _session
+        finally:
+            if not _ok:
+                # Closing the reservation sockets also unblocks the bridge
+                # thread's recv so it exits; ffmpeg is killed and the SDP file
+                # unlinked.  LIFO, and every callback swallows so this never
+                # masks the original CancelledError/exception.
+                _cleanup.close()
+
+    async def _open_sdes_stream_impl(
         self,
         *,
+        _cleanup=None,
         peer_id: str,
         user_id: str,
         device_id: str,
@@ -120,16 +149,45 @@ class _SdesOpenMixin:
         def _seq() -> str:
             return f"ap{random.randint(1000000, 9999999)}"
 
+        # Register a resource with the wrapper's cleanup stack so it is released
+        # if the cold open is cancelled/raises before the SdesSession takes
+        # ownership.  Each step swallows so ExitStack.close() can never mask the
+        # original CancelledError/exception.  No-op if called without a stack.
+        def _cl(fn, *a):
+            if _cleanup is None:
+                return
+            def _run():
+                try:
+                    fn(*a)
+                except Exception:
+                    _LOGGER.debug(
+                        "camera %s: swallowed sdes-open cleanup step",
+                        getattr(self, "device_id", "?"), exc_info=True,
+                    )
+            _cleanup.callback(_run)
+
+        def _reap(p):
+            try:
+                p.kill()
+            except Exception:
+                pass
+            try:
+                p.poll()   # reap the killed child so it does not linger as a zombie
+            except Exception:
+                pass
+
         # --- Allocate UDP ports and determine local IP ---------------------- #
         import socket as _socket
 
         _audio_sock = _socket.socket(_socket.AF_INET, _socket.SOCK_DGRAM)
         _audio_sock.bind(("0.0.0.0", 0))
         audio_port = _audio_sock.getsockname()[1]
+        _cl(_audio_sock.close)   # also unblocks the bridge thread's recv on cleanup
 
         _video_sock = _socket.socket(_socket.AF_INET, _socket.SOCK_DGRAM)
         _video_sock.bind(("0.0.0.0", 0))
         video_port = _video_sock.getsockname()[1]
+        _cl(_video_sock.close)
 
         # Use the outbound interface toward 8.8.8.8 to find our local IP.
         # connect() on a UDP socket does not send any packet.
@@ -733,6 +791,7 @@ class _SdesOpenMixin:
 
         sdp_path = await asyncio.get_running_loop().run_in_executor(
             None, _make_sdp_tempfile, _inject_sprop(ffmpeg_sdp, self.device_id))
+        _cl(os.unlink, sdp_path)   # released with the sockets on a cancelled open
 
         # --- Send webrtcReq BEFORE releasing reservation sockets ------------- #
         # ICE cameras (e.g. LK.IPC.A001064) send STUN binding requests to our
@@ -3384,6 +3443,7 @@ class _SdesOpenMixin:
                 stderr=subprocess.PIPE,
             )
             _proc_holder[0] = proc
+            _cl(_reap, proc)   # kill ffmpeg if the open is cancelled before hand-off
         except FileNotFoundError:
             # ffmpeg is not installed - clean up and surface a clear error.
             for _rsock in (_audio_sock, _video_sock):

{python_aidot_cameras-0.11.3 → python_aidot_cameras-0.11.6}/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)
@@ -1228,7 +1209,7 @@ class _WebRTCOpenMixin:
         # ------------------------------------------------------------------ #
         if use_sdes:
             try:
-                return await self._open_sdes_stream(
+                _sdes_session = await self._open_sdes_stream(
                     peer_id=peer_id,
                     user_id=user_id,
                     device_id=device_id,
@@ -1256,6 +1237,13 @@ class _WebRTCOpenMixin:
                     rtsp_push_url=rtsp_push_url,
                     talk=talk,
                 )
+                # Success: the SdesSession now owns outgoing_q + mqtt_fut and
+                # reaps them on stop(); clear the backstop slot so a concurrent
+                # open on this camera cannot reap this live session's drain.
+                # (On _SdesNoAnswerError the await raises before this runs, so the
+                # DTLS-fallback path below keeps the slot for its own hand-off.)
+                self._release_stream_drain_to_session()
+                return _sdes_session
             except CameraMixin._SdesNoAnswerError:
                 # Camera reported enableSdes='1' but did not respond to our SDES
                 # offer.  iOS telemetry shows models such as LK.IPC.A001064 can
@@ -3591,6 +3579,10 @@ class _WebRTCOpenMixin:
         _LOGGER.info(
             "WebRTC stream open for %s (peerid=%s)", device_id, peer_id
         )
+        # Ownership of the signaling drain passes to this session (its stop()
+        # reaps outgoing_q + mqtt_fut); clear the backstop slot so a concurrent
+        # open on this camera cannot reap this live session's drain.
+        self._release_stream_drain_to_session()
         return WebRTCSession(
             pc=pc,
             outgoing_q=outgoing_q,

{python_aidot_cameras-0.11.3 → python_aidot_cameras-0.11.6}/aidot/client.py

@@ -50,6 +50,27 @@ _LOGGER = logging.getLogger(__name__)
 # other cloud API calls that use owner+token headers.
 _CLOUD_APP_ID = "68"
 
+# Strong refs to fire-and-forget tasks: asyncio only keeps weak refs, so a
+# discarded task can be garbage-collected mid-flight (see camera/client.py).
+_BG_TASKS: set = set()
+
+
+def _spawn_bg(coro):
+    _t = asyncio.ensure_future(coro)
+    _BG_TASKS.add(_t)
+
+    def _done(task):
+        _BG_TASKS.discard(task)
+        # Retrieve the exception so a failing background task doesn't surface as
+        # an unhandled "Task exception was never retrieved" at GC time; log it.
+        if not task.cancelled():
+            exc = task.exception()
+            if exc is not None:
+                _LOGGER.debug("aidot background task failed: %r", exc, exc_info=exc)
+
+    _t.add_done_callback(_done)
+    return _t
+
 
 def rsa_password_encrypt(message: str) -> str:
     """RSA-encrypt the password using the AiDot public key (for loginWithFreeVerification)."""
@@ -513,9 +534,7 @@ class AidotClient:
             device_client.set_token_refresh_cb(self.async_ensure_token)
             self._device_clients[device_id] = device_client
             # Pre-warm ICE config cache so stream open does not block on this fetch.
-            asyncio.get_running_loop().create_task(
-                _prefetch_ice_config(device_client)
-            )
+            _spawn_bg(_prefetch_ice_config(device_client))
         # Started lazily here as well: __init__ cannot start discovery when
         # constructed outside a running event loop (stored-token sync path).
         if self._discover is None:
@@ -583,7 +602,7 @@ class AidotClient:
 
     def cleanup(self) -> None:
         """Sync entry point: fire-and-forget async_close()."""
-        asyncio.get_running_loop().create_task(self.async_close())
+        _spawn_bg(self.async_close())
 
     async def async_cleanup(self) -> None:
         """Async entry point: close the client and release resources."""

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-aidot-cameras"
-version = "0.11.3"
+version = "0.11.6"
 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.6/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.6
 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.6}/python_aidot_cameras.egg-info/SOURCES.txt

@@ -85,10 +85,12 @@ 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
 tests/test_motion_poll.py
+tests/test_mqtt_session_reconnect.py
 tests/test_narrow_pc_ice.py
 tests/test_no_undefined_names.py
 tests/test_offline_keepalive_pause.py
@@ -102,6 +104,7 @@ tests/test_sdes_adaptive.py
 tests/test_sdes_echo_wait_timeout.py
 tests/test_sdes_fast_liveplay.py
 tests/test_sdes_idle_release.py
+tests/test_sdes_open_cleanup.py
 tests/test_sdes_serve_audio.py
 tests/test_sdes_serve_cmd.py
 tests/test_sdes_sprop.py
@@ -113,6 +116,7 @@ tests/test_serve_relay.py
 tests/test_session_stats.py
 tests/test_speak.py
 tests/test_stream_cap.py
+tests/test_stream_drain_ownership.py
 tests/test_stream_idle.py
 tests/test_stream_teardown.py
 tests/test_talk.py

{python_aidot_cameras-0.11.3 → python_aidot_cameras-0.11.6}/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