python-aidot-cameras 1.0.0rc67__tar.gz → 1.0.0rc68__tar.gz

{python_aidot_cameras-1.0.0rc67/python_aidot_cameras.egg-info → python_aidot_cameras-1.0.0rc68}/PKG-INFO

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

@@ -3847,6 +3847,68 @@ class AvioRequestMixin:
             return None
         return await waiter.result(timeout)
 
+    async def async_avio_request_all(
+        self,
+        cmd: int,
+        payload: bytes = b"",
+        *,
+        response_cmd: int,
+        timeout: float = AVIO_RESPONSE_TIMEOUT_S,
+        more_timeout: float = AVIO_RESPONSE_TIMEOUT_S,
+        max_replies: int = 64,
+        budget: "Optional[float]" = None,
+        done=None,
+    ) -> "list[AvioResponse]":
+        """Send ``cmd`` once and return every ``response_cmd`` reply it draws.
+
+        For a command the camera answers in several packets with no further
+        request: the SD listing sends a 7-day window as one 255-record page
+        after another, all unprompted. ``async_avio_request`` keeps the first
+        and the rest arrive with nobody waiting, so a caller saw the oldest
+        255 recordings and never today's.
+
+        Every waiter is registered before the send, for the same reason as the
+        single request: the pages follow each other faster than a waiter
+        registered after the first reply could catch the second. Collection
+        stops at the first wait that times out (``timeout`` for the first
+        reply, ``more_timeout`` after it), at ``max_replies``, once ``budget``
+        seconds have passed since the send, or as soon as ``done(replies)`` is
+        true. An empty list means nothing came back.
+
+        Replies are matched on ``response_cmd`` alone, so two of these for the
+        same command at once on one session can take each other's replies.
+        """
+        router = self._avio_responses
+        waiters = [router.expect(response_cmd) for _ in range(max(1, max_replies))]
+        replies: "list[AvioResponse]" = []
+        try:
+            try:
+                sent = self._avio_cmd(cmd, payload)
+            except Exception:
+                sent = False
+            if not sent:
+                return replies
+            loop = asyncio.get_running_loop()
+            give_up = None if budget is None else loop.time() + budget
+            for waiter in waiters:
+                wait = more_timeout if replies else timeout
+                if give_up is not None:
+                    wait = min(wait, give_up - loop.time())
+                    if wait <= 0:
+                        break
+                resp = await waiter.result(wait)
+                if resp is None:
+                    break
+                replies.append(resp)
+                if done is not None and done(replies):
+                    break
+        finally:
+            # The ones never reached are still registered; a stray later reply
+            # must go to nobody rather than to a question long since answered.
+            for waiter in waiters:
+                waiter.cancel()
+        return replies
+
 
 _SDP_SECRET_ATTRS = ("a=ice-pwd:", "a=psk:")
 

{python_aidot_cameras-1.0.0rc67 → python_aidot_cameras-1.0.0rc68}/aidot_cameras/camera/sd_listing.py

@@ -14,7 +14,7 @@ list rather than as a traceback.
 
 import logging
 import time
-from typing import Any, Optional
+from typing import Any, List, Optional
 
 from .sd_events import (
     HASLISTEVENT_REQ_CMD,
@@ -34,6 +34,94 @@ _LOGGER = logging.getLogger(__name__)
 #: requests cannot hold a session for more than a viewer would tolerate.
 _SD_LIST_TIMEOUT_S = 8.0
 
+#: The pages of one listing follow each other back to back; measured on a PTZ,
+#: four pages of a 7-day window arrived together. A gap this long after a page
+#: means no more are coming.
+_SD_MORE_PAGES_TIMEOUT_S = 3.0
+
+#: 255 records a page, so 64 pages is over 16,000 recordings - far more than a
+#: card holds in the 7 days a caller asks about.
+_SD_MAX_PAGES = 64
+
+#: However the pages trickle in, a listing gives up collecting them after this
+#: long and reports what it has as incomplete. Without it each page would
+#: restart the gap timer and a slow camera could hold the session for minutes.
+_SD_LIST_PAGES_BUDGET_S = 30.0
+
+
+class _ListPages:
+    """The pages of one listing reply, each decoded once, as it arrives."""
+
+    def __init__(self) -> None:
+        self.pages: dict = {}
+        self.undecodable = 0
+        self._total: Optional[int] = None
+        self._seen = 0
+
+    def take(self, replies: List[Any]) -> None:
+        """Decode whatever in ``replies`` has not been decoded yet."""
+        for reply in replies[self._seen :]:
+            self._add(reply)
+        self._seen = len(replies)
+
+    def done(self, replies: List[Any]) -> bool:
+        """The ``done`` hook: stop collecting once the reply is whole."""
+        self.take(replies)
+        return self.covered()
+
+    def _add(self, reply: Any) -> None:
+        page = decode_list_event_response(
+            bytes(reply.payload or b""), command=LISTEVENT_RESP_CMD
+        )
+        if page is None:
+            # The decode is measured from a handful of live replies and a
+            # reply with a different shape is entirely possible. It is an
+            # empty list with a logged reason, never an exception - but not
+            # a COMPLETE empty list: something came back and could not be
+            # read, so there may well be recordings behind it.
+            self.undecodable += 1
+            _LOGGER.debug(
+                "SD list reply did not decode (%d bytes)",
+                len(bytes(reply.payload or b"")),
+            )
+            return
+        if self._total is None:
+            self._total = page.total
+        elif page.total != self._total:
+            # Every page of one reply declares the same page count. One that
+            # does not is a late page of some earlier listing; mixing it in
+            # would file another window's records under this one.
+            _LOGGER.debug(
+                "SD list page declares %d pages, this reply %d: not ours",
+                page.total,
+                self._total,
+            )
+            return
+        # A page the camera sent twice is one page.
+        self.pages.setdefault(page.page_index, page)
+
+    def covered(self) -> bool:
+        """The end flag has arrived and no page before it is missing.
+
+        ``total`` is the page count the camera declared. A camera that declares
+        none (0) is held to the pages up to its end-flag page instead.
+        """
+        ends = [i for i, p in self.pages.items() if p.end_flag == 1]
+        if not ends:
+            return False
+        want = range(self._total) if self._total else range(max(ends) + 1)
+        return set(self.pages) >= set(want)
+
+    @property
+    def records(self) -> list:
+        return [e for i in sorted(self.pages) for e in self.pages[i].events]
+
+    @property
+    def complete(self) -> bool:
+        if self.undecodable:
+            return False
+        return not self.pages or self.covered()
+
 
 def _session_is_live(session: Any) -> bool:
     """Is this session object one that could still carry a request?
@@ -88,6 +176,48 @@ class _CameraSdMixin:
             )
             return None
 
+    async def _sd_ask_pages(
+        self, session: Any, cmd: int, payload: bytes, response_cmd: int, timeout: float
+    ) -> "tuple[_ListPages, bool]":
+        """Every reply page to one request, and whether any reply came back.
+
+        A session without ``async_avio_request_all`` (an older or a stand-in
+        session) is asked the single-reply way, which is the first page only.
+
+        Not safe to run two at once on one session: replies carry no id this
+        layer can match on SDES, so concurrent listings could take each other's
+        pages. Callers serialise listings per camera.
+        """
+        pages = _ListPages()
+        ask_all = getattr(session, "async_avio_request_all", None)
+        if ask_all is None:
+            reply = await self._sd_ask(session, cmd, payload, response_cmd, timeout)
+            replies = [] if reply is None else [reply]
+        else:
+            try:
+                replies = list(
+                    await ask_all(
+                        cmd,
+                        payload,
+                        response_cmd=response_cmd,
+                        timeout=timeout,
+                        more_timeout=_SD_MORE_PAGES_TIMEOUT_S,
+                        max_replies=_SD_MAX_PAGES,
+                        budget=_SD_LIST_PAGES_BUDGET_S,
+                        done=pages.done,
+                    )
+                )
+            except Exception as exc:
+                _LOGGER.debug(
+                    "SD request %#x failed for %s: %s",
+                    cmd,
+                    getattr(self, "device_id", "?"),
+                    exc,
+                )
+                replies = []
+        pages.take(replies)
+        return pages, bool(replies)
+
     async def async_get_sd_recordings(
         self,
         *,
@@ -115,11 +245,13 @@ class _CameraSdMixin:
         card-bearing A000088 that returns an EMPTY page while 0 returns the
         records - measured 2026-08-11, same session, same window.
 
-        One request each for the list and the occupancy map. The reply is paged
-        and there is no known continuation request: the vendor's handler matches
-        a reply to the sequence number of the single request it sent. So a reply
-        whose end flag is not set comes back with ``complete=False`` rather than
-        with a second request this code would have to invent.
+        One request each for the list and the occupancy map. The list reply is
+        paged, 255 records a page, oldest first, and the camera sends every page
+        unprompted: there is no continuation request and none is needed. All of
+        them are collected (measured 2026-11-01: a PTZ's 7-day window was four
+        pages, 824 records, and reading only the first stopped six days short
+        of today). ``complete=False`` when the end flag never arrived or a page
+        before it is missing.
         """
         session = (
             session if session is not None else getattr(self, "_stream_session", None)
@@ -134,34 +266,14 @@ class _CameraSdMixin:
         end_ts = time.time()
         start_ts = end_ts - days * 86400
 
-        records = []
-        complete = True
-        list_reply = await self._sd_ask(
+        pages, list_answered = await self._sd_ask_pages(
             session,
             LISTEVENT_REQ_CMD,
             listevent_payload(start_ts, end_ts, channel=channel),
             LISTEVENT_RESP_CMD,
             timeout,
         )
-        if list_reply is not None:
-            page = decode_list_event_response(
-                bytes(list_reply.payload or b""), command=LISTEVENT_RESP_CMD
-            )
-            if page is None:
-                # The decode is measured from a handful of live replies and a
-                # reply with a different shape is entirely possible. It is an
-                # empty list with a logged reason, never an exception - but not
-                # a COMPLETE empty list: something came back and could not be
-                # read, so there may well be recordings behind it.
-                complete = False
-                _LOGGER.debug(
-                    "SD list reply for %s did not decode (%d bytes)",
-                    getattr(self, "device_id", "?"),
-                    len(bytes(list_reply.payload or b"")),
-                )
-            else:
-                records = page.events
-                complete = page.end_flag == 1
+        records, complete = pages.records, pages.complete
 
         hours = None
         map_reply = await self._sd_ask(
@@ -181,7 +293,7 @@ class _CameraSdMixin:
             hours=hours,
             # Either reply is enough to prove the camera is listening. Both
             # silent is the case that must never read as an empty card.
-            answered=list_reply is not None or map_reply is not None,
+            answered=list_answered or map_reply is not None,
             complete=complete,
             start_ts=start_ts,
             end_ts=end_ts,

{python_aidot_cameras-1.0.0rc67 → python_aidot_cameras-1.0.0rc68}/pyproject.toml

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 1.0.0rc67
+Version: 1.0.0rc68
 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.0rc67 → python_aidot_cameras-1.0.0rc68}/tests/test_avio_request.py

@@ -218,3 +218,84 @@ async def test_dispatching_a_frame_nobody_asked_for_is_harmless():
     session = _dtls_session(SimpleNamespace(send=lambda data: None))
     assert session.dispatch_avio_frame(_reply()) is False
     assert session.dispatch_avio_frame(b"junk") is False
+
+
+async def test_a_request_answered_in_several_replies_returns_them_all():
+    """The SD listing sends its pages back to back with no further request.
+
+    The second reply follows the first immediately; a waiter registered only
+    after the first reply came back would miss it.
+    """
+    session = None
+
+    def _send_and_answer(data):
+        for body in (b"\x00\x01", b"\x00\x02", b"\x00\x03"):
+            session.dispatch_avio_frame(_reply(payload=body))
+
+    session = _dtls_session(SimpleNamespace(send=_send_and_answer))
+
+    got = await session.async_avio_request_all(
+        SETSTREAMCTRL,
+        response_cmd=SETSTREAMCTRL_RESP,
+        timeout=2.0,
+        more_timeout=0.05,
+    )
+    assert [r.payload for r in got] == [b"\x00\x01", b"\x00\x02", b"\x00\x03"]
+    # Nothing left registered: a reply that turns up later belongs to nobody.
+    assert session.dispatch_avio_frame(_reply()) is False
+
+
+async def test_collecting_replies_stops_when_the_caller_has_enough():
+    session = None
+
+    def _send_and_answer(data):
+        for body in (b"\x00\x01", b"\x00\x02", b"\x00\x03"):
+            session.dispatch_avio_frame(_reply(payload=body))
+
+    session = _dtls_session(SimpleNamespace(send=_send_and_answer))
+
+    got = await session.async_avio_request_all(
+        SETSTREAMCTRL,
+        response_cmd=SETSTREAMCTRL_RESP,
+        timeout=2.0,
+        done=lambda replies: len(replies) == 2,
+    )
+    assert [r.payload for r in got] == [b"\x00\x01", b"\x00\x02"]
+    assert session.dispatch_avio_frame(_reply()) is False
+
+
+async def test_collecting_replies_to_a_command_that_could_not_be_sent():
+    session = _dtls_session(None)  # DataChannel not open
+
+    loop = asyncio.get_running_loop()
+    started = loop.time()
+    got = await session.async_avio_request_all(
+        SETSTREAMCTRL, response_cmd=SETSTREAMCTRL_RESP, timeout=30.0
+    )
+    assert got == []
+    assert loop.time() - started < 1.0
+    assert session.dispatch_avio_frame(_reply()) is False
+
+
+async def test_collecting_replies_gives_up_once_its_budget_is_spent():
+    """Each reply restarts the gap timer; the budget bounds the whole wait."""
+    session = _dtls_session(SimpleNamespace(send=lambda data: None))
+
+    async def _trickle():
+        for _ in range(20):
+            await asyncio.sleep(0.03)
+            session.dispatch_avio_frame(_reply())
+
+    feeder = asyncio.create_task(_trickle())
+    loop = asyncio.get_running_loop()
+    started = loop.time()
+    got = await session.async_avio_request_all(
+        SETSTREAMCTRL,
+        response_cmd=SETSTREAMCTRL_RESP,
+        timeout=1.0,
+        more_timeout=1.0,
+        budget=0.2,
+    )
+    feeder.cancel()
+    assert 1 <= len(got) < 20
+    assert loop.time() - started < 0.5

{python_aidot_cameras-1.0.0rc67 → python_aidot_cameras-1.0.0rc68}/tests/test_sd_listing.py

@@ -243,3 +243,124 @@ async def test_a_session_that_raises_does_not_reach_the_caller():
 
     out = await _Camera(_Angry({})).async_get_sd_recordings()
     assert out is not None and out.records == []
+
+
+class _PagedSession(_Session):
+    """A session that answers the list with every page, like a real camera."""
+
+    def __init__(self, pages, answers=None):
+        super().__init__(answers or {})
+        self._pages = pages
+
+    async def async_avio_request_all(
+        self, cmd, payload, *, response_cmd, max_replies, done, **_timeouts
+    ):
+        self.asked.append((cmd, payload, response_cmd))
+        got = []
+        for body in self._pages[:max_replies]:
+            got.append(_Reply(response_cmd, body))
+            if done(got):
+                break
+        return got
+
+
+@pytest.mark.asyncio
+async def test_every_page_of_a_long_listing_is_read():
+    """Measured 2026-11-01: four pages for one PTZ week, and only the first was read.
+
+    The first page holds the OLDEST records, so stopping there hid every
+    recording newer than the first 255.
+    """
+    session = _PagedSession(
+        [
+            _page([_record(day=5)], total=3, index=0, end_flag=0),
+            _page([_record(day=6)], total=3, index=1, end_flag=0),
+            _page([_record(day=7)], total=3, index=2, end_flag=1),
+        ]
+    )
+    out = await _Camera(session).async_get_sd_recordings()
+    assert [r.day for r in out.records] == [5, 6, 7]
+    assert out.complete is True
+
+
+@pytest.mark.asyncio
+async def test_pages_that_arrive_out_of_order_are_put_back_in_order():
+    session = _PagedSession(
+        [
+            _page([_record(day=6)], total=2, index=1, end_flag=1),
+            _page([_record(day=5)], total=2, index=0, end_flag=0),
+        ]
+    )
+    out = await _Camera(session).async_get_sd_recordings()
+    assert [r.day for r in out.records] == [5, 6]
+    assert out.complete is True
+
+
+@pytest.mark.asyncio
+async def test_a_page_sent_twice_is_counted_once():
+    session = _PagedSession(
+        [
+            _page([_record(day=5)], total=2, index=0, end_flag=0),
+            _page([_record(day=5)], total=2, index=0, end_flag=0),
+            _page([_record(day=6)], total=2, index=1, end_flag=1),
+        ]
+    )
+    out = await _Camera(session).async_get_sd_recordings()
+    assert [r.day for r in out.records] == [5, 6]
+    assert out.complete is True
+
+
+@pytest.mark.asyncio
+async def test_a_missing_page_before_the_end_is_reported_incomplete():
+    session = _PagedSession(
+        [
+            _page([_record(day=5)], total=3, index=0, end_flag=0),
+            _page([_record(day=7)], total=3, index=2, end_flag=1),
+        ]
+    )
+    out = await _Camera(session).async_get_sd_recordings()
+    assert [r.day for r in out.records] == [5, 7]
+    assert out.complete is False
+
+
+@pytest.mark.asyncio
+async def test_pages_that_stop_before_the_end_are_reported_incomplete():
+    session = _PagedSession(
+        [
+            _page([_record(day=5)], total=3, index=0, end_flag=0),
+            _page([_record(day=6)], total=3, index=1, end_flag=0),
+        ]
+    )
+    out = await _Camera(session).async_get_sd_recordings()
+    assert [r.day for r in out.records] == [5, 6]
+    assert out.complete is False
+    assert out.answered is True
+
+
+@pytest.mark.asyncio
+async def test_a_late_page_of_another_listing_is_not_mixed_in():
+    """Every page of one reply declares the same page count; a stray does not."""
+    session = _PagedSession(
+        [
+            _page([_record(day=5)], total=2, index=0, end_flag=0),
+            _page([_record(day=1)], total=4, index=1, end_flag=0),
+            _page([_record(day=6)], total=2, index=1, end_flag=1),
+        ]
+    )
+    out = await _Camera(session).async_get_sd_recordings()
+    assert [r.day for r in out.records] == [5, 6]
+    assert out.complete is True
+
+
+@pytest.mark.asyncio
+async def test_an_end_page_first_with_no_page_count_does_not_end_the_listing():
+    """With no declared count, the pages before the end-flag page are still owed."""
+    session = _PagedSession(
+        [
+            _page([_record(day=6)], total=0, index=1, end_flag=1),
+            _page([_record(day=5)], total=0, index=0, end_flag=0),
+        ]
+    )
+    out = await _Camera(session).async_get_sd_recordings()
+    assert [r.day for r in out.records] == [5, 6]
+    assert out.complete is True