python-aidot-cameras 0.13.1__tar.gz → 0.13.2__tar.gz

{python_aidot_cameras-0.13.1/python_aidot_cameras.egg-info → python_aidot_cameras-0.13.2}/PKG-INFO

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

@@ -960,15 +960,27 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
         for _key in ("Battery_remaining", "batteryRemaining", "batteryLevel"):
             if _as_int(_props.get(_key)) is not None:
                 return True
-        # The low-power flag: batteryMode=2 is what a camera that sleeps between
-        # sessions reports (see _async_send_camera_command).  Deliberately NOT
-        # keyed on ``powerType``: that name is also the value we SEND in
-        # livePlayReq, we have never observed the cloud returning it as a device
-        # property, and p2pCache - the field right next to it - reads 2 on every
-        # camera including mains ones.  Reading it here would risk classifying a
-        # mains camera as battery, which would put powerType=2 on ITS wire payload
-        # and can leave an A000088 un-armed.  Evidence has to be unambiguous.
-        if _as_int(_props.get("batteryMode")) == 2:
+        # The low-power flag, but ONLY when corroborated.  ``batteryMode=2`` on
+        # its own is not evidence: measured against the live cloud payload, every
+        # MAINS A000088 on this fleet reports ``batteryMode: '2'`` and nothing
+        # else battery-related, while a real battery model reports it alongside
+        # actual telemetry (``Battery_remaining``, ``lowPowerStatus``,
+        # ``charging``).  Trusting it alone classified four mains cameras as
+        # battery, which put powerType=2 on their wire payload and gave them the
+        # battery idle window instead of the mains warm-hold.
+        #
+        # This is the same trap the paragraph below describes for ``powerType`` /
+        # ``p2pCache`` - a field that reads 2 on every camera - so it gets the
+        # same treatment rather than being taken at face value.  Corroboration is
+        # kept (instead of dropping the flag) so a future battery model that
+        # names its level differently is still caught by the flag plus any one
+        # battery-only field.
+        _BATTERY_TELEMETRY = (
+            "Battery_remaining", "batteryRemaining", "batteryLevel",
+            "lowPowerStatus", "charging",
+        )
+        if (_as_int(_props.get("batteryMode")) == 2
+                and any(_props.get(k) is not None for k in _BATTERY_TELEMETRY)):
             return True
         # Already-parsed status, for a camera refreshed from an attribute push
         # rather than from a device-list dict.

{python_aidot_cameras-0.13.1 → python_aidot_cameras-0.13.2}/pyproject.toml

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.13.1
+Version: 0.13.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.13.1 → python_aidot_cameras-0.13.2}/python_aidot_cameras.egg-info/SOURCES.txt

@@ -71,6 +71,7 @@ tests/test_aioice_compat.py
 tests/test_alarm_event.py
 tests/test_backoff.py
 tests/test_battery_detection.py
+tests/test_battery_evidence_corroboration.py
 tests/test_battery_skip_turn.py
 tests/test_constants_imports_resolve.py
 tests/test_deferred_hardening.py

{python_aidot_cameras-0.13.1 → python_aidot_cameras-0.13.2}/tests/test_battery_detection.py

@@ -91,9 +91,36 @@ def test_numeric_string_battery_level_counts():
     assert _cam("LK.IPC.A009999", props={"Battery_remaining": "38"}).is_battery_camera
 
 
-def test_battery_mode_two_counts():
-    assert _cam("LK.IPC.A009999", props={"batteryMode": 2}).is_battery_camera is True
-    assert _cam("LK.IPC.A009999", props={"batteryMode": "2"}).is_battery_camera is True
+def test_battery_mode_two_alone_is_not_evidence():
+    """REVISED 2026-08-02 against the live cloud payload.
+
+    This test used to assert that ``batteryMode=2`` alone proves a battery, on
+    the reasonable reading of the field's name. The account's actual device list
+    disproves it: every MAINS A000088 reports ``batteryMode: '2'`` and no other
+    battery field, while real battery models report it alongside real telemetry
+    (``Battery_remaining``, ``lowPowerStatus``, ``charging``).
+
+    Trusting it alone classified four mains cameras as battery, which put
+    powerType=2 on their wire payload and gave them the battery idle window
+    instead of the mains warm-hold - the same trap
+    ``test_power_type_property_is_deliberately_not_evidence`` guards for
+    ``powerType``/``p2pCache``, which also read 2 on every camera.
+    """
+    for value in (2, "2"):
+        assert _cam("LK.IPC.A009999",
+                    props={"batteryMode": value}).is_battery_camera is False
+
+
+def test_battery_mode_two_counts_when_corroborated():
+    """The flag is still a signal - it just needs one real battery field.
+
+    Kept (rather than dropping the flag) so a battery model whose level field we
+    have not seen is still caught, provided it reports any battery-only field.
+    """
+    for extra in ({"charging": "0"}, {"lowPowerStatus": "0"},
+                  {"Battery_remaining": "100"}):
+        assert _cam("LK.IPC.A009999",
+                    props={"batteryMode": "2", **extra}).is_battery_camera is True
 
 
 def test_battery_mode_one_is_not_evidence():

python_aidot_cameras-0.13.2/tests/test_battery_evidence_corroboration.py

@@ -0,0 +1,139 @@
+"""``batteryMode=2`` alone must not make a mains camera look like a battery one.
+
+Every property payload below is the REAL one from the live cloud account
+(2026-08-02), not a construction. That matters: the bug was believing a field
+meant what its name suggests, and only the actual payload disproves it.
+
+    A001513 (real battery): batteryMode=2, Battery_remaining, lowPowerStatus, charging
+    A000088 (MAINS):        batteryMode=2   <- and nothing else
+    A001064 (mains PTZ):    {}
+
+Misclassification is costly in BOTH directions, which is why the corroboration
+rule is "flag AND telemetry" rather than dropping the flag or trusting it:
+
+* battery read as mains loses the SDES TURN pre-allocation (a cloud-woken
+  battery camera has no LAN host candidate, so the relay is its ONLY return
+  path), the keep-alive renew and the HTTP wake;
+* mains read as battery puts powerType=2 on its wire payload and hands it the
+  battery idle window instead of the mains warm-hold - which is what shipped.
+"""
+
+import types
+
+import pytest
+
+from aidot_cameras.camera.client import CameraMixin
+
+# --- real payloads, verbatim from the cloud device list --------------------- #
+L2_BATTERY = {"batteryMode": "2", "lowPowerStatus": "0",
+              "Battery_remaining": "100", "charging": "0"}
+M3_PRO_MAINS = {"batteryMode": "2"}
+PTZ_MAINS: dict = {}
+
+
+class _Cam:
+    """The real classification code on a minimal object.
+
+    The methods and properties are taken straight off CameraMixin rather than
+    reimplemented, so these tests exercise shipping logic; only the three
+    attributes it reads are stubbed.
+    """
+
+    _BATTERY_MODELS = CameraMixin._BATTERY_MODELS
+    _battery_evidence = CameraMixin._battery_evidence
+    is_battery_camera = CameraMixin.is_battery_camera
+    live_power_type = CameraMixin.live_power_type
+
+    def __init__(self, props, model="LK.IPC.A000088"):
+        self._raw_device = {"properties": props}
+        self.info = types.SimpleNamespace(model_id=model)
+        self.status = None
+
+
+def _cam(props, model="LK.IPC.A000088"):
+    return _Cam(props, model)
+
+
+# --------------------------------------------------------------------------- #
+# the regression
+# --------------------------------------------------------------------------- #
+
+@pytest.mark.parametrize("name", ["M3 Pro_180", "Family Room Cam",
+                                  "Bedroom M3 Pro", "Deck"])
+def test_mains_a000088_reporting_batterymode_is_not_a_battery_camera(name):
+    """The shipped bug: four mains cameras classified as battery.
+
+    They report `batteryMode: '2'` and no other battery field. Trusting the flag
+    alone gave them powerType=2 and the battery idle window.
+    """
+    cam = _cam(M3_PRO_MAINS, model="LK.IPC.A000088")
+    assert cam._battery_evidence() is None, name
+    assert cam.is_battery_camera is False, name
+
+
+def test_mains_ptz_with_no_battery_fields_stays_mains():
+    cam = _cam(PTZ_MAINS, model="LK.IPC.A001064")
+    assert cam.is_battery_camera is False
+
+
+# --------------------------------------------------------------------------- #
+# the thing that must NOT regress
+# --------------------------------------------------------------------------- #
+
+def test_a_real_battery_camera_is_still_detected():
+    """A001513 must stay battery - losing this costs it the TURN pre-alloc."""
+    cam = _cam(L2_BATTERY, model="LK.IPC.A001513")
+    assert cam._battery_evidence() is True
+    assert cam.is_battery_camera is True
+
+
+def test_battery_detection_does_not_lean_on_the_model_list_alone():
+    """Evidence must carry it, so an unlisted battery revision still works."""
+    cam = _cam(L2_BATTERY, model="LK.IPC.A999999-2")
+    assert cam.is_battery_camera is True
+
+
+def test_a_listed_model_with_no_properties_is_still_battery():
+    """The model list is the backstop when the payload carries nothing."""
+    cam = _cam({}, model="LK.IPC.A001513")
+    assert cam._battery_evidence() is None
+    assert cam.is_battery_camera is True
+
+
+# --------------------------------------------------------------------------- #
+# the corroboration rule itself
+# --------------------------------------------------------------------------- #
+
+@pytest.mark.parametrize("corroborating", [
+    {"Battery_remaining": "55"},
+    {"batteryRemaining": "55"},
+    {"batteryLevel": "55"},
+    {"lowPowerStatus": "0"},
+    {"charging": "1"},
+])
+def test_batterymode_counts_when_any_battery_field_corroborates(corroborating):
+    """The flag is kept as a signal, not discarded - it just needs backing.
+
+    This is what catches a future battery model whose level field we have not
+    seen, provided it reports any battery-only field at all.
+    """
+    cam = _cam({"batteryMode": "2", **corroborating}, model="LK.IPC.A000088")
+    assert cam._battery_evidence() is True
+
+
+def test_a_zero_valued_battery_field_still_corroborates():
+    """`charging: '0'` is a report, not an absence - presence is the signal."""
+    cam = _cam({"batteryMode": "2", "charging": "0"}, model="LK.IPC.A000088")
+    assert cam._battery_evidence() is True
+
+
+def test_evidence_never_returns_false_so_it_cannot_demote_a_known_model():
+    """It may only ADD to the battery set, never remove - preserved property."""
+    for props in (M3_PRO_MAINS, PTZ_MAINS, {"batteryMode": "1"}):
+        assert _cam(props)._battery_evidence() in (True, None)
+
+
+def test_power_type_follows_the_classification():
+    """powerType on the wire must never disagree with the battery guards."""
+    assert _cam(M3_PRO_MAINS, model="LK.IPC.A000088").live_power_type == 1
+    assert _cam(L2_BATTERY, model="LK.IPC.A001513").live_power_type == 2

{python_aidot_cameras-0.13.1 → python_aidot_cameras-0.13.2}/tests/test_live_validate_policy.py

@@ -279,3 +279,58 @@ def test_media_seen_accepts_dtls_frames(lv):
     ok, evidence = lv._media_seen(object(), frames=42, out_path=None)
     assert ok
     assert evidence["frames"] == 42
+
+
+# --------------------------------------------------------------------------- #
+# absent-camera early exit
+# --------------------------------------------------------------------------- #
+
+def test_slotless_budget_is_smaller_than_the_dtls_budget(lv):
+    """The early exit must actually save attempts, or it is decoration."""
+    assert lv.SLOTLESS_MAX_ATTEMPTS < lv.ATTEMPTS_DTLS
+
+
+def test_one_retry_is_still_allowed_for_a_single_missed_response(lv):
+    """A camera silent ONCE may just have missed a webrtcResp on a busy account.
+
+    Dropping to a single attempt would turn one unlucky timeout into a failed
+    release, so the budget must be >1.
+    """
+    assert lv.SLOTLESS_MAX_ATTEMPTS > 1
+
+
+def test_only_the_no_session_verdict_is_treated_as_absent(lv):
+    """ERROR alone means no session was opened, so nothing was probabilistic.
+
+    NO_MEDIA and BUSY DID reach the camera - those are exactly the flaky cases
+    the retry budget exists for, and they must keep their full allowance.
+    """
+    assert lv._SLOTLESS_VERDICTS == frozenset({"ERROR"})
+    for reached_the_camera in ("PASS", "NO_MEDIA", "BUSY"):
+        assert reached_the_camera not in lv._SLOTLESS_VERDICTS
+
+
+def test_a_camera_that_reached_us_once_keeps_its_full_budget(lv):
+    """The early exit requires EVERY attempt to be slotless.
+
+    A camera that returns NO_MEDIA then ERROR is flaky, not absent, and must not
+    be cut short - which is why the loop checks all() rather than the last one.
+    """
+    mixed = [{"verdict": "NO_MEDIA"}, {"verdict": "ERROR"}]
+    assert not all(a["verdict"] in lv._SLOTLESS_VERDICTS for a in mixed)
+
+    absent = [{"verdict": "ERROR"}, {"verdict": "ERROR"}]
+    assert all(a["verdict"] in lv._SLOTLESS_VERDICTS for a in absent)
+
+
+def test_an_absent_camera_still_reaches_a_failing_verdict(lv, tmp_path):
+    """Skipping attempts must not soften the verdict - absent is still ERROR.
+
+    The saving is wall clock, not leniency: a required model with no working
+    camera must still fail the release.
+    """
+    report = {"cameras": [_cam(lv, "LK.IPC.A000088", "ERROR", name="Deck")]}
+    report["cameras"][0]["attempts_used"] = lv.SLOTLESS_MAX_ATTEMPTS
+    assert lv._summarize(report, _args(tmp_path)) == 1
+    assert report["verdict"] == "FAIL"
+    assert report["required_failed"] == ["Deck"]