python-aidot-cameras 0.12.0__tar.gz → 0.12.2__tar.gz

{python_aidot_cameras-0.12.0/python_aidot_cameras.egg-info → python_aidot_cameras-0.12.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.12.0
+Version: 0.12.2
 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

{python_aidot_cameras-0.12.0 → python_aidot_cameras-0.12.2}/aidot_cameras/camera/client.py

@@ -2645,9 +2645,15 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
 
     async def _deregister_go2rtc(self) -> None:
         """Remove this camera's stream from go2rtc (best-effort)."""
-        base, pull = self._go2rtc_url, self._go2rtc_pull_url
+        base = self._go2rtc_url
         self._go2rtc_pull_url = None
-        if not (base and pull):
+        # Deliberately NOT gated on `pull`: go2rtc answers the register call with
+        # 400 when it cannot immediately validate the source (a camera that has
+        # not started producing yet), yet it still keeps the stream registered.
+        # ensure_stream reports that as failure, so pull stays None - and gating
+        # on it here leaked one dead stream per attempt, which then sat in go2rtc
+        # with a producer nothing was feeding.
+        if not base:
             return
         import aiohttp
         from .go2rtc import Go2rtcClient
@@ -3396,7 +3402,30 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
             if not mqtt_url:
                 return None
             from .protocol import _PersistentMqtt
-            pm = _PersistentMqtt(mqtt_url, mqtt_user, mqtt_pwd, client_id)
+
+            def _invalidate_mqtt_credentials(rc) -> None:
+                """Drop the cached MQTT password so the next use re-fetches it.
+
+                The broker rotates this password on every account login and
+                allows one connection at a time, so any other login (the phone
+                app, a second Home Assistant, a script) invalidates ours.  The
+                cached copy lives in login_info, where it short-circuits the
+                credential fetch, so it has to be cleared or every retry reuses
+                the dead password.  The persistent client itself is dropped too,
+                so the next request rebuilds it with fresh credentials.
+                """
+                for key in ("mqttPassword", "mqttPwd"):
+                    if li.pop(key, None) is not None:
+                        _LOGGER.warning(
+                            "cleared the cached MQTT password after the broker "
+                            "rejected it (rc=%s); it will be re-fetched", rc,
+                        )
+                self._smarthome_auth = None
+                if li.get(LOGIN_INFO_PERSISTENT_MQTT_KEY) is pm:
+                    li.pop(LOGIN_INFO_PERSISTENT_MQTT_KEY, None)
+
+            pm = _PersistentMqtt(mqtt_url, mqtt_user, mqtt_pwd, client_id,
+                                 on_auth_failure=_invalidate_mqtt_credentials)
             li[LOGIN_INFO_PERSISTENT_MQTT_KEY] = pm
             return pm
 

{python_aidot_cameras-0.12.0 → python_aidot_cameras-0.12.2}/aidot_cameras/camera/protocol.py

@@ -1414,12 +1414,26 @@ class _PersistentMqtt:
     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"):
+    # Connect return codes meaning "these credentials are not acceptable"
+    # rather than "try again later".  4/5 are MQTT 3.1.1 (bad user/pass, not
+    # authorized); 134/135 are the MQTT 5 equivalents (0x86/0x87).  The AiDot
+    # broker rotates the MQTT password on every account login and allows one
+    # connection at a time, so a cached password can go stale at any moment -
+    # a login from the phone app is enough.  Retrying it forever is useless;
+    # the owner has to fetch a fresh credential.
+    _AUTH_REFUSAL_RCS = frozenset({4, 5, 134, 135})
+
+    def __init__(self, mqtt_url, mqtt_user, mqtt_pwd, client_id, ws_path="/mqtt",
+                 on_auth_failure=None):
         self._url = mqtt_url
         self._user = mqtt_user
         self._pwd = mqtt_pwd
         self._cid = client_id
         self._ws_path = ws_path
+        # Invoked (once per instance) when the broker rejects our credentials so
+        # the owner can invalidate its cache and re-authenticate.
+        self._on_auth_failure = on_auth_failure
+        self._auth_failed_reported = False
         self._client = None
         self._host = None
         self._port = None
@@ -1476,6 +1490,21 @@ class _PersistentMqtt:
                 except Exception:
                     _LOGGER.debug("persistent mqtt: resubscribe %s failed", t)
             self._connected.set()
+        elif rc in self._AUTH_REFUSAL_RCS:
+            # Stale credential: paho would retry this password forever.  Tell the
+            # owner once so it can invalidate its cache and re-authenticate.
+            _LOGGER.warning(
+                "persistent mqtt: broker rejected our credentials (rc=%s) - the "
+                "MQTT password has almost certainly been rotated by another "
+                "login; requesting a fresh one", rc,
+            )
+            if self._on_auth_failure and not self._auth_failed_reported:
+                self._auth_failed_reported = True
+                try:
+                    self._on_auth_failure(rc)
+                except Exception:
+                    _LOGGER.debug("persistent mqtt: on_auth_failure raised",
+                                  exc_info=True)
         else:
             _LOGGER.warning("persistent mqtt: broker refused rc=%s", rc)
 

{python_aidot_cameras-0.12.0 → python_aidot_cameras-0.12.2}/aidot_cameras/client.py

@@ -464,6 +464,13 @@ class CameraClient(_UpstreamAidotClient):
         The HTTP calls themselves are still upstream's ``CloudApi``.
         """
         final_device_list: list[dict[str, Any]] = []
+        # Devices upstream's client cannot construct (no usable aesKey): Zigbee
+        # sub-devices, remotes, and other accessories that were never supported
+        # here.  They are counted and reported once, not warned about
+        # individually - an account with a dozen Zigbee sensors would otherwise
+        # log a dozen WARNINGs on every refresh for devices nothing was ever
+        # going to use.
+        unbuildable: dict[str, int] = {}
         houses = await self._cloud_api.get_houses() or []
         for house in houses:
             if house.get(CONF_IS_OWNER) is False:
@@ -473,11 +480,19 @@ class CameraClient(_UpstreamAidotClient):
                 if _is_camera_device(device) or _upstream_can_build(device):
                     final_device_list.append(device)
                 else:
-                    _LOGGER.warning(
-                        "skipping device %s (%s): no AES key, upstream's device "
-                        "client cannot be built for it",
-                        device.get(CONF_ID), device.get(CONF_MODEL_ID),
+                    model = device.get(CONF_MODEL_ID) or "unknown"
+                    unbuildable[model] = unbuildable.get(model, 0) + 1
+                    _LOGGER.debug(
+                        "skipping device %s (%s): no usable aesKey, upstream's "
+                        "device client cannot be built for it",
+                        device.get(CONF_ID), model,
                     )
+        if unbuildable:
+            _LOGGER.info(
+                "skipped %d device(s) with no usable aesKey (not supported here): %s",
+                sum(unbuildable.values()),
+                ", ".join(f"{m} x{n}" for m, n in sorted(unbuildable.items())),
+            )
 
         product_ids = ",".join(
             sorted(

{python_aidot_cameras-0.12.0 → python_aidot_cameras-0.12.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-aidot-cameras"
-version = "0.12.0"
+version = "0.12.2"
 description = "Control AiDot/Leedarson WiFi lights and cameras (WebRTC streaming, two-way audio, PTZ, controls)"
 readme = "README.md"
 license = "MIT"

{python_aidot_cameras-0.12.0 → python_aidot_cameras-0.12.2/python_aidot_cameras.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.12.0
+Version: 0.12.2
 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

{python_aidot_cameras-0.12.0 → python_aidot_cameras-0.12.2}/python_aidot_cameras.egg-info/SOURCES.txt

@@ -91,6 +91,7 @@ tests/test_light_active_color_mode.py
 tests/test_live_stream_param.py
 tests/test_logging_caps.py
 tests/test_motion_poll.py
+tests/test_mqtt_credential_self_heal.py
 tests/test_mqtt_session_reconnect.py
 tests/test_narrow_pc_ice.py
 tests/test_no_undefined_names.py

python_aidot_cameras-0.12.2/tests/test_mqtt_credential_self_heal.py

@@ -0,0 +1,52 @@
+"""The broker rotates the MQTT password on every account login and allows one
+connection at a time, so a cached password goes stale whenever anything else
+logs in (the phone app is enough).  paho would retry the dead password forever,
+so a credential refusal has to invalidate the cache instead.
+"""
+import aidot_cameras.camera.protocol as proto
+
+
+def _pm(on_auth_failure=None):
+    return proto._PersistentMqtt(
+        "wss://broker.example:8443/mqtt", "user", "stale-pwd", "app-user",
+        on_auth_failure=on_auth_failure,
+    )
+
+
+def test_auth_refusal_codes_cover_mqtt3_and_mqtt5():
+    # 4/5 are MQTT 3.1.1 bad-user-pass / not-authorized; 134/135 are the MQTT 5
+    # equivalents (0x86/0x87) - the AiDot broker answers with 134.
+    for rc in (4, 5, 134, 135):
+        assert rc in proto._PersistentMqtt._AUTH_REFUSAL_RCS, rc
+
+
+def test_credential_refusal_invokes_the_callback_once():
+    seen = []
+    pm = _pm(on_auth_failure=seen.append)
+    pm._on_connect(None, None, {}, 134)
+    pm._on_connect(None, None, {}, 134)   # repeated refusal must not re-notify
+    assert seen == [134]
+
+
+def test_transient_refusal_does_not_invalidate_credentials():
+    # rc=3 is "server unavailable" - retrying the same password is correct.
+    seen = []
+    pm = _pm(on_auth_failure=seen.append)
+    pm._on_connect(None, None, {}, 3)
+    assert seen == []
+
+
+def test_successful_connect_does_not_invalidate_credentials():
+    seen = []
+    pm = _pm(on_auth_failure=seen.append)
+    pm._on_connect(None, None, {}, 0)
+    assert seen == []
+    assert pm._connected.is_set()
+
+
+def test_callback_exception_is_contained():
+    def boom(rc):
+        raise RuntimeError("callback exploded")
+
+    pm = _pm(on_auth_failure=boom)
+    pm._on_connect(None, None, {}, 134)   # must not propagate into paho's loop