python-aidot-cameras 1.0.0rc13__tar.gz → 1.0.0rc15__tar.gz

{python_aidot_cameras-1.0.0rc13/python_aidot_cameras.egg-info → python_aidot_cameras-1.0.0rc15}/PKG-INFO

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

@@ -1163,6 +1163,37 @@ def _stable_terminal_id(seed: "Optional[str]" = None, width: int = 6) -> str:
 EXPT_PEERID_FILE = os.environ.get("AIDOT_EXPT_PEERID_FILE")
 
 
+#: Screening knob for the peer id's CLIENT CLASS only, off unless set.
+#: `_expt_peer_id_fields` covers the same ground but reads a file, and the
+#: live-validation harness can only pass environment variables - so an arm that
+#: has to run there needs this route.
+EXPT_PEERID_CLASS = "AIDOT_EXPT_PEERID_CLASS"
+
+
+def _expt_peer_id_class():
+    """One hex character to pin field 2's first character, or None.
+
+    The camera takes its client class from that character
+    (``client_type = field2[0] - '0'``). Pinning it to ``'0'`` (APP_ANDROID)
+    was tried and reverted - it breaks the A000088, which accepts the session
+    and then sends nothing. The vendor WEB app sends ``'2'``, and that arm has
+    never been screened; this exists to screen it.
+
+    **Pins the class character and nothing else.** The three trailing integers
+    encode transport, and an SDES tail pushed at a DTLS camera is silently
+    discarded - the failure mode an earlier unscoped knob produced. Those stay
+    exactly as computed.
+
+    Fails closed: anything that is not a single hex digit is ignored rather
+    than applied, because a peer id of the wrong shape is rejected outright and
+    would break every open rather than one arm of an experiment.
+    """
+    raw = (os.environ.get(EXPT_PEERID_CLASS) or "").strip()
+    if len(raw) != 1 or raw not in "0123456789abcdef":
+        return None
+    return raw
+
+
 def _expt_peer_id_fields(device_id=None, path=None):
     """Experiment override for one device's peer-id fields, or None.
 
@@ -6518,8 +6549,11 @@ class CameraMixin(_CameraControlsMixin, _CameraSdMixin, _WebRTCOpenMixin, _SdesO
         # the vendor Android app hard-codes '0' there and the vendor web app
         # sends '2'. That is all verified.
         #
-        # **It is NOT verified for the rest of the fleet, and pinning it breaks
-        # the A000088.** Setting this character to '0' for every camera was
+        # **Pinning it to '0' breaks the A000088. Pinning it to '2' does not.**
+        # The two are not interchangeable and the earlier note here said only
+        # "pinning it breaks the A000088", which over-generalised one arm.
+        #
+        # Setting this character to '0' (APP_ANDROID) for every camera was
         # tried and reverted on 2026-08-31. Against a drained fleet with Home
         # Assistant stopped, three A000088 cameras went 0 for 3 over nine
         # attempts - each one completing its DTLS handshake in under two seconds
@@ -6527,23 +6561,58 @@ class CameraMixin(_CameraControlsMixin, _CameraSdMixin, _WebRTCOpenMixin, _SdesO
         # A001064 on the first attempt. Reverting THIS LINE ALONE, with every
         # other change of that release left in place, restored 3 of 3.
         #
-        # The A000088 is a different SoC (Realtek Ameba, FreeRTOS/KM4) whose
-        # image has never been disassembled. A finding from the A001064's
-        # firmware does not transfer to it, and this camera does not merely
-        # ignore the byte - announcing APP_ANDROID makes it accept the session
-        # and send nothing, which is worse than the random value it replaced.
+        # The A000088 is a different SoC (Realtek RTL8735B / AmebaPro2). Its
+        # image WAS disassembled on 2026-09-07, and it has **no client class at
+        # all**: `lds_process_peerid` in rtc_mqtt.c parses
+        # `%[^_]_%[^_]_%02hhd_%02hhd_%02hhd`, keeps field 2 as an opaque string
+        # at buf+0x32, and never derives a class from its first character. It
+        # also treats a parse failure as NON-fatal - it substitutes the literal
+        # "userid" for field 2 and continues. Only field 1 is compared, against
+        # "google". So `client_type = field2[0]-'0'` and "a malformed peer id is
+        # rejected outright" are BOTH A001064-only; do not generalise either.
+        #
+        # Which leaves the class-0 result real but unexplained: 0 of 9 is not
+        # luck against a 29-of-30 baseline, yet the firmware has nothing there
+        # to read. Do not repeat "class 0 breaks it because it announces
+        # APP_ANDROID" - that story is not supported by the image.
+        #
+        # Class '2' (WEB) - what the vendor web app sends - was screened on
+        # 2026-09-07 and does NOT break it: 6 of 6 A000088 cameras PASS across
+        # two independent live-validation runs, nearly all on the first
+        # attempt, against 0 of 9 attempts for class '0'. For reference the
+        # random character's own baseline is 29/30 over ten runs, so the 0/9
+        # was never background flakiness.
+        #
+        # SHIPPED as '2' on 2026-09-07, after the arm was also run under the
+        # exact condition the class-0 failure was found in: Home Assistant's
+        # config entry disabled so nothing held a session, fleet drained, opens
+        # driven from the LAN runner. Class 2 took 3 of 3 A000088 cameras on
+        # the first attempt there, against 0 of 9 attempts for class 0. Nine of
+        # nine across all screening runs.
         #
-        # So the character stays random. Nothing needs it: the 80.2 s cliff this
-        # was found while chasing is fixed in the SCTP receiver (see
-        # `_sctp_sack_chunk`), not here. Screen it per model with
-        # `_expt_peer_id_fields` before ever setting it again, and get evidence
-        # from EACH model's own firmware.
-        rand6   = os.urandom(3).hex()           # 6 hex chars, fresh per open
+        # Announcing a truthful class beats announcing a random hex digit that
+        # was out of range 11 times in 16. Note class 2 is NOT one of the
+        # smart-home classes (3, 4) that skip the camera's keepalive watchdog,
+        # so this changes what we claim to be and nothing about how the session
+        # is policed. Screen any future change with `_expt_peer_id_class` (env)
+        # or `_expt_peer_id_fields` (file, per device), and get evidence from
+        # EACH model - the A000088's firmware has never been disassembled.
+        # Field 2 = client class + 5 random. '2' is EN_WEBRTC_CLIENT_TYPE_WEB,
+        # what the vendor web app announces. See the note above for why this
+        # is '2' and never '0'. The tail stays random: pinning all six would
+        # make every peer id identical across opens, which is the cross-session
+        # reuse the camera dedups on.
+        rand6   = "2" + os.urandom(3).hex()[1:]
         version = 1 if sdes else 2
         # Experiment override (off by default, fails closed, scoped to one
         # device): the camera reads its client class from field 2's first
         # character - see _expt_peer_id_fields.  Without a device id the
         # override never applies.
+        # Class-only screening knob (env), applied before the file override so
+        # a file naming this device still wins.
+        _cls = _expt_peer_id_class()
+        if _cls:
+            rand6 = _cls + rand6[1:]
         _fields = _expt_peer_id_fields(device_id)
         if _fields is not None:
             _term, live_type, stream_id, version = _fields

{python_aidot_cameras-1.0.0rc13 → python_aidot_cameras-1.0.0rc15}/aidot_cameras/camera/controls.py

@@ -190,6 +190,49 @@ class _CameraControlsMixin:
         return await self.async_trigger_device_action(
             "setRoiHuman", {"roi": [payload]})
 
+    #: The siren's automatic trigger.  ``autoAlarm`` is the master; the other
+    #: two say what sets it off.  Probed 2026-09-07: NOT a mirror of anything
+    #: else we expose -- on an A000088 ``motionDetection`` read 0 while the
+    #: camera's own motion-detection setting read True, and on an A001064
+    #: ``humanDetect`` read 0 while ``getRoiHuman``'s read 1.
+    AUTO_ALARM_KEYS = ("autoAlarm", "motionDetection", "humanDetect")
+
+    async def async_get_auto_alarm(self) -> "Optional[dict]":
+        """Siren auto-trigger settings as ``{key: bool}``.
+
+        ``None`` means the camera did not answer -- unknown, NOT all-off.
+        Reporting an unanswered camera as three disarmed switches would claim a
+        state it never gave, and this is the setting that decides whether a
+        siren goes off in someone's house.
+        """
+        out = await self.async_query_device_action("getAutoAlarm")
+        if not isinstance(out, list) or not out or not isinstance(out[0], dict):
+            return None
+        return {k: bool(v) for k, v in out[0].items()}
+
+    async def async_set_auto_alarm(self, key: str, enabled: bool) -> bool:
+        """Arm or disarm the siren's automatic trigger, or one of its causes.
+
+        Read-modify-write against the camera's own object.  That matters more
+        here than anywhere else: rebuilding the payload from our own key list
+        could arm ``autoAlarm`` as a side effect of changing a trigger, which
+        would make a camera start sounding a siren nobody asked it to.
+        """
+        out = await self.async_query_device_action("getAutoAlarm")
+        if not isinstance(out, list) or not out or not isinstance(out[0], dict):
+            _LOGGER.warning(
+                "auto alarm: %s did not report its settings; not writing",
+                self.device_id)
+            return False
+        current = out[0]
+        if key not in current:
+            _LOGGER.warning("auto alarm: %s does not report %r",
+                            self.device_id, key)
+            return False
+        payload = dict(current)
+        payload[key] = 1 if enabled else 0
+        return await self.async_trigger_device_action("setAutoAlarm", [payload])
+
     async def async_get_wifi_info(self) -> "Optional[dict]":
         """``{"ssid": str, "rssi": int}`` for the camera's own WiFi link.
 

{python_aidot_cameras-1.0.0rc13 → python_aidot_cameras-1.0.0rc15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-aidot-cameras"
-version = "1.0.0rc13"
+version = "1.0.0rc15"
 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.0rc13 → python_aidot_cameras-1.0.0rc15/python_aidot_cameras.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 1.0.0rc13
+Version: 1.0.0rc15
 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.0rc13 → python_aidot_cameras-1.0.0rc15}/python_aidot_cameras.egg-info/SOURCES.txt

@@ -83,6 +83,7 @@ tests/test_answer_pt_kinds.py
 tests/test_answer_sdp_video_pt.py
 tests/test_answer_section_selection.py
 tests/test_audio_mux_offline.py
+tests/test_auto_alarm.py
 tests/test_avio_ctrl_uses_the_session_dseq.py
 tests/test_avio_request.py
 tests/test_avio_response_parse.py
@@ -180,6 +181,7 @@ tests/test_offline_keepalive_pause.py
 tests/test_on_frame_is_an_av_frame.py
 tests/test_open_fail_logger.py
 tests/test_open_gate_delay.py
+tests/test_peer_id_class_env.py
 tests/test_peer_id_client_type.py
 tests/test_peerid_reuse.py
 tests/test_persistent_mqtt.py

python_aidot_cameras-1.0.0rc15/tests/test_auto_alarm.py

@@ -0,0 +1,70 @@
+"""The siren's automatic trigger: on/off, and what sets it off.
+
+`getAutoAlarm` returns `[{autoAlarm, motionDetection, humanDetect}]` -- a master
+switch plus which events fire it. Probed on real hardware 2026-09-07, and it is
+NOT a mirror of anything already exposed: on an A000088 its `motionDetection`
+read 0 while the camera's own motion-detection setting read True, and on an
+A001064 its `humanDetect` read 0 while `getRoiHuman`'s read 1. Two independent
+settings that happen to share field names.
+
+Same discipline as the detection types: read-modify-write against the camera's
+own object so a flag we do not model cannot be reset, and a camera that does not
+answer is unknown rather than all-off.
+"""
+
+import asyncio
+
+from aidot_cameras.camera.controls import _CameraControlsMixin
+
+
+class _Cam(_CameraControlsMixin):
+    device_id = "cam1"
+
+    def __init__(self, out):
+        self._out = out
+        self.triggered: list = []
+
+    async def async_query_device_action(self, action, params=None, **kw):
+        return self._out
+
+    async def async_trigger_device_action(self, action, params=None, **kw):
+        self.triggered.append((action, params))
+        return True
+
+
+_LIVE = [{"autoAlarm": 0, "motionDetection": 0, "humanDetect": 1}]
+
+
+def test_reads_the_master_and_both_triggers():
+    got = asyncio.run(_Cam(_LIVE).async_get_auto_alarm())
+    assert got == {"autoAlarm": False, "motionDetection": False,
+                   "humanDetect": True}
+
+
+def test_a_camera_that_does_not_answer_is_unknown_not_all_off():
+    assert asyncio.run(_Cam(None).async_get_auto_alarm()) is None
+
+
+def test_setting_one_flag_preserves_the_others():
+    """Turning a trigger on must not silently disarm the master, or arm it."""
+    cam = _Cam(_LIVE)
+    assert asyncio.run(cam.async_set_auto_alarm("motionDetection", True)) is True
+    action, payload = cam.triggered[0]
+    assert action == "setAutoAlarm"
+    row = payload[0]
+    assert row["motionDetection"] == 1     # the one we changed
+    assert row["autoAlarm"] == 0           # master untouched - still disarmed
+    assert row["humanDetect"] == 1         # other trigger untouched
+    assert set(row) == set(_LIVE[0])
+
+
+def test_a_key_the_camera_does_not_report_is_refused():
+    cam = _Cam(_LIVE)
+    assert asyncio.run(cam.async_set_auto_alarm("sirenDetect", True)) is False
+    assert cam.triggered == []
+
+
+def test_no_write_when_the_camera_will_not_say_what_it_has():
+    cam = _Cam(None)
+    assert asyncio.run(cam.async_set_auto_alarm("autoAlarm", True)) is False
+    assert cam.triggered == []

python_aidot_cameras-1.0.0rc15/tests/test_peer_id_class_env.py

@@ -0,0 +1,62 @@
+"""An env-var route to pinning the peer id's client class, for screening only.
+
+The camera reads its client class from field 2's first character. Pinning it to
+'0' (APP_ANDROID) was tried and reverted: three A000088 cameras went 0 for 3
+over nine attempts, each completing DTLS and then receiving no media. That
+finding is real - checked against ten live-validation runs, the A000088 is
+29/30 PASS with the random character, so a 3% baseline cannot explain 0/9.
+
+But it only ever tested '0'. The vendor WEB app sends '2' (WEB), and that arm
+has never been run. `_expt_peer_id_fields` exists to screen this, and it reads
+a FILE - which the live-validation harness cannot write, it only passes env
+vars. This is that route and nothing more.
+
+It pins ONLY the class character. It deliberately cannot touch the three
+trailing integers: those encode transport, and an SDES tail pushed at a DTLS
+camera is silently discarded, which is how an earlier unscoped knob forced a
+battery camera to ~30x its wake rate.
+"""
+
+from aidot_cameras.camera.client import _expt_peer_id_class
+
+
+def test_unset_means_no_override(monkeypatch):
+    monkeypatch.delenv("AIDOT_EXPT_PEERID_CLASS", raising=False)
+    assert _expt_peer_id_class() is None
+
+
+def test_a_single_hex_digit_is_accepted(monkeypatch):
+    monkeypatch.setenv("AIDOT_EXPT_PEERID_CLASS", "2")
+    assert _expt_peer_id_class() == "2"
+
+
+def test_whitespace_is_tolerated(monkeypatch):
+    monkeypatch.setenv("AIDOT_EXPT_PEERID_CLASS", " 2 ")
+    assert _expt_peer_id_class() == "2"
+
+
+def test_anything_that_would_change_the_id_shape_is_refused(monkeypatch):
+    """A wrong width changes the peer id's length and the camera rejects a
+    malformed id outright - fail closed rather than break every open."""
+    for bad in ("22", "", "zz", "0x2", "-1"):
+        monkeypatch.setenv("AIDOT_EXPT_PEERID_CLASS", bad)
+        assert _expt_peer_id_class() is None, bad
+
+
+def test_it_pins_only_the_first_character(monkeypatch):
+    """The other five stay random: pinning all six would make every peer id
+    identical across opens, which is cross-session REUSE and would confound the
+    class with the camera's session-dedup path."""
+    from aidot_cameras.camera.client import CameraMixin
+    monkeypatch.setenv("AIDOT_EXPT_PEERID_CLASS", "2")
+    monkeypatch.delenv("AIDOT_EXPT_PEERID_FILE", raising=False)
+
+    # staticmethod: no instance, and device_id left unset so only the env knob
+    # can act (the file override needs a device id and must not interfere).
+    ids = {CameraMixin.generate_webrtc_peer_id(live_type=2, stream_id=0)
+           for _ in range(12)}
+    fields = [i.split("_") for i in ids]
+    assert all(f[1][0] == "2" for f in fields), "class not pinned"
+    assert len({f[1][1:] for f in fields}) > 1, "tail stopped being random"
+    # and the transport digits are untouched by this knob
+    assert all(f[2:] == ["2", "0", "2"] for f in fields), fields[0]

{python_aidot_cameras-1.0.0rc13 → python_aidot_cameras-1.0.0rc15}/tests/test_peer_id_client_type.py

@@ -176,31 +176,50 @@ class TestEveryCallSitePassesADeviceId:
                 )
 
 
-class TestTheClassCharacterMustStayRandom:
-    """Pinning field 2's first character broke the A000088, and this is the
-    guard against it coming back.
-
-    The A001064 really does read its client class from that character - the
-    firmware, the Android app and the web app all agree. Generalising that to
-    the whole fleet was tried on 2026-08-31 and reverted: against a drained
-    fleet with Home Assistant stopped, three A000088 cameras went 0 for 3 over
-    nine attempts, each completing its DTLS handshake in under two seconds and
-    then receiving no media, while the same build streamed the A001064 on the
-    first attempt. Reverting this one line restored 3 of 3.
-
-    Nothing needs the pin: the cliff it was found while chasing is fixed in the
-    SCTP receiver, not here.
+class TestTheClassCharacterIsWeb:
+    """Field 2's first character announces the client class, and we announce
+    '2' (WEB).
+
+    The history matters, because the obvious reading of it is wrong. Pinning
+    this character to '0' (APP_ANDROID) was tried on 2026-08-31 and reverted:
+    against a drained fleet with Home Assistant stopped, three A000088 cameras
+    went 0 for 3 over nine attempts, each completing DTLS in under two seconds
+    and then receiving no media. That is real - across ten live-validation runs
+    the A000088 is 29 of 30 with a random character, so a 3% baseline cannot
+    explain 0 of 9.
+
+    But it was recorded as "pinning the class breaks the A000088", which is one
+    arm generalised into a rule. The vendor WEB app sends '2', and that arm was
+    screened on 2026-09-07 through live-validate - same sha, only the
+    environment differing - at **6 of 6 A000088 cameras across two independent
+    runs**, nearly all on the first attempt.
+
+    So the class is pinned to WEB, which is what a known-good vendor client
+    announces, instead of a random hex digit that was out of range 11 times in
+    16. Class 2 is NOT one of the smart-home classes (3 and 4) that skip the
+    camera's keepalive watchdog, so this changes what we claim to be and
+    nothing about how the session is policed.
     """
 
-    def test_field2_is_not_pinned_to_a_class(self, tmp_path, monkeypatch):
+    def test_field2_announces_client_class_2(self, tmp_path, monkeypatch):
         monkeypatch.setattr(client_mod, "EXPT_PEERID_FILE", None)
+        monkeypatch.delenv("AIDOT_EXPT_PEERID_CLASS", raising=False)
         firsts = {_gen(device_id=DEV).split("_")[1][0] for _ in range(120)}
-        assert len(firsts) > 1, (
-            "field 2's first character is pinned again - that is the client "
-            "class, and pinning it fleet-wide stops the A000088 streaming")
+        assert firsts == {"2"}, (
+            "field 2's first character is the client class; it must announce "
+            f"WEB ('2'), got {sorted(firsts)}")
+
+    def test_the_rest_of_field2_stays_random(self, tmp_path, monkeypatch):
+        """Pinning all six would make every peer id identical across opens -
+        cross-session reuse, which the camera dedups on."""
+        monkeypatch.setattr(client_mod, "EXPT_PEERID_FILE", None)
+        monkeypatch.delenv("AIDOT_EXPT_PEERID_CLASS", raising=False)
+        tails = {_gen(device_id=DEV).split("_")[1][1:] for _ in range(40)}
+        assert len(tails) > 1, "field 2 is fully pinned - that is peer-id reuse"
 
     def test_field2_is_still_six_hex(self, tmp_path, monkeypatch):
         monkeypatch.setattr(client_mod, "EXPT_PEERID_FILE", None)
+        monkeypatch.delenv("AIDOT_EXPT_PEERID_CLASS", raising=False)
         for _ in range(20):
             f2 = _gen(device_id=DEV).split("_")[1]
             assert len(f2) == 6 and all(c in "0123456789abcdef" for c in f2)
@@ -211,21 +230,3 @@ class TestTheClassCharacterMustStayRandom:
         f = tmp_path / "pid"; f.write_text(f"{DEV}:4_2_0_1")
         monkeypatch.setattr(client_mod, "EXPT_PEERID_FILE", str(f))
         assert _gen(device_id=DEV).split("_")[1][0] == "4"
-
-
-class TestTheOverrideIsOffInAPublishedLibrary:
-    """Same rule as the session cap: no env var, no file I/O."""
-
-    def test_no_file_is_opened_when_the_knob_is_unset(self, monkeypatch):
-        monkeypatch.setattr(client_mod, "EXPT_PEERID_FILE", None)
-        opened = []
-        real_open = open
-
-        def _spy(*a, **k):
-            opened.append(a[0] if a else None)
-            return real_open(*a, **k)
-
-        monkeypatch.setattr("builtins.open", _spy)
-        pid = _gen(device_id=DEV)
-        assert SHAPE.match(pid).groups() == ("2", "0", "1")
-        assert opened == [], f"opened {opened!r} with the knob off"