python-aidot-cameras 1.0.0rc4__tar.gz → 1.0.0rc5__tar.gz

{python_aidot_cameras-1.0.0rc4/python_aidot_cameras.egg-info → python_aidot_cameras-1.0.0rc5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 1.0.0rc4
+Version: 1.0.0rc5
 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-1.0.0rc4 → python_aidot_cameras-1.0.0rc5}/aidot_cameras/camera/client.py

@@ -2675,12 +2675,53 @@ class CameraMixin(_CameraControlsMixin, _CameraSdMixin, _WebRTCOpenMixin, _SdesO
         publish_items = [
             (f"iot/v1/s/{user_id}/device/devActionReq", payload),
         ]
-        messages, _st = await _mqtt_session_with_status(
-            mqtt_url, mqtt_user, mqtt_pwd, client_id,
-            subscribe_topics=[f"iot/v1/c/{user_id}/#", f"iot/v1/cb/{user_id}/#"],
-            publish_items=publish_items,
-            duration=timeout,
-        )
+        sub_topics = [f"iot/v1/c/{user_id}/#", f"iot/v1/cb/{user_id}/#"]
+
+        # Use the PERSISTENT connection when there is one, exactly as
+        # `_mqtt_device_cmd` does. Opening a fresh session here instead looked
+        # harmless and is not: it connects with the same `mqttClientId` the
+        # long-lived connection is already using, and a broker evicts the older
+        # session on a duplicate client id. Inside Home Assistant that means the
+        # query and the integration's own connection knock each other off, and
+        # the reply never arrives -- the request appears to work and simply
+        # returns nothing. It only "worked" when tested with the integration
+        # stopped, which is the one condition that hides the conflict.
+        messages = []
+        pm = await self._get_persistent_mqtt() if self._resolve_persistent_mqtt() else None
+        if pm is not None:
+            messages, _st = await pm.request(
+                publish_items=publish_items,
+                subscribe_topics=sub_topics,
+                timeout=timeout,
+            )
+            if _st and _st.get("error"):
+                _LOGGER.debug(
+                    "async_query_device_action: persistent MQTT failed (%s); "
+                    "falling back for %s", _st.get("error"), device_id)
+                pm = None
+        if pm is None:
+            messages, _st = await _mqtt_session_with_status(
+                mqtt_url, mqtt_user, mqtt_pwd, client_id,
+                subscribe_topics=sub_topics,
+                publish_items=publish_items,
+                duration=timeout,
+            )
+        # Several devAction messages can be in flight on a shared connection,
+        # and some carry no `out` at all (a bare acknowledgement). Taking the
+        # first match therefore loses data: a camera reporting six sound
+        # detectors surfaced only the two from whichever reply arrived first.
+        # So prefer a reply that actually carries a payload, and only fall back
+        # to an empty one when nothing better arrived.
+        # Two passes' worth of preference, resolved in one:
+        #   best  - right device, right action, our seq, and a payload
+        #   good  - right device, right action, a payload
+        # `seq` is a PREFERENCE, never a filter. Requiring it looked tidy and
+        # was wrong: a camera that does not echo our seq has every one of its
+        # replies discarded, and the call then reports "no reply" for a camera
+        # that answered. Observed live as `no reply from <device> (4 messages
+        # seen)` -- four candidates rejected on the seq alone.
+        best = good = None
+        _empty_seen = False
         for topic, raw in messages:
             if "devAction" not in topic:
                 continue
@@ -2691,8 +2732,44 @@ class CameraMixin(_CameraControlsMixin, _CameraSdMixin, _WebRTCOpenMixin, _SdesO
             body = msg.get("payload") or {}
             if body.get("action") != action:
                 continue
-            return body.get("out")
-        _LOGGER.debug("devActionReq %s: no reply from %s", action, device_id)
+            # Match the DEVICE too. The persistent connection is subscribed to
+            # the whole account (`iot/v1/c/{userId}/#`), so replies for every
+            # camera arrive here -- matching on the action alone lets one
+            # camera read another's answer. Observed live: four cameras all
+            # reported the same SD figures, which belonged to whichever camera
+            # answered first.
+            # The device match IS a filter: the persistent connection carries
+            # the whole account, and without this one camera reads another's
+            # answer (observed live as four cameras reporting identical SD
+            # figures).
+            _rid = body.get("devId") or msg.get("id")
+            if _rid and _rid != device_id:
+                continue
+            out = body.get("out")
+            if out is None:
+                _empty_seen = True
+                continue
+            if msg.get("seq") == seq:
+                best = out
+                break
+            if good is None:
+                good = out
+        if best is not None:
+            return best
+        if good is not None:
+            _LOGGER.debug(
+                "devActionReq %s: accepted a reply for %s without a seq match",
+                action, device_id)
+            return good
+        if _empty_seen:
+            _LOGGER.debug("devActionReq %s: only empty replies from %s",
+                          action, device_id)
+            return None
+        # Never return None silently: a caller cannot tell "unsupported" from
+        # "the reply never came back", and a silent None is what made this
+        # failure invisible for an entire debugging session.
+        _LOGGER.info("devActionReq %s: no reply from %s (%d messages seen)",
+                     action, device_id, len(messages))
         return None
 
     async def async_trigger_device_action(

{python_aidot_cameras-1.0.0rc4 → python_aidot_cameras-1.0.0rc5}/pyproject.toml

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

{python_aidot_cameras-1.0.0rc4 → python_aidot_cameras-1.0.0rc5/python_aidot_cameras.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 1.0.0rc4
+Version: 1.0.0rc5
 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-1.0.0rc4 → python_aidot_cameras-1.0.0rc5}/tests/test_camera_properties.py

@@ -104,3 +104,67 @@ class TestSdCardInfo:
 
     def test_no_reply_is_none(self):
         assert asyncio.run(_Cam(None).async_get_sd_card_info()) is None
+
+
+class TestItDoesNotFightTheIntegrationsConnection:
+    """The query must reuse the persistent MQTT connection when there is one.
+
+    Opening a fresh session uses the same `mqttClientId` the long-lived
+    connection already holds, and a broker evicts the older session on a
+    duplicate client id. Inside Home Assistant that means the query and the
+    integration knock each other off and the reply never arrives -- which looks
+    exactly like "this camera does not support the action".
+    """
+
+    def test_the_query_prefers_the_persistent_connection(self):
+        import inspect
+        from aidot_cameras.camera import client as client_mod
+        src = inspect.getsource(client_mod.CameraMixin.async_query_device_action)
+        assert "_get_persistent_mqtt" in src, (
+            "the query opens its own MQTT session again - that duplicates the "
+            "client id and the reply is lost inside Home Assistant")
+        assert "_resolve_persistent_mqtt" in src
+
+    def test_a_missing_reply_is_logged_not_silent(self):
+        import inspect
+        from aidot_cameras.camera import client as client_mod
+        src = inspect.getsource(client_mod.CameraMixin.async_query_device_action)
+        assert "no reply from" in src
+        # INFO, not debug: a silent None is what hid this failure. Find the
+        # logging call that owns the message rather than guessing at a
+        # character window near it.
+        import re
+        call = re.search(r'_LOGGER\.(\w+)\(\s*\n?\s*"[^"]*no reply from', src)
+        assert call is not None, "the no-reply message is not a logging call"
+        assert call.group(1) == "info", (
+            f"the no-reply message logs at {call.group(1)}, not info")
+
+
+class TestRepliesAreMatchedToTheRightCamera:
+    """The persistent connection carries the whole account's traffic.
+
+    Observed live: all four cameras reported identical SD figures, because the
+    matcher keyed on the action alone and each camera accepted whichever reply
+    arrived first.
+    """
+
+    def test_it_filters_on_the_device_id(self):
+        import inspect
+        from aidot_cameras.camera import client as client_mod
+        src = inspect.getsource(client_mod.CameraMixin.async_query_device_action)
+        assert 'body.get("devId")' in src
+        assert "!= device_id" in src
+
+    def test_seq_is_a_preference_not_a_filter(self):
+        """Requiring the seq discards every reply from a camera that does not
+        echo it -- seen live as "no reply (4 messages seen)" on a camera that
+        had in fact answered four times."""
+        import inspect
+        from aidot_cameras.camera import client as client_mod
+        src = inspect.getsource(client_mod.CameraMixin.async_query_device_action)
+        assert 'msg.get("seq") == seq' in src, "seq should still be preferred"
+        # The rejecting form must be gone.
+        assert "_rseq != seq" not in src
+        assert "if _rseq and" not in src
+        # A reply without a matching seq must still be usable.
+        assert "good" in src