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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 1.0.0rc3
+Version: 1.0.0rc4
 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.0rc4}/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,92 @@ 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),
+        ]
+        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,
+        )
+        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
+            return body.get("out")
+        _LOGGER.debug("devActionReq %s: no reply from %s", action, device_id)
+        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 +2711,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.0rc4}/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.0rc4}/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.0rc4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-aidot-cameras"
-version = "1.0.0rc3"
+version = "1.0.0rc4"
 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.0rc4/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.0rc4
 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.0rc4}/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

python_aidot_cameras-1.0.0rc4/tests/test_camera_properties.py

@@ -0,0 +1,106 @@
+"""Sound detection, WiFi and SD-card properties read over devActionReq.
+
+The camera answers these `get` actions with real data. The behaviour worth
+pinning is what happens when it does NOT: a camera that cannot answer must read
+as unknown, never as a set of switched-off features.
+"""
+import asyncio
+
+from aidot_cameras.camera.controls import _CameraControlsMixin
+
+
+class _Cam:
+    def __init__(self, out=None, set_ok=True):
+        self.device_id = "dev1"
+        self._out = out
+        self._set_ok = set_ok
+        self.queries = []
+        self.actions = []
+
+    async def async_query_device_action(self, action, params=None, *, timeout=8.0):
+        self.queries.append(action)
+        return self._out
+
+    async def async_trigger_device_action(self, action, params, *,
+                                          timeout=4.0, expect_ack=True):
+        self.actions.append((action, params))
+        return self._set_ok
+
+    async_get_sound_detection = _CameraControlsMixin.async_get_sound_detection
+    async_set_sound_detection = _CameraControlsMixin.async_set_sound_detection
+    async_get_wifi_info = _CameraControlsMixin.async_get_wifi_info
+    async_get_sd_card_info = _CameraControlsMixin.async_get_sd_card_info
+
+
+_SOUND = [{"sound_enable": 0}, {"glass_Break": 1}, {"smoke_T3": 0}]
+
+
+class TestSoundDetection:
+    def test_it_flattens_the_camera_s_list_of_single_key_dicts(self):
+        cam = _Cam(_SOUND)
+        assert asyncio.run(cam.async_get_sound_detection()) == {
+            "sound_enable": False, "glass_Break": True, "smoke_T3": False}
+
+    def test_no_reply_is_unknown_not_all_off(self):
+        """A null `out` must not be reported as a set of disabled detectors."""
+        assert asyncio.run(_Cam(None).async_get_sound_detection()) is None
+
+    def test_a_write_echoes_the_camera_s_own_structure(self):
+        cam = _Cam(_SOUND)
+        assert asyncio.run(cam.async_set_sound_detection("smoke_T3", True)) is True
+        action, payload = cam.actions[0]
+        assert action == "soundAlgorithmSet"
+        assert payload == [{"sound_enable": 0}, {"glass_Break": 1}, {"smoke_T3": 1}]
+
+    def test_it_leaves_the_other_flags_untouched(self):
+        cam = _Cam(_SOUND)
+        asyncio.run(cam.async_set_sound_detection("sound_enable", True))
+        assert cam.actions[0][1] == [
+            {"sound_enable": 1}, {"glass_Break": 1}, {"smoke_T3": 0}]
+
+    def test_it_refuses_to_write_a_key_the_camera_does_not_report(self):
+        cam = _Cam(_SOUND)
+        assert asyncio.run(cam.async_set_sound_detection("nope", True)) is False
+        assert cam.actions == []
+
+    def test_it_refuses_to_write_when_the_camera_did_not_answer(self):
+        """Without a current list there is nothing to echo - guessing a payload
+        here is how an unrelated detector gets switched off."""
+        cam = _Cam(None)
+        assert asyncio.run(cam.async_set_sound_detection("smoke_T3", True)) is False
+        assert cam.actions == []
+
+
+class TestWifiInfo:
+    def test_it_names_only_the_confirmed_fields(self):
+        cam = _Cam(["Brightly", 63, 1984564238])
+        assert asyncio.run(cam.async_get_wifi_info()) == {
+            "ssid": "Brightly", "rssi": 63}
+
+    def test_no_reply_is_none(self):
+        assert asyncio.run(_Cam(None).async_get_wifi_info()) is None
+
+
+class TestSdCardInfo:
+    def test_absent_card(self):
+        cam = _Cam([False, 0, 0, 0, 0])
+        got = asyncio.run(cam.async_get_sd_card_info())
+        assert got["present"] is False and got["total"] == 0 and got["used"] == 0
+
+    def test_present_card_passes_numbers_through_unconverted(self):
+        cam = _Cam([True, 29838, 28848, 3, 0])
+        got = asyncio.run(cam.async_get_sd_card_info())
+        assert got["present"] is True
+        assert got["total"] == 29838 and got["used"] == 28848
+
+    def test_the_fourth_field_is_not_reported_as_free_space(self):
+        """Measured on a real camera: total 29838, used 28848, fourth field 3.
+        That is not a remainder (990), so naming it "free" would report 3 units
+        left on a nearly-full 30 GB card. It stays raw until confirmed."""
+        cam = _Cam([True, 29838, 28848, 3, 0])
+        got = asyncio.run(cam.async_get_sd_card_info())
+        assert "free" not in got
+        assert got["raw"] == [True, 29838, 28848, 3, 0]
+
+    def test_no_reply_is_none(self):
+        assert asyncio.run(_Cam(None).async_get_sd_card_info()) is None

python_aidot_cameras-1.0.0rc4/tests/test_publish_target_readiness.py

@@ -0,0 +1,74 @@
+"""Waiting for the publish target before launching the serve ffmpeg.
+
+After a Home Assistant restart the serve ffmpeg can be launched before go2rtc's
+RTSP listener is back. ffmpeg's first connect is then refused, it exits 145, and
+that reads as "stream ended" -- the camera's view is down until something
+retries. Every observed occurrence on a live box sat within a minute of a
+restart.
+"""
+import asyncio
+import socket
+
+from aidot_cameras.camera.sdes_open import _await_rtsp_publish_target
+
+
+def _free_port() -> int:
+    s = socket.socket()
+    s.bind(("127.0.0.1", 0))
+    port = s.getsockname()[1]
+    s.close()
+    return port
+
+
+class TestItWaitsForTheTarget:
+    def test_an_open_port_returns_immediately(self):
+        srv = socket.socket()
+        srv.bind(("127.0.0.1", 0))
+        srv.listen(1)
+        port = srv.getsockname()[1]
+        try:
+            ok = asyncio.run(_await_rtsp_publish_target(
+                f"rtsp://127.0.0.1:{port}/aidot_x", timeout=5.0))
+            assert ok is True
+        finally:
+            srv.close()
+
+    def test_a_closed_port_times_out_but_does_not_raise(self):
+        """False, not an exception: the caller still launches ffmpeg so a target
+        that never opens surfaces as ffmpeg's own error, not a silent refusal."""
+        ok = asyncio.run(_await_rtsp_publish_target(
+            f"rtsp://127.0.0.1:{_free_port()}/aidot_x", timeout=1.0))
+        assert ok is False
+
+
+class TestItNeverBlocksTheWrongThing:
+    def test_a_non_rtsp_url_is_not_probed(self):
+        assert asyncio.run(_await_rtsp_publish_target(
+            "http://127.0.0.1:1/x.ts", timeout=0.1)) is True
+
+    def test_none_is_not_probed(self):
+        assert asyncio.run(_await_rtsp_publish_target(None, timeout=0.1)) is True
+
+    def test_an_unparseable_url_does_not_block(self):
+        assert asyncio.run(_await_rtsp_publish_target(
+            "rtsp://[unclosed", timeout=0.1)) is True
+
+
+class TestUrlForms:
+    def test_credentials_in_the_url_are_stripped_before_the_host(self):
+        srv = socket.socket()
+        srv.bind(("127.0.0.1", 0))
+        srv.listen(1)
+        port = srv.getsockname()[1]
+        try:
+            ok = asyncio.run(_await_rtsp_publish_target(
+                f"rtsp://user:pw@127.0.0.1:{port}/aidot_x", timeout=5.0))
+            assert ok is True
+        finally:
+            srv.close()
+
+    def test_a_missing_port_defaults_to_554(self):
+        # 554 is almost certainly closed here; the point is it parses and
+        # returns rather than raising.
+        assert asyncio.run(_await_rtsp_publish_target(
+            "rtsp://127.0.0.1/aidot_x", timeout=0.5)) in (True, False)