python-aidot-cameras 1.0.0b5__tar.gz → 1.0.0b7__tar.gz

{python_aidot_cameras-1.0.0b5/python_aidot_cameras.egg-info → python_aidot_cameras-1.0.0b7}/PKG-INFO

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

@@ -48,6 +48,38 @@ def _as_bool(v: Any) -> Optional[bool]:
     return None if i is None else bool(i)
 
 
+def _card_present(attr: dict) -> Optional[bool]:
+    """Is an SD card in the slot? None means nobody said.
+
+    Three states, and the third is the point. Of seven cameras measured
+    2026-08-12, one reported ``SDcardExistFlag: true``, two reported ``false``,
+    and four carried neither key - including an A000088, the same model as all
+    three that did report. So a missing key cannot mean "this model cannot say";
+    it means we do not know, and anything that reads it as "no card" would tell
+    someone with a working camera that their slot is empty.
+
+    ``SDcardExistFlag`` wins where it exists. ``SDcardBaseInfo`` is the fallback
+    and arrives as a STRING holding a JSON array - element 0 agreed with the
+    flag on every camera carrying both. The other four positions are not
+    decoded: ``30432`` is plausibly a 32 GB card's total MB and plausibly
+    something else, and a guess does not belong in a public data model.
+    """
+    if "SDcardExistFlag" in attr:
+        flag = _as_bool(attr.get("SDcardExistFlag"))
+        if flag is not None:
+            return flag
+
+    raw = attr.get("SDcardBaseInfo")
+    if isinstance(raw, str):
+        try:
+            raw = json.loads(raw)
+        except ValueError:
+            return None
+    if isinstance(raw, (list, tuple)) and raw:
+        return _as_bool(raw[0])
+    return None
+
+
 class CameraStatusData(DeviceStatusData):
     """Core status plus camera fields; accepts both typed-model and dict updates."""
 
@@ -74,6 +106,11 @@ class CameraStatusData(DeviceStatusData):
     battery_remaining: Optional[int] = None  # Battery_remaining 0-100 (%)
     occupancy: Optional[bool] = None          # Occupancy live presence
     sd_card_status: Optional[str] = None      # SDcardStatus
+    # Tri-state: True in the slot, False slot empty, None nobody said. Reads
+    # INVERTED on A000088 relative to sd_card_status ("0" with a card, "1"
+    # without, 3/3) - which is why sd_card_status is not used for this and the
+    # two are kept apart. That inversion has no corroboration off A000088.
+    sd_card_present: Optional[bool] = None    # SDcardExistFlag/SDcardBaseInfo[0]
     wifi_rssi: Optional[int] = None           # networkRssi (dBm), cloud property
 
     def update(self, attr) -> None:
@@ -125,6 +162,11 @@ class CameraStatusData(DeviceStatusData):
             self.occupancy = b
         if (v := attr.get("SDcardStatus")) is not None:
             self.sd_card_status = str(v)
+        # Only overwrite on an actual reading. Attribute pushes are partial - a
+        # motion notif carries no card keys - so a silent update must leave what
+        # the last full poll established alone.
+        if (b := _card_present(attr)) is not None:
+            self.sd_card_present = b
         if (i := _as_int(attr.get("networkRssi"))) is not None:
             self.wifi_rssi = i
 

{python_aidot_cameras-1.0.0b5 → python_aidot_cameras-1.0.0b7}/aidot_cameras/camera/sd_listing.py

@@ -35,9 +35,42 @@ _LOGGER = logging.getLogger(__name__)
 _SD_LIST_TIMEOUT_S = 8.0
 
 
+def _session_is_live(session: Any) -> bool:
+    """Is this session object one that could still carry a request?
+
+    Only SDES sessions publish ``is_alive``, so a session already torn down is
+    caught on that transport and not on DTLS. That asymmetry is fine here and
+    must stay fine at every caller: this is a cheap early-out, never the thing
+    that keeps a dead channel from being reported as an empty card. ``answered``
+    does that, on every transport.
+    """
+    if session is None:
+        return False
+    return getattr(session, "is_alive", True) is not False
+
+
 class _CameraSdMixin:
     """The on-device recording query, mixed into CameraMixin."""
 
+    @property
+    def has_live_session(self) -> bool:
+        """Is a stream session up right now?
+
+        Public because callers legitimately need to WAIT for a session without
+        asking it anything. ``start_keepalive`` returns before the handshake it
+        schedules has finished, so a caller that wants to ride the session it
+        just asked for has no way to know when that session has arrived.
+        Probing with a real request is not a substitute: once the session is up,
+        the probe IS the request, and a caller that wanted to send one request
+        has then sent two.
+
+        Best-effort, in the direction that keeps callers honest: a torn-down
+        session reads as live on a transport that does not say otherwise, so a
+        listing taken on the strength of this can still fail and every caller
+        must still handle that.
+        """
+        return _session_is_live(getattr(self, "_stream_session", None))
+
     async def _sd_ask(self, session: Any, cmd: int, payload: bytes,
                       response_cmd: int, timeout: float) -> Optional[Any]:
         """One request, with every failure flattened to None."""
@@ -84,14 +117,11 @@ class _CameraSdMixin:
         """
         session = session if session is not None else getattr(
             self, "_stream_session", None)
-        if session is None:
-            return None
-        # A cheap early-out for a session already known to be torn down: there
-        # is no point spending two timeouts on it. Only SDES sessions publish
-        # `is_alive`, so this catches some dead sessions and not others - which
-        # is fine, because it is NOT what keeps a dead session from being
-        # reported as an empty card. `answered` does that, on every transport.
-        if getattr(session, "is_alive", True) is False:
+        # No session is "could not ask", and so is a session already known to
+        # be torn down: there is no point spending two timeouts on one. Shared
+        # with `has_live_session` so a caller waiting for a session to exist and
+        # this call deciding it has one cannot come to different answers.
+        if not _session_is_live(session):
             return None
 
         end_ts = time.time()

{python_aidot_cameras-1.0.0b5 → python_aidot_cameras-1.0.0b7}/pyproject.toml

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

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

@@ -160,6 +160,7 @@ tests/test_restart_cycle.py
 tests/test_retry_policy.py
 tests/test_scripts_importable.py
 tests/test_sctp_init_ack_tsn.py
+tests/test_sd_card_presence.py
 tests/test_sd_event_decode.py
 tests/test_sd_event_probe_payloads.py
 tests/test_sd_listing.py

python_aidot_cameras-1.0.0b7/tests/test_sd_card_presence.py

@@ -0,0 +1,94 @@
+"""Is there a card in the slot, and do we actually know?
+
+A camera with no SD card and a camera that could not be asked look identical to
+every listing call: both return nothing. The cloud has been carrying the answer
+all along in `SDcardExistFlag` / `SDcardBaseInfo`, and nothing read it - so a
+user with an empty slot was told "the camera did not answer", which is false and
+not actionable.
+
+The whole value of the field is in the THIRD state. Two of the fleet's seven
+cameras report the flag as false, one reports true, and four carry neither key -
+including an A000088, the same model as all three that do report. So absence
+cannot mean "this model cannot report it", and anything that collapses unknown
+into "no card" would tell someone with a working camera it has no card.
+"""
+from aidot_cameras.camera.models import CameraStatusData
+
+
+def test_unknown_by_default():
+    assert CameraStatusData().sd_card_present is None
+
+
+def test_a_card_that_is_there():
+    s = CameraStatusData()
+    s.update({"SDcardExistFlag": True})
+    assert s.sd_card_present is True
+
+
+def test_a_slot_that_is_empty():
+    s = CameraStatusData()
+    s.update({"SDcardExistFlag": False})
+    assert s.sd_card_present is False
+
+
+def test_a_camera_that_says_nothing_stays_unknown():
+    # The regression that matters. Four of seven cameras look like this, and
+    # `False` here would put "there is no SD card in this camera" under a
+    # camera nobody has any evidence about.
+    s = CameraStatusData()
+    s.update({"Battery_remaining": "80", "SDcardStatus": "1"})
+    assert s.sd_card_present is None
+
+
+def test_the_base_info_answers_when_the_flag_is_absent():
+    # Measured shape: a STRING holding a JSON array, not an array. Element 0
+    # agreed with the flag on every camera that carried both.
+    s = CameraStatusData()
+    s.update({"SDcardBaseInfo": "[true,30432,0,1,0]"})
+    assert s.sd_card_present is True
+    s2 = CameraStatusData()
+    s2.update({"SDcardBaseInfo": "[false,0,0,0,0]"})
+    assert s2.sd_card_present is False
+
+
+def test_the_base_info_is_also_accepted_as_a_real_list():
+    # The same keys arrive in different shapes across cameras - the neighbouring
+    # SdcardRecord_Enable is "1" on five and true on one - so shape is not
+    # something to rely on.
+    s = CameraStatusData()
+    s.update({"SDcardBaseInfo": [True, 30432, 0, 1, 0]})
+    assert s.sd_card_present is True
+
+
+def test_the_flag_wins_over_the_base_info():
+    s = CameraStatusData()
+    s.update({"SDcardExistFlag": False, "SDcardBaseInfo": "[true,30432,0,1,0]"})
+    assert s.sd_card_present is False
+
+
+def test_a_reply_that_cannot_be_read_is_unknown_not_absent():
+    # A decode failure is not evidence about the slot. Silence about a card and
+    # a card that is not there are the two answers this whole subsystem exists
+    # to keep apart.
+    for junk in ("", "[", "not json", "[]", None, 5, {}):
+        s = CameraStatusData()
+        s.update({"SDcardBaseInfo": junk})
+        assert s.sd_card_present is None, junk
+
+
+def test_a_later_silent_update_does_not_clobber_a_known_reading():
+    # Camera attribute pushes are partial: a notif about motion carries no card
+    # keys, and must not erase what the last full poll established.
+    s = CameraStatusData()
+    s.update({"SDcardExistFlag": True})
+    s.update({"Occupancy": True})
+    assert s.sd_card_present is True
+
+
+def test_it_arrives_through_the_cloud_properties_path_too():
+    # Both shapes reach the same parser: setDevAttrNotif attrs and the cloud
+    # device record's `properties`. The probe read it off the latter.
+    s = CameraStatusData()
+    s.update_from_camera_attributes(
+        {"SDcardExistFlag": False, "SDcardBaseInfo": "[false,0,0,0,0]"})
+    assert s.sd_card_present is False

{python_aidot_cameras-1.0.0b5 → python_aidot_cameras-1.0.0b7}/tests/test_sd_listing.py

@@ -58,6 +58,39 @@ class _Camera(_CameraSdMixin):
         self.device_id = "dev-1"
 
 
+def test_no_session_is_not_a_live_session():
+    # The point of the predicate: a caller can wait for a session to exist
+    # without sending anything to find out whether it does.
+    assert _Camera().has_live_session is False
+
+
+def test_a_session_that_exists_is_a_live_session():
+    assert _Camera(_Session({})).has_live_session is True
+
+
+def test_a_torn_down_session_is_not_a_live_session():
+    # Only SDES sessions say so, which is why a caller that acts on this still
+    # has to handle a listing that fails anyway.
+    assert _Camera(_Session({}, alive=False)).has_live_session is False
+
+
+def test_the_predicate_reaches_the_client_a_caller_actually_holds():
+    # Every test above builds the mixin directly, which proves the rule and not
+    # the wiring. A caller reads this off the client it was handed, and reads it
+    # through hasattr - so a name shadowed anywhere in that MRO would not raise,
+    # it would quietly answer "cannot ask" and put the caller straight back to
+    # the behaviour this predicate exists to end.
+    from aidot_cameras.device_client import CameraDeviceClient, LightDeviceClient
+
+    client = object.__new__(CameraDeviceClient)
+    assert client.has_live_session is False
+    client._stream_session = _Session({})
+    assert client.has_live_session is True
+    # And it stays off the client a light gets, like the rest of the camera
+    # surface: that separation is enforced by construction, not by convention.
+    assert not hasattr(LightDeviceClient, "has_live_session")
+
+
 @pytest.mark.asyncio
 async def test_no_session_is_not_an_empty_card():
     # None, not []. A caller cannot tell "could not ask" from "nothing there"