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

{python_aidot_cameras-0.7.27/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.27
+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,7 @@ 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) |

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

@@ -95,6 +95,7 @@ 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) |

{python_aidot_cameras-0.7.27 → 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.27"
+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.27 → 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:
@@ -2659,6 +2681,46 @@ class CameraMixin(_CameraControlsMixin):
         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

{python_aidot_cameras-0.7.27 → 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.27 → 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.27 → 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.27
+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,7 @@ 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) |

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

@@ -42,6 +42,7 @@ 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

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/#"}