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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.7.28
+Version: 0.7.30
 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,7 +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_PERSISTENT_MQTT` | Reuse ONE account-level persistent MQTT connection for device commands, attribute fetches, AND stream-open signaling (matching the official app) instead of connecting per operation, cutting cloud connect churn. **On by default** (the app's behaviour; live soak cut SDES NO_MEDIA ~57%→~19%); set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
 | `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.28 → python_aidot_cameras-0.7.30}/README.md

@@ -95,7 +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_PERSISTENT_MQTT` | Reuse ONE account-level persistent MQTT connection for device commands, attribute fetches, AND stream-open signaling (matching the official app) instead of connecting per operation, cutting cloud connect churn. **On by default** (the app's behaviour; live soak cut SDES NO_MEDIA ~57%→~19%); set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
 | `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.28 → python_aidot_cameras-0.7.30}/pyproject.toml

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

@@ -2682,16 +2682,21 @@ class CameraMixin(_CameraControlsMixin):
             "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)."""
+        """Whether commands, attribute fetches, AND stream-open signaling reuse ONE
+        account-level persistent MQTT connection (matching the app's
+        LDSBaseMqttServiceImpl) instead of connecting per op.
+
+        **Default ON** (2026-06-17): this is exactly how the official app behaves -
+        one persistent connection per login session - and a live soak showed it
+        cuts SDES NO_MEDIA from ~57% to ~19% (no regression). It is also safer
+        than connect-per-op, which can collide on the single authorized client_id.
+        Disable via ``AIDOT_PERSISTENT_MQTT`` in {0,false,no,off} or per-camera
+        ``_persistent_mqtt_opt=False`` (the explicit opt always wins)."""
         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")
+        return os.environ.get("AIDOT_PERSISTENT_MQTT", "").strip().lower() not in (
+            "0", "false", "no", "off")
 
     async def _get_persistent_mqtt(self):
         """Get-or-create the account-shared ``_PersistentMqtt`` (one per account,
@@ -4093,16 +4098,40 @@ class CameraMixin(_CameraControlsMixin):
                     )
                 )
 
-        # Run MQTT in a thread executor (very long duration; stopped via
-        # outgoing_q sentinel when the caller calls WebRTCSession.stop()).
-        mqtt_fut = loop.run_in_executor(
-            None,
-            lambda: _mqtt_session_sync(
-                mqtt_url, mqtt_user, mqtt_pwd, mqtt_cid,
-                sub_topics, [], 3600.0, _on_mqtt_message,
-                "/mqtt", _on_mqtt_ready, outgoing_q,
-            ),
-        )
+        # MQTT transport for the stream signaling.  Default: a dedicated
+        # connect-per-stream session in an executor (stopped via outgoing_q
+        # sentinel on WebRTCSession.stop()).  AIDOT_PERSISTENT_MQTT (Phase 2):
+        # ride the SAME account-level persistent connection commands/attrs use
+        # (the stream's mqtt_cid IS the authorized mqttClientId, so it's the same
+        # connection) - subscribe + register a handler + drain outgoing_q through
+        # it, and DON'T tear the connection down on stop (matching the app).
+        _pm_stream = (await self._get_persistent_mqtt()
+                      if self._resolve_persistent_mqtt() else None)
+        if _pm_stream is not None:
+            await _pm_stream.subscribe(sub_topics)
+            _pm_stream.add_handler(_on_mqtt_message)
+
+            async def _pm_stream_drain():
+                try:
+                    while True:
+                        out = await loop.run_in_executor(None, outgoing_q.get)
+                        if out is None:   # stop sentinel from WebRTCSession.stop()
+                            return
+                        await _pm_stream.publish(out[0], out[1])
+                finally:
+                    _pm_stream.remove_handler(_on_mqtt_message)
+
+            mqtt_fut = asyncio.ensure_future(_pm_stream_drain())
+            _on_mqtt_ready({"connected": True, "rc": 0, "rc_str": "persistent"})
+        else:
+            mqtt_fut = loop.run_in_executor(
+                None,
+                lambda: _mqtt_session_sync(
+                    mqtt_url, mqtt_user, mqtt_pwd, mqtt_cid,
+                    sub_topics, [], 3600.0, _on_mqtt_message,
+                    "/mqtt", _on_mqtt_ready, outgoing_q,
+                ),
+            )
 
         # Wait for MQTT to be connected and subscribed before proceeding.
         # threading.Event.wait(timeout) returns True if set, False on timeout.

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

@@ -1270,6 +1270,7 @@ class _PersistentMqtt:
         self._lock = threading.Lock()
         self._subs = set()         # topics to (re)subscribe on connect
         self._collectors = []      # transient queues, each receives every msg
+        self._handlers = []        # persistent on_message callbacks (e.g. a stream)
         self._started = False
         self.connects = 0          # observability: how many times we connected
 
@@ -1330,8 +1331,14 @@ class _PersistentMqtt:
         item = (msg.topic, payload)
         with self._lock:
             cols = list(self._collectors)
+            handlers = list(self._handlers)
         for q in cols:
             q.put(item)
+        for h in handlers:                 # persistent subscribers (stream, etc.)
+            try:
+                h(msg.topic, payload)
+            except Exception:
+                _LOGGER.debug("persistent mqtt: handler raised", exc_info=True)
 
     def _ensure_started_sync(self, timeout=15.0):
         with self._lock:
@@ -1409,6 +1416,44 @@ class _PersistentMqtt:
         return await loop.run_in_executor(
             None, functools.partial(self._ensure_started_sync, timeout))
 
+    # --- persistent subscriber API (for the stream signaling, Phase 2) -------- #
+    def add_handler(self, callback):
+        """Register a persistent on_message callback ``callback(topic, payload)``
+        that receives every message for the connection's lifetime (until removed).
+        Use for a long-lived consumer like an open stream's signaling handler."""
+        with self._lock:
+            self._handlers.append(callback)
+        return callback
+
+    def remove_handler(self, callback):
+        with self._lock:
+            try:
+                self._handlers.remove(callback)
+            except ValueError:
+                pass
+
+    async def subscribe(self, topics):
+        """Ensure the connection is up and subscribe ``topics`` (tracked for replay)."""
+        import functools
+        loop = asyncio.get_running_loop()
+        await loop.run_in_executor(None, self._ensure_started_sync, 15.0)
+        await loop.run_in_executor(None, functools.partial(self._subscribe_sync, topics))
+
+    async def publish(self, topic, payload):
+        """Publish on the shared connection (ensures it's up first)."""
+        import functools
+
+        def _pub():
+            if not self._ensure_started_sync():
+                return False
+            try:
+                self._client.publish(topic, payload)
+                return True
+            except Exception:
+                return False
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(None, functools.partial(_pub))
+
     def close(self):
         c = self._client
         self._client = None

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.7.28
+Version: 0.7.30
 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,7 +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_PERSISTENT_MQTT` | Reuse ONE account-level persistent MQTT connection for device commands, attribute fetches, AND stream-open signaling (matching the official app) instead of connecting per operation, cutting cloud connect churn. **On by default** (the app's behaviour; live soak cut SDES NO_MEDIA ~57%→~19%); set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
 | `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.28 → python_aidot_cameras-0.7.30}/tests/test_persistent_mqtt.py

@@ -21,25 +21,27 @@ def _cam():
     return _CAM.__new__(_CAM)
 
 
-def test_default_off(monkeypatch):
+def test_default_on(monkeypatch):
+    # default ON (matches the app's single persistent connection)
     monkeypatch.delenv("AIDOT_PERSISTENT_MQTT", raising=False)
-    assert _cam()._resolve_persistent_mqtt() is False
+    assert _cam()._resolve_persistent_mqtt() is True
 
 
-def test_env_enables(monkeypatch):
-    for val in ("1", "true", "TRUE", "yes", "on", " On "):
+def test_env_disables(monkeypatch):
+    for val in ("0", "false", "FALSE", "no", "off", " Off "):
         monkeypatch.setenv("AIDOT_PERSISTENT_MQTT", val)
-        assert _cam()._resolve_persistent_mqtt() is True, val
+        assert _cam()._resolve_persistent_mqtt() is False, val
 
 
-def test_env_falsey_stays_off(monkeypatch):
-    for val in ("0", "false", "no", "off", "", "anything"):
+def test_env_truthy_or_unknown_stays_on(monkeypatch):
+    for val in ("1", "true", "yes", "on", "anything"):
         monkeypatch.setenv("AIDOT_PERSISTENT_MQTT", val)
-        assert _cam()._resolve_persistent_mqtt() is False, val
+        assert _cam()._resolve_persistent_mqtt() is True, val
 
 
-def test_kwarg_wins_over_env(monkeypatch):
-    monkeypatch.setenv("AIDOT_PERSISTENT_MQTT", "1")
+def test_kwarg_off_wins_over_default(monkeypatch):
+    # an explicit opt=False (e.g. user turned the HA toggle off) overrides default-on
+    monkeypatch.delenv("AIDOT_PERSISTENT_MQTT", raising=False)
     cam = _cam()
     cam._persistent_mqtt_opt = False
     assert cam._resolve_persistent_mqtt() is False