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

{python_aidot_cameras-1.0.0rc3/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.0rc3
+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.0rc3 → python_aidot_cameras-1.0.0rc5}/aidot_cameras/camera/client.py

@@ -2376,9 +2376,15 @@ class CameraMixin(_CameraControlsMixin, _CameraSdMixin, _WebRTCOpenMixin, _SdesO
         timeout: float = 8.0,
         ack_keyword: str = "setDevAttr",
         seq: "Optional[str]" = None,
+        expect_ack: bool = True,
     ) -> bool:
         """Connect MQTT, optionally wake battery camera, publish command, wait for ack.
 
+        ``expect_ack=False`` reports whether the command was PUBLISHED, not
+        whether the camera answered. That is the honest result for an action
+        whose success removes the camera from the network -- a reboot acks by
+        going away, so waiting for one turns a working command into a False.
+
         All setDevAttrReq callers in the APK (b6.java, LiveCameraView, etc.)
         are in live-view screens where the camera is already awake and MQTT-
         connected.  For battery cameras we send lowPowerActiveStateReq first so
@@ -2454,6 +2460,17 @@ class CameraMixin(_CameraControlsMixin, _CameraSdMixin, _WebRTCOpenMixin, _SdesO
                 duration=timeout,
             )
 
+        # A fire-and-forget caller only needs to know the publish left the host.
+        # `_st` separates that from "no ack came back", which the ack scan below
+        # cannot: it returns False for a failed publish and for a camera that
+        # rebooted before answering.
+        if not expect_ack:
+            _published = not (_st and _st.get("error"))
+            _LOGGER.info(
+                "_mqtt_device_cmd: published without waiting for an ack "
+                "(topic=%s published=%s)", pub_topic, _published)
+            return _published
+
         # Two passes, because being sure is worth more than being quick. A
         # response carrying OUR seq is proof; anything else on these topics is
         # only evidence that SOMETHING was acked - and several things are in
@@ -2546,6 +2563,7 @@ class CameraMixin(_CameraControlsMixin, _CameraSdMixin, _WebRTCOpenMixin, _SdesO
         """
         import json as _json
         import random as _random
+        import time as _time
 
         lan = getattr(self, "_lan_client", None)
         if lan is not None:
@@ -2567,11 +2585,17 @@ class CameraMixin(_CameraControlsMixin, _CameraSdMixin, _WebRTCOpenMixin, _SdesO
             inner["userId"] = str(user_id)
         if cam_pwd:
             inner["password"] = cam_pwd
+        # `tst` matches the app, which stamps every setDevAttrReq and
+        # devActionReq it builds. The camera accepts the message without it --
+        # this path is proven and reads back within one poll -- so this is
+        # parity rather than a fix; it costs nothing and removes one more way
+        # our traffic differs from the vendor's.
         payload = _json.dumps({
             "id":      device_id,
             "method":  "setDevAttrReq",
             "service": "device",
             "seq":     seq,
+            "tst":     int(_time.time() * 1000),
             "payload": inner,
         })
         pub_topic = f"iot/v1/c/{device_id}/device/setDevAttrReq"
@@ -2592,12 +2616,169 @@ class CameraMixin(_CameraControlsMixin, _CameraSdMixin, _WebRTCOpenMixin, _SdesO
                 _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), 'async_set_device_attribute', exc_info=True)
         return ok
 
+    async def async_query_device_action(
+        self,
+        action: str,
+        params=None,
+        *,
+        timeout: float = 8.0,
+    ):
+        """Send a read-only devActionReq and return the camera's ``out`` payload.
+
+        :meth:`async_trigger_device_action` answers "did it go", which is all a
+        control needs. But the camera *answers* its ``get`` actions with real
+        data -- wifi details, SD capacity, which sound algorithms are armed --
+        and none of that was reachable while the only helper returned a bool.
+
+        Returns the decoded ``out`` exactly as the camera sent it (list or
+        dict), or ``None`` when nothing came back. ``None`` means UNKNOWN, not
+        "off": several of these actions answer with ``out: null`` on models that
+        do not implement them, and a caller that reads that as a disabled
+        feature will report a camera as having something switched off when it
+        simply cannot say.
+
+        Deliberately built on the module-level session helper rather than on
+        :meth:`_mqtt_device_cmd`: that method reduces a reply to a bool and is
+        the proven control path, so it is left alone.
+        """
+        import json as _json
+        import random as _random
+        import time as _time
+
+        user_id   = self.user_id
+        device_id = self.device_id
+        smarthome_auth = await self._async_get_smarthome_auth()
+        mqtt_url = await self._async_get_mqtt_url()
+        if not mqtt_url:
+            _LOGGER.debug("async_query_device_action: no MQTT URL for %s", device_id)
+            return None
+        mqtt_user = (smarthome_auth or {}).get("mqttUser") or str(user_id)
+        mqtt_pwd  = (smarthome_auth or {}).get("mqttPassword") or ""
+        client_id = (self._user_info.get("mqttClientId") or f"app-{mqtt_user}")
+
+        _dev = self._camera_properties() or {}
+        parent_id = (getattr(getattr(self, "info", None), "direct_id", None)
+                     or _dev.get("directId") or _dev.get("parentId") or device_id)
+        seq = f"ap{_random.randint(1000000, 9999999)}"
+        payload = _json.dumps({
+            "method":  "devActionReq",
+            "service": "device",
+            "seq":     seq,
+            "tst":     int(_time.time() * 1000),
+            "payload": {
+                "devId":    device_id,
+                "parentId": parent_id,
+                "action":   action,
+                "in":       params if params is not None else [],
+            },
+        })
+        publish_items = [
+            (f"iot/v1/s/{user_id}/device/devActionReq", payload),
+        ]
+        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
+            try:
+                msg = _json.loads(raw)
+            except Exception:
+                continue
+            body = msg.get("payload") or {}
+            if body.get("action") != action:
+                continue
+            # 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(
         self,
         action: str,
         params,
         *,
         timeout: float = 4.0,
+        expect_ack: bool = True,
     ) -> bool:
         """Send a devActionReq (e.g. siren/alarm trigger).
 
@@ -2607,23 +2788,42 @@ class CameraMixin(_CameraControlsMixin, _CameraSdMixin, _WebRTCOpenMixin, _SdesO
                     "payload": {"devId": deviceId, "action": action, "in": params}}
         """
         import json as _json
+        import random as _random
+        import time as _time
 
         user_id   = self.user_id
         device_id = self.device_id
 
+        # The app's own builder (main chunk, DeviceControl) sends five things we
+        # did not: `seq`, `tst`, and a `parentId` alongside `devId`. The camera
+        # answers nothing at all to a devActionReq without them -- a RebootFunc
+        # sent in the short form drew zero replies and did not reboot, while the
+        # same action with these fields is what the settings page uses.
+        #
+        # `password` is deliberately NOT sent: the H5 passes it to its wrapper,
+        # but the wrapper does not put it on the wire, and a read-only
+        # `WifiBaseInfo` acks without it.
+        _dev = self._camera_properties() or {}
+        parent_id = (getattr(getattr(self, "info", None), "direct_id", None)
+                     or _dev.get("directId") or _dev.get("parentId") or device_id)
+        seq = f"ap{_random.randint(1000000, 9999999)}"
         payload = _json.dumps({
             "method":  "devActionReq",
             "service": "device",
+            "seq":     seq,
+            "tst":     int(_time.time() * 1000),
             "payload": {
-                "devId":  device_id,
-                "action": action,
-                "in":     params,
+                "devId":    device_id,
+                "parentId": parent_id,
+                "action":   action,
+                "in":       params,
             },
         })
         pub_topic = f"iot/v1/s/{user_id}/device/devActionReq"
         _LOGGER.info("devActionReq: %s %s -> %s", action, params, device_id)
         return await self._mqtt_device_cmd(
-            pub_topic, payload, timeout=timeout, ack_keyword="devAction")
+            pub_topic, payload, timeout=timeout, ack_keyword="devAction",
+            seq=seq, expect_ack=expect_ack)
 
     # Convenience wrappers - confirmed attribute names/types from APK source
 

{python_aidot_cameras-1.0.0rc3 → python_aidot_cameras-1.0.0rc5}/aidot_cameras/camera/controls.py

@@ -9,6 +9,8 @@ mixin must be combined into CameraMixin (it is not usable standalone).
 import logging
 import struct
 
+from typing import Optional
+
 from .constants import _PTZ_DIR_CODES, _STREAM_QUALITY, SETSTREAMCTRL_CMD
 
 _LOGGER = logging.getLogger(__name__)
@@ -87,6 +89,131 @@ class _CameraControlsMixin:
         self.status.siren = on
         return result
 
+    #: Sound-detection algorithms, in the order the camera reports them. The
+    #: camera answers ``soundAlgorithmGet`` with a list of single-key dicts --
+    #: ``[{"sound_enable": 0}, {"glass_Break": 0}, {"smoke_T3": 0}, ...]`` --
+    #: so the key names come from the camera rather than from us. The vendor
+    #: app's own strings name baby_cry and dog_bark alongside these.
+    #: ``sound_enable`` is the master switch; the rest are individual detectors.
+    SOUND_MASTER_KEY = "sound_enable"
+
+    async def async_get_sound_detection(self) -> "Optional[dict]":
+        """Which sound detectors are armed, as ``{key: bool}``.
+
+        ``None`` means the camera did not answer -- unknown, NOT all-off. A
+        model that does not implement this replies with a null ``out``, and
+        reporting that as a set of disabled switches would invent a state the
+        camera never claimed.
+        """
+        out = await self.async_query_device_action("soundAlgorithmGet")
+        if not isinstance(out, list):
+            return None
+        flags: dict = {}
+        for item in out:
+            if isinstance(item, dict):
+                for key, value in item.items():
+                    flags[key] = bool(value)
+        return flags or None
+
+    async def async_set_sound_detection(self, key: str, enabled: bool) -> bool:
+        """Arm or disarm one sound detector.
+
+        Read-modify-write: the camera is asked for the current list and gets
+        the same structure back with one flag changed. The alternative is
+        inventing a payload schema for ``soundAlgorithmSet``, and the camera
+        reports the shape it wants -- so echo it rather than guess it.
+        """
+        out = await self.async_query_device_action("soundAlgorithmGet")
+        if not isinstance(out, list):
+            _LOGGER.warning(
+                "sound detection: %s did not report its algorithms; not writing",
+                self.device_id)
+            return False
+        found = False
+        payload = []
+        for item in out:
+            if isinstance(item, dict) and key in item:
+                payload.append({key: 1 if enabled else 0})
+                found = True
+            else:
+                payload.append(item)
+        if not found:
+            _LOGGER.warning("sound detection: %s does not report %r", self.device_id, key)
+            return False
+        return await self.async_trigger_device_action("soundAlgorithmSet", payload)
+
+    async def async_get_wifi_info(self) -> "Optional[dict]":
+        """``{"ssid": str, "rssi": int}`` for the camera's own WiFi link.
+
+        The camera answers ``WifiBaseInfo`` with a positional list whose first
+        two entries are the SSID and signal strength. Only those two are named
+        here -- the third is an integer that looks like an encoded address, and
+        naming a field we have not confirmed is how a guess becomes a fact.
+        """
+        out = await self.async_query_device_action("WifiBaseInfo")
+        if not isinstance(out, list) or not out:
+            return None
+        info: dict = {"ssid": out[0] if isinstance(out[0], str) else None}
+        if len(out) > 1 and isinstance(out[1], (int, float)):
+            info["rssi"] = int(out[1])
+        return info
+
+    async def async_get_sd_card_info(self) -> "Optional[dict]":
+        """``{"present": bool, "total": int, "used": int, "raw": list}``.
+
+        ``SDcardBaseInfo`` answers positionally: ``[False, 0, 0, 0, 0]`` with no
+        card, ``[True, 29838, 28848, 3, ...]`` on a nearly-full one.
+
+        Only the first three fields are named. The fourth was almost called
+        "free" -- but 29838 - 28848 is 990, not 3, so it is not a remainder;
+        28848/29838 is 96.7%, which makes 3 look like a percentage. "Looks
+        like" is not confirmation, so it stays unnamed in ``raw`` rather than
+        shipping a field that reports 3 MB free on a 30 GB card.
+
+        Units for ``total`` and ``used`` are unconfirmed too (MB is plausible
+        at these magnitudes), so the numbers are passed through exactly as the
+        camera reports them rather than converted.
+        """
+        out = await self.async_query_device_action("SDcardBaseInfo")
+        if not isinstance(out, list) or not out:
+            return None
+        def _n(i):
+            return int(out[i]) if len(out) > i and isinstance(out[i], (int, float)) else None
+        return {"present": bool(out[0]), "total": _n(1), "used": _n(2),
+                "raw": list(out)}
+
+    async def async_reboot(self) -> bool:
+        """Ask the camera to reboot. True means the request was SENT.
+
+        The vendor app's camera settings page does exactly this -- its H5
+        bundle calls ``devActionReq({action: "RebootFunc", in: []})`` -- and
+        ``RebootFunc`` also appears in the native ``NewLivePresenter``. It is
+        the same ``devActionReq`` transport the siren already uses.
+
+        Two deliberate choices:
+
+        * **No ack is awaited.** A reboot succeeds by taking the camera off the
+          network, so a camera that reboots before answering would otherwise be
+          reported as a failure. The app passes no timeout for this action
+          either, unlike the reads beside it. So this reports "requested", and
+          the caller must not read it as "rebooted".
+        * **Refused when the cloud says the camera is offline.** The app only
+          renders its reboot button when the device is reachable
+          (``isCanUseStatus``), and a wake-then-reboot on a sleeping battery
+          camera is not something to fire blind.
+
+        The camera is gone for about a minute afterwards (the app's own wording
+        is "The device Needs a minute to reboot"), during which a viewer sees a
+        session that connects and delivers nothing.
+        """
+        if (not self.status.online) and getattr(self, "_cloud_online_explicit", False):
+            _LOGGER.warning(
+                "reboot refused for %s: the cloud reports it offline", self.device_id)
+            return False
+        _LOGGER.info("reboot requested for %s", self.device_id)
+        return await self.async_trigger_device_action(
+            "RebootFunc", [], expect_ack=False)
+
     async def async_set_night_vision(self, mode: str) -> bool:
         """mode: 'auto' (0), 'on' (1), 'off' (2)"""
         _modes = {"auto": 0, "on": 1, "off": 2}

{python_aidot_cameras-1.0.0rc3 → python_aidot_cameras-1.0.0rc5}/aidot_cameras/camera/sdes_open.py

@@ -108,6 +108,70 @@ def _sctp_reassemble(flags: int, stream_id: int, payload: bytes,
     return None
 
 
+async def _await_rtsp_publish_target(url: "Optional[str]", *,
+                                     timeout: float = 20.0) -> bool:
+    """Wait until an ``rtsp://host:port`` target accepts a connection.
+
+    Publishing into go2rtc is a race after a Home Assistant restart: the serve
+    ffmpeg is launched as soon as media arrives, and go2rtc's RTSP listener may
+    not be back yet. ffmpeg then fails its very first connect with
+    ``Connection refused``, reports ``Could not write header (incorrect codec
+    parameters ?)``, and exits 145 -- which reads as "stream ended" and takes
+    that camera's view down until something retries.
+
+    Measured on a live box: every occurrence of that failure sat inside a
+    one-minute window around an HA restart (11:32, 11:43, 11:49, 11:52, 11:54,
+    11:56, 11:57 on 2026-09-01, and the same shape the night before), and none
+    in steady state.
+
+    Returns True when the port accepts, False on timeout. False is not fatal --
+    the caller launches ffmpeg anyway, because a target that never opens is a
+    different problem and should surface as ffmpeg's own error rather than as a
+    silent refusal to start.
+    """
+    if not url or not url.startswith("rtsp://"):
+        return True
+    try:
+        rest = url[len("rtsp://"):]
+        hostport = rest.split("/", 1)[0]
+        if "@" in hostport:
+            hostport = hostport.rsplit("@", 1)[1]
+        if hostport.startswith("["):            # IPv6 literal
+            if "]" not in hostport:
+                return True                      # malformed: do not block
+            host, _, tail = hostport[1:].partition("]")
+            port = int(tail.lstrip(":") or 554)
+        else:
+            host, _, port_s = hostport.partition(":")
+            port = int(port_s or 554)
+    except (ValueError, IndexError):
+        return True                              # unparseable: do not block
+
+    _deadline = time.monotonic() + timeout
+    _attempt = 0
+    while time.monotonic() < _deadline:
+        _attempt += 1
+        try:
+            _r, _w = await asyncio.wait_for(
+                asyncio.open_connection(host, port), timeout=3.0)
+            _w.close()
+            try:
+                await _w.wait_closed()
+            except Exception:
+                pass
+            if _attempt > 1:
+                _LOGGER.info(
+                    "publish target %s:%s accepted after %d attempts",
+                    host, port, _attempt)
+            return True
+        except (OSError, TimeoutError):
+            await asyncio.sleep(0.5)
+    _LOGGER.warning(
+        "publish target %s:%s did not accept a connection within %.0fs - "
+        "launching ffmpeg anyway so its own error surfaces", host, port, timeout)
+    return False
+
+
 def _sctp_sack_chunk(cum_tsn: int, a_rwnd: int = 131072) -> bytes:
     """An SCTP SACK (RFC 4960 s3.3.4) with no gap blocks and no duplicates.
 
@@ -6820,6 +6884,8 @@ class _SdesOpenMixin:
                        if _keep_a is not None else ""))
             except Exception:
                 _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_open_sdes_stream', exc_info=True)
+        # Do not launch the publisher into a listener that is not up yet.
+        await _await_rtsp_publish_target(rtsp_push_url)
         _LOGGER.info("SDES ffmpeg cmd: %s", " ".join(cmd))
         if _ffmpeg_path() is None:
             # ffmpeg is not installed - clean up and surface a clear error

{python_aidot_cameras-1.0.0rc3 → 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.0rc3"
+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.0rc3 → 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.0rc3
+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.0rc3 → python_aidot_cameras-1.0.0rc5}/python_aidot_cameras.egg-info/SOURCES.txt

@@ -93,6 +93,7 @@ tests/test_bitrate_campaign_arms.py
 tests/test_ble_gateway.py
 tests/test_bridge_state_sentinels.py
 tests/test_busy_backoff.py
+tests/test_camera_properties.py
 tests/test_canary_log_names_the_camera.py
 tests/test_cloud_count.py
 tests/test_cloud_plan.py
@@ -178,7 +179,9 @@ tests/test_playback_tls.py
 tests/test_post_merge_hardening.py
 tests/test_ptz_probe_reads_what_it_is_told.py
 tests/test_public_signature_matches_impl.py
+tests/test_publish_target_readiness.py
 tests/test_quality_campaign_in_session.py
+tests/test_reboot_action.py
 tests/test_recent_recordings.py
 tests/test_remb.py
 tests/test_remb_goes_out_the_relay_aware_sender.py