python-aidot-cameras 0.7.26__tar.gz → 0.7.28__tar.gz

{python_aidot_cameras-0.7.26/src/python_aidot_cameras.egg-info → python_aidot_cameras-0.7.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.7.26
+Version: 0.7.28
 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
@@ -122,6 +122,8 @@ chosen to work out of the box; override only when tuning.
 | `AIDOT_SPROP_DIR` | Directory where captured SPS/PPS (sprop) parameter sets are cached. Set this to a writable path (e.g. for Home Assistant) if the default location is read-only. | `<package dir>` |
 | `AIDOT_DISABLE_HIGHPORT_FIX` | If set (any value), disables the DTLS high-port `USE-CANDIDATE` nomination fix and falls back to upstream aioice behavior (used to measure the baseline connect rate). | unset (fix enabled) |
 | `AIDOT_FAST_CONNECT` | Enables LAN-direct "fast connect" mode (STUN-only, skips several cloud signaling waits) when set to a truthy value. | unset (off) |
+| `AIDOT_PERSISTENT_MQTT` | Reuse ONE account-level persistent MQTT connection for device commands and attribute fetches (matching the official app) instead of connecting per operation, cutting cloud connect churn. Truthy value enables. The stream-open path is unaffected. | unset (off) |
+| `AIDOT_SDES_ADAPTIVE` | Adaptive fast-with-fallback for the SDES keepalive loop: try the fast path first (skip livePlay waits + TURN relay pre-alloc) and fall back to the full relay path if a fast attempt delivers no media. A per-device cache skips the fast attempt on later views once it has failed for a camera. Truthy value enables. | unset (off) |
 | `AIDOT_SDES_FAST_LIVEPLAY` | Truthy value skips the `livePlayResp` blocking wait for eligible SDES cameras (~4.5 s faster cold start), while keeping the full ICE/SCTP handshake. Role-reversal models (A001064 PTZ) are always excluded. Soak-validated; opt-in. | unset (off) |
 | `AIDOT_SERVE_RELAY` | Holds the public stream port via an internal relay that proxies to ffmpeg, so the first (cold) view connects instead of failing while ffmpeg can't pre-bind the port. Set to `0` to serve ffmpeg directly. | `1` (enabled) |
 | `AIDOT_MAX_CONCURRENT_OPENS` | Caps how many stream opens run concurrently. | `2` |

{python_aidot_cameras-0.7.26 → python_aidot_cameras-0.7.28}/README.md

@@ -95,6 +95,8 @@ chosen to work out of the box; override only when tuning.
 | `AIDOT_SPROP_DIR` | Directory where captured SPS/PPS (sprop) parameter sets are cached. Set this to a writable path (e.g. for Home Assistant) if the default location is read-only. | `<package dir>` |
 | `AIDOT_DISABLE_HIGHPORT_FIX` | If set (any value), disables the DTLS high-port `USE-CANDIDATE` nomination fix and falls back to upstream aioice behavior (used to measure the baseline connect rate). | unset (fix enabled) |
 | `AIDOT_FAST_CONNECT` | Enables LAN-direct "fast connect" mode (STUN-only, skips several cloud signaling waits) when set to a truthy value. | unset (off) |
+| `AIDOT_PERSISTENT_MQTT` | Reuse ONE account-level persistent MQTT connection for device commands and attribute fetches (matching the official app) instead of connecting per operation, cutting cloud connect churn. Truthy value enables. The stream-open path is unaffected. | unset (off) |
+| `AIDOT_SDES_ADAPTIVE` | Adaptive fast-with-fallback for the SDES keepalive loop: try the fast path first (skip livePlay waits + TURN relay pre-alloc) and fall back to the full relay path if a fast attempt delivers no media. A per-device cache skips the fast attempt on later views once it has failed for a camera. Truthy value enables. | unset (off) |
 | `AIDOT_SDES_FAST_LIVEPLAY` | Truthy value skips the `livePlayResp` blocking wait for eligible SDES cameras (~4.5 s faster cold start), while keeping the full ICE/SCTP handshake. Role-reversal models (A001064 PTZ) are always excluded. Soak-validated; opt-in. | unset (off) |
 | `AIDOT_SERVE_RELAY` | Holds the public stream port via an internal relay that proxies to ffmpeg, so the first (cold) view connects instead of failing while ffmpeg can't pre-bind the port. Set to `0` to serve ffmpeg directly. | `1` (enabled) |
 | `AIDOT_MAX_CONCURRENT_OPENS` | Caps how many stream opens run concurrently. | `2` |

{python_aidot_cameras-0.7.26 → python_aidot_cameras-0.7.28}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-aidot-cameras"
-version = "0.7.26"
+version = "0.7.28"
 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.26 → python_aidot_cameras-0.7.28}/src/aidot/camera/client.py

@@ -1241,12 +1241,23 @@ class CameraMixin(_CameraControlsMixin):
             publish_items.append((_wake_topic, _wake_payload))
         publish_items.append((pub_topic, payload_str))
 
-        messages = await _mqtt_session(
-            mqtt_url, mqtt_user, mqtt_pwd, client_id,
-            subscribe_topics=sub_topics,
-            publish_items=publish_items,
-            duration=timeout,
-        )
+        if self._resolve_persistent_mqtt():
+            pm = await self._get_persistent_mqtt()
+        else:
+            pm = None
+        if pm is not None:
+            messages, _st = await pm.request(
+                publish_items=publish_items,
+                subscribe_topics=sub_topics,
+                timeout=timeout,
+            )
+        else:
+            messages = await _mqtt_session(
+                mqtt_url, mqtt_user, mqtt_pwd, client_id,
+                subscribe_topics=sub_topics,
+                publish_items=publish_items,
+                duration=timeout,
+            )
 
         for topic, raw in messages:
             if ack_keyword and ack_keyword not in topic:
@@ -1473,12 +1484,23 @@ class CameraMixin(_CameraControlsMixin):
             })
             publish_items.append((_wake_topic, _wake_payload))
 
-        messages = await _mqtt_session(
-            mqtt_url, mqtt_user, mqtt_pwd, client_id,
-            subscribe_topics=sub_topics,
-            publish_items=publish_items,
-            duration=timeout,
-        )
+        if self._resolve_persistent_mqtt():
+            pm = await self._get_persistent_mqtt()
+        else:
+            pm = None
+        if pm is not None:
+            messages, _st = await pm.request(
+                publish_items=publish_items,
+                subscribe_topics=sub_topics,
+                timeout=timeout,
+            )
+        else:
+            messages = await _mqtt_session(
+                mqtt_url, mqtt_user, mqtt_pwd, client_id,
+                subscribe_topics=sub_topics,
+                publish_items=publish_items,
+                duration=timeout,
+            )
 
         for topic, raw in messages:
             if "setDevAttrNotif" not in topic:
@@ -1959,6 +1981,8 @@ class CameraMixin(_CameraControlsMixin):
         serve_relay: Optional[bool] = None,
         stream_idle_s: Optional[float] = None,
         sdes_fast_liveplay: Optional[bool] = None,
+        sdes_skip_turn: Optional[bool] = None,
+        sdes_adaptive: Optional[bool] = None,
     ) -> None:
         """Start a persistent stream that keeps the camera session alive.
 
@@ -2009,6 +2033,10 @@ class CameraMixin(_CameraControlsMixin):
             self._stream_idle_opt = stream_idle_s
         if sdes_fast_liveplay is not None:
             self._sdes_fast_liveplay_opt = sdes_fast_liveplay
+        if sdes_skip_turn is not None:
+            self._sdes_skip_turn_opt = sdes_skip_turn
+        if sdes_adaptive is not None:
+            self._sdes_adaptive_opt = sdes_adaptive
         if self._stream_task is not None and not self._stream_task.done():
             return
         self._keepalive_rtsp_url = rtsp_push_url
@@ -2218,19 +2246,46 @@ class CameraMixin(_CameraControlsMixin):
         # media (see end of loop).
         _pacer = ReconnectPacer(_MIN_DELAY, _MAX_DELAY)
 
+        # Adaptive fast-with-fallback (default on): the first open tries the fast
+        # path (skip livePlay waits + TURN relay pre-allocation) with a SHORT
+        # timeout/grace so a non-LAN camera fails quickly; on no media we latch
+        # _fast_failed and the remaining opens this loop use the full, patient
+        # relay path.  Makes fast-by-default safe regardless of camera reachability.
+        _adaptive = self._resolve_sdes_adaptive()
+        _FAST_OPEN_TIMEOUT = 45.0
+        _FAST_GRACE = 40.0
+        # Per-device cache: once a fast attempt has failed for this camera (e.g. a
+        # strict-NAT / non-LAN camera that genuinely needs the relay), remember it
+        # so later views skip the fast attempt entirely instead of re-paying the
+        # ~40s fast timeout on every fresh keepalive loop. Latches for the client's
+        # lifetime; an integration reload / restart re-probes the fast path.
+        _fast_failed = bool(getattr(self, "_fast_path_unavailable", False))
+
         while self._streaming_active:
             if self._serve_relay is not None:
                 # Clear any stale backend from a prior session; the open below
                 # points the relay at this session's fresh internal ffmpeg port.
                 self._serve_relay.set_backend(None)
+            _use_fast = self._adaptive_next_fast(_adaptive, _fast_failed)
+            if _adaptive:
+                self._fast_attempt_override = _use_fast
             try:
                 session = await self.async_open_webrtc_stream(
                     rtsp_push_url=self._keepalive_rtsp_url,
-                    timeout=120.0,
+                    timeout=(_FAST_OPEN_TIMEOUT if _use_fast else 120.0),
                 )
             except asyncio.CancelledError:
+                self._fast_attempt_override = None
                 return
             except Exception as exc:
+                self._fast_attempt_override = None
+                if _use_fast:
+                    _fast_failed = self._adaptive_after_attempt(True, False, _fast_failed)
+                    self._fast_path_unavailable = True  # cache across views
+                    _LOGGER.info(
+                        "SDES adaptive[%s]: fast open failed (%.0fs) - "
+                        "falling back to full relay path", self.device_id,
+                        _FAST_OPEN_TIMEOUT)
                 _delay = _pacer.fail_delay()
                 _LOGGER.warning(
                     "SDES keepalive: stream open failed for %s (retry in %.0fs): %s",
@@ -2242,6 +2297,7 @@ class CameraMixin(_CameraControlsMixin):
                     return
                 continue
 
+            self._fast_attempt_override = None
             self._stream_session = session
             # Don't block solely on wait_done(): the SDES ffmpeg reads RTP over a
             # UDP socket with no input timeout, so when a battery camera tears the
@@ -2276,6 +2332,7 @@ class CameraMixin(_CameraControlsMixin):
                         session.last_media_monotonic,
                         _started_at,
                         time.monotonic(),
+                        grace=(_FAST_GRACE if _use_fast else 60.0),
                     ):
                         _stalled = True
                         break
@@ -2327,12 +2384,22 @@ class CameraMixin(_CameraControlsMixin):
             except Exception:
                 _LOGGER.debug("camera %s: swallowed exception", '_sdes_keepalive_loop', exc_info=True)
 
+            # Adaptive bookkeeping: a fast attempt that never delivered media
+            # latches the loop onto the full relay path for its remaining opens.
+            _healthy = session.last_media_monotonic > 0.0
+            if _use_fast and not _healthy and not _fast_failed:
+                _LOGGER.info(
+                    "SDES adaptive[%s]: fast attempt delivered no media - "
+                    "falling back to full relay path", self.device_id)
+            _fast_failed = self._adaptive_after_attempt(_use_fast, _healthy, _fast_failed)
+            if _use_fast and not _healthy:
+                self._fast_path_unavailable = True  # cache across views
+
             if self._streaming_active:
                 # Escalate backoff only when the session never delivered media
                 # (camera refused / degraded on a rapid reconnect); a session
                 # that streamed fine and then ended (battery teardown, consumer
                 # gone) is a normal lifecycle event and resets to the base interval.
-                _healthy = session.last_media_monotonic > 0.0
                 try:
                     await asyncio.sleep(_pacer.session_end_delay(healthy=_healthy))
                 except asyncio.CancelledError:
@@ -2556,6 +2623,9 @@ class CameraMixin(_CameraControlsMixin):
         opt = getattr(self, "_sdes_fast_liveplay_opt", None)
         if opt is not None:
             return bool(opt)
+        ov = getattr(self, "_fast_attempt_override", None)
+        if ov is not None:
+            return bool(ov)
         return os.environ.get("AIDOT_SDES_FAST_LIVEPLAY", "").strip().lower() in (
             "1", "true", "yes", "on")
 
@@ -2580,9 +2650,90 @@ class CameraMixin(_CameraControlsMixin):
         opt = getattr(self, "_sdes_skip_turn_opt", None)
         if opt is not None:
             return bool(opt)
+        ov = getattr(self, "_fast_attempt_override", None)
+        if ov is not None:
+            return bool(ov)
         return os.environ.get("AIDOT_SDES_SKIP_TURN_PREALLOC", "").strip().lower() in (
             "1", "true", "yes", "on")
 
+    def _resolve_sdes_adaptive(self) -> bool:
+        """Whether the SDES keepalive loop drives the fast path adaptively
+        (opt-in, default OFF): try fast-first (skip the livePlay waits + TURN
+        relay pre-allocation, with a short timeout), and fall back to the full,
+        patient relay path if the fast attempt delivers no media.
+
+        This makes "fast by default" safe for cameras of unknown reachability:
+        a LAN-direct camera gets the fast connect; a remote / strict-NAT camera
+        loses one short fast attempt, then connects via the full relay path.
+
+        Default OFF pending real-world fast-failure-rate data: a fast *failure*
+        costs ~40 s (the grace) before fallback while success saves only ~7 s, so
+        until the failure rate is known on real fleets this stays opt-in.
+
+        Per-camera ``sdes_adaptive`` (via start_keepalive) wins; else the
+        ``AIDOT_SDES_ADAPTIVE`` env (truthy = 1/true/yes/on), default off. When
+        off, the per-attempt override is never set, so the explicit
+        ``sdes_fast_liveplay`` / ``sdes_skip_turn`` opts (or their envs) decide -
+        exactly the pre-adaptive behaviour."""
+        opt = getattr(self, "_sdes_adaptive_opt", None)
+        if opt is not None:
+            return bool(opt)
+        return os.environ.get("AIDOT_SDES_ADAPTIVE", "").strip().lower() in (
+            "1", "true", "yes", "on")
+
+    def _resolve_persistent_mqtt(self) -> bool:
+        """Whether commands + attribute fetches reuse ONE account-level persistent
+        MQTT connection (matching the app's LDSBaseMqttServiceImpl) instead of
+        connecting per op.  Opt-in (``AIDOT_PERSISTENT_MQTT`` env / per-camera
+        ``_persistent_mqtt_opt``), default off while it's validated.  Phase 1: the
+        stream-open path is unchanged (it uses session client_ids)."""
+        opt = getattr(self, "_persistent_mqtt_opt", None)
+        if opt is not None:
+            return bool(opt)
+        return os.environ.get("AIDOT_PERSISTENT_MQTT", "").strip().lower() in (
+            "1", "true", "yes", "on")
+
+    async def _get_persistent_mqtt(self):
+        """Get-or-create the account-shared ``_PersistentMqtt`` (one per account,
+        keyed on the shared ``login_info``).  The broker binds auth to the single
+        authorized client_id, so there must be exactly one.  Returns None if it
+        can't be built (caller falls back to per-op ``_mqtt_session``)."""
+        # _user_info is the shared account dict (same object across the account's
+        # DeviceClients, and the same object as AidotClient.login_info) - the right
+        # place to cache one connection per account.
+        li = self._user_info if isinstance(getattr(self, "_user_info", None), dict) else None
+        if li is None:
+            return None
+        pm = li.get("_persistent_mqtt")
+        if pm is not None:
+            return pm
+        smarthome_auth = await self._async_get_smarthome_auth()
+        mqtt_user = (smarthome_auth or {}).get("mqttUser") or str(self.user_id)
+        mqtt_pwd  = (smarthome_auth or {}).get("mqttPassword") or ""
+        client_id = (self._user_info.get("mqttClientId") or f"app-{mqtt_user}")
+        mqtt_url = await self._async_get_mqtt_url()
+        if not mqtt_url:
+            return None
+        from .protocol import _PersistentMqtt
+        pm = li.get("_persistent_mqtt")  # re-check under the brief await gap
+        if pm is None:
+            pm = _PersistentMqtt(mqtt_url, mqtt_user, mqtt_pwd, client_id)
+            li["_persistent_mqtt"] = pm
+        return pm
+
+    @staticmethod
+    def _adaptive_next_fast(adaptive: bool, fast_failed: bool) -> bool:
+        """Whether the next SDES open attempt should use the fast path: only when
+        adaptive mode is on and the fast path has not already failed this loop."""
+        return bool(adaptive) and not bool(fast_failed)
+
+    @staticmethod
+    def _adaptive_after_attempt(use_fast: bool, healthy: bool, fast_failed: bool) -> bool:
+        """Updated ``fast_failed`` after an attempt: latch it once a fast attempt
+        delivers no media, so the loop stays on the full relay path (no
+        oscillation) until it restarts fresh on the next view."""
+        return bool(fast_failed) or (bool(use_fast) and not bool(healthy))
+
     def _maybe_start_serve_relay(self, serve_url: Optional[str]) -> "Optional[_ServeRelay]":
         """Hold the public serve port via a _ServeRelay so an eager go2rtc pull
         connects-and-waits instead of hitting ECONNREFUSED during the ~16-25s

{python_aidot_cameras-0.7.26 → python_aidot_cameras-0.7.28}/src/aidot/camera/protocol.py

@@ -1245,6 +1245,186 @@ def _mqtt_session_sync(
     return collected, status
 
 
+class _PersistentMqtt:
+    """One long-lived paho MQTT connection reused across many publish/collect
+    round-trips - matching the official app's single persistent connection
+    (LDSBaseMqttServiceImpl) instead of our historical connect-per-op.
+
+    Thread-safe: the paho network loop runs in its own background thread and
+    auto-reconnects; tracked subscriptions are replayed on every (re)connect.
+    ``request()`` registers a transient collector, publishes, and gathers
+    matching messages for ``timeout`` WITHOUT tearing the connection down, so
+    N operations cost ONE connect instead of N. The client_id is account-level,
+    so exactly one of these should exist per account (per AidotClient)."""
+
+    def __init__(self, mqtt_url, mqtt_user, mqtt_pwd, client_id, ws_path="/mqtt"):
+        self._url = mqtt_url
+        self._user = mqtt_user
+        self._pwd = mqtt_pwd
+        self._cid = client_id
+        self._ws_path = ws_path
+        self._client = None
+        self._host = None
+        self._port = None
+        self._connected = threading.Event()
+        self._lock = threading.Lock()
+        self._subs = set()         # topics to (re)subscribe on connect
+        self._collectors = []      # transient queues, each receives every msg
+        self._started = False
+        self.connects = 0          # observability: how many times we connected
+
+    def _build(self):
+        import paho.mqtt.client as _paho
+        import ssl as _ssl
+        from urllib.parse import urlparse
+        parsed = urlparse(self._url)
+        self._host = parsed.hostname or self._url
+        self._port = parsed.port or (8443 if parsed.scheme in ("wss", "https") else 1883)
+        tls = parsed.scheme in ("wss", "https", "mqtts")
+        path = self._ws_path if self._ws_path is not None else (parsed.path or "/mqtt")
+        if path == "":
+            path = "/"
+        try:
+            c = _paho.Client(callback_api_version=_paho.CallbackAPIVersion.VERSION2,
+                             client_id=self._cid, transport="websockets")
+        except AttributeError:
+            c = _paho.Client(client_id=self._cid, transport="websockets")
+        c.ws_set_options(path=path)
+        if self._user:
+            c.username_pw_set(self._user, self._pwd or "")
+        if tls:
+            c.tls_set_context(_ssl.create_default_context())
+        try:
+            c.reconnect_delay_set(min_delay=1, max_delay=30)
+        except Exception:
+            pass
+        c.on_connect = self._on_connect
+        c.on_disconnect = self._on_disconnect
+        c.on_message = self._on_message
+        return c
+
+    def _on_connect(self, c, ud, flags, reason_code, props=None):
+        try:
+            rc = int(reason_code)
+        except (TypeError, ValueError):
+            rc = getattr(reason_code, "value", -1)
+        if rc == 0:
+            self.connects += 1
+            with self._lock:
+                subs = list(self._subs)
+            for t in subs:                 # replay subscriptions after (re)connect
+                try:
+                    c.subscribe(t)
+                except Exception:
+                    _LOGGER.debug("persistent mqtt: resubscribe %s failed", t)
+            self._connected.set()
+        else:
+            _LOGGER.warning("persistent mqtt: broker refused rc=%s", rc)
+
+    def _on_disconnect(self, c, ud, *args, **kwargs):
+        self._connected.clear()            # paho loop auto-reconnects; subs replay on_connect
+
+    def _on_message(self, c, ud, msg):
+        payload = (msg.payload.decode("utf-8", errors="replace")
+                   if isinstance(msg.payload, (bytes, bytearray)) else str(msg.payload))
+        item = (msg.topic, payload)
+        with self._lock:
+            cols = list(self._collectors)
+        for q in cols:
+            q.put(item)
+
+    def _ensure_started_sync(self, timeout=15.0):
+        with self._lock:
+            if self._client is None:
+                self._client = self._build()
+                try:
+                    self._client.connect(self._host, self._port, keepalive=60)
+                except Exception as exc:
+                    _LOGGER.warning("persistent mqtt: connect() raised: %s", exc)
+                    self._client = None
+                    return False
+                self._client.loop_start()  # drives keepalive + auto-reconnect
+                self._started = True
+        return self._connected.wait(timeout)
+
+    def _subscribe_sync(self, topics):
+        new = []
+        with self._lock:
+            for t in topics:
+                if t not in self._subs:
+                    self._subs.add(t)
+                    new.append(t)
+            c = self._client
+        if c is not None and self._connected.is_set():
+            for t in new:
+                try:
+                    c.subscribe(t)
+                except Exception:
+                    _LOGGER.debug("persistent mqtt: subscribe %s failed", t)
+
+    def _request_sync(self, publish_items, subscribe_topics, match, timeout):
+        import queue as _queue
+        import time as _time
+        if not self._ensure_started_sync():
+            return [], {"error": "persistent mqtt connect timeout"}
+        self._subscribe_sync(subscribe_topics or [])
+        q = _queue.Queue()
+        with self._lock:
+            self._collectors.append(q)
+        collected = []
+        try:
+            for pt, pp in (publish_items or []):
+                self._client.publish(pt, pp)
+            deadline = _time.monotonic() + timeout
+            while True:
+                remaining = deadline - _time.monotonic()
+                if remaining <= 0:
+                    break
+                try:
+                    item = q.get(timeout=min(remaining, 0.1))
+                except _queue.Empty:
+                    continue
+                if match is None or match(item[0], item[1]):
+                    collected.append(item)
+        finally:
+            with self._lock:
+                try:
+                    self._collectors.remove(q)
+                except ValueError:
+                    pass
+        return collected, {"error": None}
+
+    async def request(self, publish_items, subscribe_topics=None, match=None, timeout=5.0):
+        """Publish ``publish_items`` and collect matching messages for ``timeout``
+        on the shared persistent connection (one connect for the account, reused).
+        Returns (messages, status)."""
+        import functools
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(None, functools.partial(
+            self._request_sync, publish_items, subscribe_topics, match, timeout))
+
+    async def ensure_connected(self, timeout=15.0):
+        import functools
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            None, functools.partial(self._ensure_started_sync, timeout))
+
+    def close(self):
+        c = self._client
+        self._client = None
+        self._started = False
+        self._connected.clear()
+        if c is not None:
+            try:
+                c.loop_stop()
+            except Exception:
+                pass
+            try:
+                c.disconnect()
+            except Exception:
+                pass
+
+
 async def _mqtt_session(
     mqtt_url: str,
     mqtt_user: str,

{python_aidot_cameras-0.7.26 → python_aidot_cameras-0.7.28}/src/aidot/client.py

@@ -529,6 +529,15 @@ class AidotClient:
         for client in self._device_clients.values():
             await client.close()
         self._device_clients.clear()
+        # Close the account-shared persistent MQTT connection, if one was opened
+        # (AIDOT_PERSISTENT_MQTT). Stored on the shared login_info by the camera
+        # command/attr paths; closing here stops its background paho loop.
+        pm = self.login_info.pop("_persistent_mqtt", None) if isinstance(self.login_info, dict) else None
+        if pm is not None:
+            try:
+                pm.close()
+            except Exception:
+                _LOGGER.debug("aidot: persistent mqtt close failed", exc_info=True)
 
     def cleanup(self) -> None:
         """Sync entry point: fire-and-forget async_close()."""

{python_aidot_cameras-0.7.26 → python_aidot_cameras-0.7.28/src/python_aidot_cameras.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.7.26
+Version: 0.7.28
 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
@@ -122,6 +122,8 @@ chosen to work out of the box; override only when tuning.
 | `AIDOT_SPROP_DIR` | Directory where captured SPS/PPS (sprop) parameter sets are cached. Set this to a writable path (e.g. for Home Assistant) if the default location is read-only. | `<package dir>` |
 | `AIDOT_DISABLE_HIGHPORT_FIX` | If set (any value), disables the DTLS high-port `USE-CANDIDATE` nomination fix and falls back to upstream aioice behavior (used to measure the baseline connect rate). | unset (fix enabled) |
 | `AIDOT_FAST_CONNECT` | Enables LAN-direct "fast connect" mode (STUN-only, skips several cloud signaling waits) when set to a truthy value. | unset (off) |
+| `AIDOT_PERSISTENT_MQTT` | Reuse ONE account-level persistent MQTT connection for device commands and attribute fetches (matching the official app) instead of connecting per operation, cutting cloud connect churn. Truthy value enables. The stream-open path is unaffected. | unset (off) |
+| `AIDOT_SDES_ADAPTIVE` | Adaptive fast-with-fallback for the SDES keepalive loop: try the fast path first (skip livePlay waits + TURN relay pre-alloc) and fall back to the full relay path if a fast attempt delivers no media. A per-device cache skips the fast attempt on later views once it has failed for a camera. Truthy value enables. | unset (off) |
 | `AIDOT_SDES_FAST_LIVEPLAY` | Truthy value skips the `livePlayResp` blocking wait for eligible SDES cameras (~4.5 s faster cold start), while keeping the full ICE/SCTP handshake. Role-reversal models (A001064 PTZ) are always excluded. Soak-validated; opt-in. | unset (off) |
 | `AIDOT_SERVE_RELAY` | Holds the public stream port via an internal relay that proxies to ffmpeg, so the first (cold) view connects instead of failing while ffmpeg can't pre-bind the port. Set to `0` to serve ffmpeg directly. | `1` (enabled) |
 | `AIDOT_MAX_CONCURRENT_OPENS` | Caps how many stream opens run concurrently. | `2` |

{python_aidot_cameras-0.7.26 → python_aidot_cameras-0.7.28}/src/python_aidot_cameras.egg-info/SOURCES.txt

@@ -42,7 +42,9 @@ tests/test_lan_control.py
 tests/test_live_stream_param.py
 tests/test_motion_poll.py
 tests/test_no_undefined_names.py
+tests/test_persistent_mqtt.py
 tests/test_post_merge_hardening.py
+tests/test_sdes_adaptive.py
 tests/test_sdes_fast_liveplay.py
 tests/test_sdes_idle_release.py
 tests/test_sdes_sprop.py

python_aidot_cameras-0.7.28/tests/test_persistent_mqtt.py

@@ -0,0 +1,68 @@
+"""Unit tests for the persistent-MQTT flag wiring (Phase 1).
+
+Locks the opt/env precedence of ``_resolve_persistent_mqtt`` (per-camera kwarg
+wins over AIDOT_PERSISTENT_MQTT env, default off) and the basic reuse semantics
+of the ``_PersistentMqtt`` collector routing. The live connection behaviour is
+validated on hardware, not here.
+"""
+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
+from aidot.camera.protocol import _PersistentMqtt
+
+_CAM = next(v for v in vars(cc).values()
+            if isinstance(v, type) and "_resolve_persistent_mqtt" in v.__dict__)
+
+
+def _cam():
+    return _CAM.__new__(_CAM)
+
+
+def test_default_off(monkeypatch):
+    monkeypatch.delenv("AIDOT_PERSISTENT_MQTT", raising=False)
+    assert _cam()._resolve_persistent_mqtt() is False
+
+
+def test_env_enables(monkeypatch):
+    for val in ("1", "true", "TRUE", "yes", "on", " On "):
+        monkeypatch.setenv("AIDOT_PERSISTENT_MQTT", val)
+        assert _cam()._resolve_persistent_mqtt() is True, val
+
+
+def test_env_falsey_stays_off(monkeypatch):
+    for val in ("0", "false", "no", "off", "", "anything"):
+        monkeypatch.setenv("AIDOT_PERSISTENT_MQTT", val)
+        assert _cam()._resolve_persistent_mqtt() is False, val
+
+
+def test_kwarg_wins_over_env(monkeypatch):
+    monkeypatch.setenv("AIDOT_PERSISTENT_MQTT", "1")
+    cam = _cam()
+    cam._persistent_mqtt_opt = False
+    assert cam._resolve_persistent_mqtt() is False
+
+
+def test_collector_routing_fans_out_messages():
+    # _on_message must fan every message out to every registered collector queue,
+    # so concurrent request()s each see the traffic (matching is per-collector).
+    import queue
+    pm = _PersistentMqtt("wss://h:8443/mqtt", "u", "p", "cid")
+    q1, q2 = queue.Queue(), queue.Queue()
+    pm._collectors = [q1, q2]
+
+    class _Msg:
+        topic = "iot/v1/cb/dev/x"
+        payload = b'{"k":1}'
+    pm._on_message(None, None, _Msg())
+    assert q1.get_nowait() == ("iot/v1/cb/dev/x", '{"k":1}')
+    assert q2.get_nowait() == ("iot/v1/cb/dev/x", '{"k":1}')
+
+
+def test_subscriptions_tracked_for_replay():
+    # subscribe topics must be remembered so they can be replayed on reconnect
+    pm = _PersistentMqtt("wss://h:8443/mqtt", "u", "p", "cid")
+    pm._subscribe_sync(["a/#", "b/#", "a/#"])  # no client yet -> just tracked
+    assert pm._subs == {"a/#", "b/#"}

python_aidot_cameras-0.7.28/tests/test_sdes_adaptive.py

@@ -0,0 +1,126 @@
+"""Unit tests for the SDES adaptive fast-with-fallback controller.
+
+The adaptive controller (default on) makes "fast by default" safe regardless of
+camera reachability: the SDES keepalive loop tries the fast path first (skip the
+livePlay waits + TURN relay pre-allocation, short timeout/grace) and falls back
+to the full relay path if a fast attempt delivers no media. These tests lock the
+decision state-machine and the resolver precedence so the wiring is verifiable
+without a camera; the real media/stability effect is validated by live soak.
+"""
+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 "_resolve_sdes_adaptive" in v.__dict__)
+
+
+def _cam():
+    return _CAM.__new__(_CAM)
+
+
+# --- _resolve_sdes_adaptive: opt-in, default OFF --------------------------- #
+
+def test_adaptive_default_off(monkeypatch):
+    monkeypatch.delenv("AIDOT_SDES_ADAPTIVE", raising=False)
+    assert _cam()._resolve_sdes_adaptive() is False
+
+
+def test_adaptive_env_enables(monkeypatch):
+    for val in ("1", "true", "TRUE", "yes", "on", " On "):
+        monkeypatch.setenv("AIDOT_SDES_ADAPTIVE", val)
+        assert _cam()._resolve_sdes_adaptive() is True, val
+
+
+def test_adaptive_env_falsey_stays_off(monkeypatch):
+    for val in ("0", "false", "no", "off", "", "anything"):
+        monkeypatch.setenv("AIDOT_SDES_ADAPTIVE", val)
+        assert _cam()._resolve_sdes_adaptive() is False, val
+
+
+def test_adaptive_kwarg_wins_over_env(monkeypatch):
+    monkeypatch.setenv("AIDOT_SDES_ADAPTIVE", "1")
+    cam = _cam()
+    cam._sdes_adaptive_opt = False  # start_keepalive(sdes_adaptive=False)
+    assert cam._resolve_sdes_adaptive() is False
+
+
+# --- decision state machine ------------------------------------------------ #
+
+def test_next_fast_only_when_adaptive_and_not_failed():
+    assert _CAM._adaptive_next_fast(True, False) is True
+    assert _CAM._adaptive_next_fast(True, True) is False   # latched off
+    assert _CAM._adaptive_next_fast(False, False) is False  # adaptive off
+
+
+def test_after_attempt_latches_on_fast_nomedia():
+    # a fast attempt that delivered no media latches fast_failed
+    assert _CAM._adaptive_after_attempt(True, False, False) is True
+    # a fast attempt that delivered media does NOT latch
+    assert _CAM._adaptive_after_attempt(True, True, False) is False
+    # a full attempt (use_fast False) never latches, regardless of media
+    assert _CAM._adaptive_after_attempt(False, False, False) is False
+    # once latched, it stays latched (no oscillation back to fast)
+    assert _CAM._adaptive_after_attempt(False, True, True) is True
+
+
+def test_full_lifecycle_fast_then_fallback_sticks():
+    adaptive, failed = True, False
+    # attempt 1: fast, no media -> latch
+    use_fast = _CAM._adaptive_next_fast(adaptive, failed)
+    assert use_fast is True
+    failed = _CAM._adaptive_after_attempt(use_fast, False, failed)
+    assert failed is True
+    # attempt 2: must be full now, and stays full even after a healthy session
+    use_fast = _CAM._adaptive_next_fast(adaptive, failed)
+    assert use_fast is False
+    failed = _CAM._adaptive_after_attempt(use_fast, True, failed)
+    assert failed is True
+
+
+# --- per-attempt override feeds the fast resolvers ------------------------- #
+
+def test_override_drives_skip_turn_resolver(monkeypatch):
+    monkeypatch.delenv("AIDOT_SDES_SKIP_TURN_PREALLOC", raising=False)
+    cam = _cam()
+    cam._fast_attempt_override = True
+    assert cam._resolve_sdes_skip_turn() is True
+    cam._fast_attempt_override = False
+    assert cam._resolve_sdes_skip_turn() is False
+
+
+def test_explicit_opt_beats_override(monkeypatch):
+    # an explicit user opt must win over the adaptive per-attempt override
+    cam = _cam()
+    cam._sdes_skip_turn_opt = False
+    cam._fast_attempt_override = True
+    assert cam._resolve_sdes_skip_turn() is False
+
+
+def test_cache_makes_next_view_skip_fast():
+    # A camera that previously failed the fast path latches _fast_path_unavailable,
+    # so the next keepalive loop starts already-failed and skips the fast attempt
+    # (no repeated ~40s fast timeout per fresh view). A fresh camera tries fast.
+    cached = _cam()
+    cached._fast_path_unavailable = True
+    init_failed = bool(getattr(cached, "_fast_path_unavailable", False))
+    assert init_failed is True
+    assert _CAM._adaptive_next_fast(True, init_failed) is False
+
+    fresh = _cam()
+    init_fresh = bool(getattr(fresh, "_fast_path_unavailable", False))
+    assert init_fresh is False
+    assert _CAM._adaptive_next_fast(True, init_fresh) is True
+
+
+def test_override_respects_role_reversal_exclusion(monkeypatch):
+    from types import SimpleNamespace
+    monkeypatch.delenv("AIDOT_SDES_FAST_LIVEPLAY", raising=False)
+    cam = _cam()
+    cam.info = SimpleNamespace(model_id="LK.IPC.A001064")
+    cam._fast_attempt_override = True  # adaptive would try fast...
+    # ...but the role-reversal model is excluded from fast-liveplay regardless
+    assert cam._resolve_sdes_fast_liveplay() is False