python-aidot-cameras 0.11.5__tar.gz → 0.11.6__tar.gz

{python_aidot_cameras-0.11.5/python_aidot_cameras.egg-info → python_aidot_cameras-0.11.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.11.5
+Version: 0.11.6
 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.11.5 → python_aidot_cameras-0.11.6}/aidot/camera/client.py

@@ -984,7 +984,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
 
         Mirrors the official app's wake (DeviceWakeUpRepos.k()), which fires the
         HTTP wake so a sleeping camera (no live MQTT session) still gets the signal
-        through the cloud, and retries on failure (n.java onError "正在重试").  The
+        through the cloud, and retries on failure (n.java onError "retrying").  The
         MQTT ``lowPowerActiveStateReq`` is also published by the streaming /
         attribute paths; this adds the reliable cloud-side channel.  Non-battery
         cameras are always reachable, so this is a no-op for them.
@@ -1894,7 +1894,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
 
         _MIME = {1: "video/mp4", 2: "application/x-mpegURL"}
 
-        try:
+        async def _fetch():
             async with aiohttp.ClientSession() as session:
                 async with session.post(
                     f"{self._aidot_v32_base}/playback/getEventVideoUrl",
@@ -1905,7 +1905,12 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                     headers=self._aidot_headers(),
                     timeout=aiohttp.ClientTimeout(total=15),
                 ) as resp:
-                    body = await resp.json(content_type=None)
+                    return await resp.json(content_type=None)
+
+        try:
+            body = await _fetch()
+            if self._is_auth_error(body) and await self._async_refresh_auth_token():
+                body = await _fetch()  # retry once with the refreshed token
 
             _LOGGER.debug("getEventVideoUrl raw for %s uuid=%s: %s", self.device_id, event_uuid, body)
 
@@ -1966,7 +1971,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
         end_ts = int(time.time() * 1000)
         start_ts = end_ts - 30 * 86_400_000  # look back 30 days
 
-        try:
+        async def _fetch():
             async with aiohttp.ClientSession() as session:
                 async with session.post(
                     f"{self._aidot_v32_base}/playback/eventRecordingList",
@@ -1980,7 +1985,12 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                     headers=self._aidot_headers(),
                     timeout=aiohttp.ClientTimeout(total=15),
                 ) as resp:
-                    body = await resp.json(content_type=None)
+                    return await resp.json(content_type=None)
+
+        try:
+            body = await _fetch()
+            if self._is_auth_error(body) and await self._async_refresh_auth_token():
+                body = await _fetch()  # retry once with the refreshed token
 
             _LOGGER.debug("thumbnail eventRecordingList for %s: %s", self.device_id, body)
             if body.get("code") != 200:
@@ -2244,6 +2254,20 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
         except (asyncio.CancelledError, Exception):
             _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_reap_stream_drain', exc_info=True)
 
+    def _release_stream_drain_to_session(self):
+        """Hand ownership of the persistent-MQTT signaling drain to the session
+        that just opened successfully.
+
+        The returned WebRTCSession/SdesSession reaps its own outgoing_q + mqtt_fut
+        on stop(); ``_stream_mqtt_drain``/``_stream_mqtt_outq`` are only a backstop
+        for a drain whose open was cancelled *before* a session took ownership.
+        Clearing the slot on hand-off means a concurrent open on this same camera
+        (e.g. a snapshot taken during a live view) no longer reaps - and so no
+        longer kills - the live session's drain; the slot from then on only ever
+        holds a genuinely orphaned (cancelled mid-handshake) drain."""
+        self._stream_mqtt_drain = None
+        self._stream_mqtt_outq = None
+
     async def async_start_motion_polling(
         self, callback: Callable, interval: float = 30.0, lookback_s: int = 600,
     ) -> None:

{python_aidot_cameras-0.11.5 → python_aidot_cameras-0.11.6}/aidot/camera/protocol.py

@@ -536,6 +536,11 @@ def _extract_param_sets_from_rtp(pkt: bytes) -> dict:
         while i + 2 <= len(payload):
             size = int.from_bytes(payload[i:i + 2], "big")
             i += 2
+            if i + size > len(payload):
+                # Truncated STAP-A: the advertised NAL size runs past the end of
+                # the packet, so the remaining bytes are garbage.  Stop rather
+                # than slice a short NAL and cache a corrupt SPS/PPS.
+                break
             nal = payload[i:i + size]
             i += size
             if nal:
@@ -1211,6 +1216,16 @@ def _mqtt_session_sync(
         status["connected"] = (rc == 0)
         status["rc"]        = rc
         status["rc_str"]    = str(reason_code)
+        if rc == 0:
+            # (Re)subscribe on EVERY successful connect.  paho's loop_start
+            # auto-reconnects after a transient drop, but with clean_session the
+            # broker retains no subscriptions, so a reconnected client would be
+            # deaf unless they are re-established here rather than only once below.
+            for _sub in subscribe_topics:
+                try:
+                    c.subscribe(_sub)
+                except Exception:
+                    _LOGGER.debug("_mqtt_session: resubscribe failed for %s", _sub, exc_info=True)
         conn_ev.set()
 
     def _on_message(c, ud, msg):
@@ -1228,10 +1243,23 @@ def _mqtt_session_sync(
         # If _on_connect was never fired (WebSocket upgrade failed, auth refused
         # at TCP level, etc.) signal conn_ev now so the caller doesn't time out.
         if not conn_ev.is_set():
+            # Never connected (WS upgrade failed, auth refused at TCP level, ...):
+            # unblock the caller and end the receive loop - the connect failed.
             status["connected"] = False
             status["rc_str"]    = f"disconnect-before-connect rc={reason_code}"
             conn_ev.set()
-        msg_q.put(None)   # sentinel to unblock the receive loop
+            msg_q.put(None)   # sentinel: end the receive loop
+            return
+        # Already connected once: this is a transient drop.  paho's loop_start
+        # auto-reconnects and _on_connect re-subscribes, so DON'T end the receive
+        # loop here - a broker blip must not tear down a long-lived stream's
+        # signaling (the non-persistent transport runs one session for the whole
+        # stream).  A real teardown ends the loop via the outgoing-queue None
+        # sentinel or the duration deadline instead.
+        _LOGGER.debug(
+            "_mqtt_session: transient disconnect rc=%s (paho will reconnect)",
+            reason_code,
+        )
 
     def _on_log(c, ud, level, buf):
         if len(status["log"]) < 500:
@@ -1279,9 +1307,9 @@ def _mqtt_session_sync(
 
     _LOGGER.info("_mqtt_session: connected to %s:%d clientId=%s", hostname, port, client_id)
 
-    for topic in subscribe_topics:
-        client.subscribe(topic)
-        _LOGGER.debug("_mqtt_session: subscribed %s", topic)
+    # Subscriptions are (re)established in _on_connect so they survive a paho
+    # auto-reconnect; nothing to subscribe here.
+    _LOGGER.debug("_mqtt_session: subscribed (in on_connect) %s", subscribe_topics)
 
     for pub_topic, pub_payload in publish_items:
         client.publish(pub_topic, pub_payload)

{python_aidot_cameras-0.11.5 → python_aidot_cameras-0.11.6}/aidot/camera/sdes_open.py

@@ -47,9 +47,38 @@ def _sdes_echo_wait_timeout(skip_liveplay: bool) -> float:
 
 
 class _SdesOpenMixin:
-    async def _open_sdes_stream(
+    async def _open_sdes_stream(self, **kwargs) -> "SdesSession":
+        """Allocate-and-hand-off wrapper around _open_sdes_stream_impl.
+
+        The impl reserves two UDP sockets, starts a bridge thread, launches
+        ffmpeg and writes a temp SDP, then hands them to the returned
+        SdesSession (whose stop() releases them).  If the cold open is cancelled
+        mid-handshake (25-70s) - or raises before that hand-off - none of that
+        has an owner yet, so a plain call leaks the fds, the thread and a /tmp
+        file on every cancelled attempt (eventually "Too many open files").
+        The impl registers each resource on an ExitStack as it is allocated;
+        close the stack unless the impl actually returned a session.
+        """
+        from contextlib import ExitStack
+
+        _cleanup = ExitStack()
+        _ok = False
+        try:
+            _session = await self._open_sdes_stream_impl(_cleanup=_cleanup, **kwargs)
+            _ok = True
+            return _session
+        finally:
+            if not _ok:
+                # Closing the reservation sockets also unblocks the bridge
+                # thread's recv so it exits; ffmpeg is killed and the SDP file
+                # unlinked.  LIFO, and every callback swallows so this never
+                # masks the original CancelledError/exception.
+                _cleanup.close()
+
+    async def _open_sdes_stream_impl(
         self,
         *,
+        _cleanup=None,
         peer_id: str,
         user_id: str,
         device_id: str,
@@ -120,16 +149,45 @@ class _SdesOpenMixin:
         def _seq() -> str:
             return f"ap{random.randint(1000000, 9999999)}"
 
+        # Register a resource with the wrapper's cleanup stack so it is released
+        # if the cold open is cancelled/raises before the SdesSession takes
+        # ownership.  Each step swallows so ExitStack.close() can never mask the
+        # original CancelledError/exception.  No-op if called without a stack.
+        def _cl(fn, *a):
+            if _cleanup is None:
+                return
+            def _run():
+                try:
+                    fn(*a)
+                except Exception:
+                    _LOGGER.debug(
+                        "camera %s: swallowed sdes-open cleanup step",
+                        getattr(self, "device_id", "?"), exc_info=True,
+                    )
+            _cleanup.callback(_run)
+
+        def _reap(p):
+            try:
+                p.kill()
+            except Exception:
+                pass
+            try:
+                p.poll()   # reap the killed child so it does not linger as a zombie
+            except Exception:
+                pass
+
         # --- Allocate UDP ports and determine local IP ---------------------- #
         import socket as _socket
 
         _audio_sock = _socket.socket(_socket.AF_INET, _socket.SOCK_DGRAM)
         _audio_sock.bind(("0.0.0.0", 0))
         audio_port = _audio_sock.getsockname()[1]
+        _cl(_audio_sock.close)   # also unblocks the bridge thread's recv on cleanup
 
         _video_sock = _socket.socket(_socket.AF_INET, _socket.SOCK_DGRAM)
         _video_sock.bind(("0.0.0.0", 0))
         video_port = _video_sock.getsockname()[1]
+        _cl(_video_sock.close)
 
         # Use the outbound interface toward 8.8.8.8 to find our local IP.
         # connect() on a UDP socket does not send any packet.
@@ -733,6 +791,7 @@ class _SdesOpenMixin:
 
         sdp_path = await asyncio.get_running_loop().run_in_executor(
             None, _make_sdp_tempfile, _inject_sprop(ffmpeg_sdp, self.device_id))
+        _cl(os.unlink, sdp_path)   # released with the sockets on a cancelled open
 
         # --- Send webrtcReq BEFORE releasing reservation sockets ------------- #
         # ICE cameras (e.g. LK.IPC.A001064) send STUN binding requests to our
@@ -3384,6 +3443,7 @@ class _SdesOpenMixin:
                 stderr=subprocess.PIPE,
             )
             _proc_holder[0] = proc
+            _cl(_reap, proc)   # kill ffmpeg if the open is cancelled before hand-off
         except FileNotFoundError:
             # ffmpeg is not installed - clean up and surface a clear error.
             for _rsock in (_audio_sock, _video_sock):

{python_aidot_cameras-0.11.5 → python_aidot_cameras-0.11.6}/aidot/camera/webrtc_open.py

@@ -1209,7 +1209,7 @@ class _WebRTCOpenMixin:
         # ------------------------------------------------------------------ #
         if use_sdes:
             try:
-                return await self._open_sdes_stream(
+                _sdes_session = await self._open_sdes_stream(
                     peer_id=peer_id,
                     user_id=user_id,
                     device_id=device_id,
@@ -1237,6 +1237,13 @@ class _WebRTCOpenMixin:
                     rtsp_push_url=rtsp_push_url,
                     talk=talk,
                 )
+                # Success: the SdesSession now owns outgoing_q + mqtt_fut and
+                # reaps them on stop(); clear the backstop slot so a concurrent
+                # open on this camera cannot reap this live session's drain.
+                # (On _SdesNoAnswerError the await raises before this runs, so the
+                # DTLS-fallback path below keeps the slot for its own hand-off.)
+                self._release_stream_drain_to_session()
+                return _sdes_session
             except CameraMixin._SdesNoAnswerError:
                 # Camera reported enableSdes='1' but did not respond to our SDES
                 # offer.  iOS telemetry shows models such as LK.IPC.A001064 can
@@ -3572,6 +3579,10 @@ class _WebRTCOpenMixin:
         _LOGGER.info(
             "WebRTC stream open for %s (peerid=%s)", device_id, peer_id
         )
+        # Ownership of the signaling drain passes to this session (its stop()
+        # reaps outgoing_q + mqtt_fut); clear the backstop slot so a concurrent
+        # open on this camera cannot reap this live session's drain.
+        self._release_stream_drain_to_session()
         return WebRTCSession(
             pc=pc,
             outgoing_q=outgoing_q,

{python_aidot_cameras-0.11.5 → python_aidot_cameras-0.11.6}/aidot/client.py

@@ -50,6 +50,27 @@ _LOGGER = logging.getLogger(__name__)
 # other cloud API calls that use owner+token headers.
 _CLOUD_APP_ID = "68"
 
+# Strong refs to fire-and-forget tasks: asyncio only keeps weak refs, so a
+# discarded task can be garbage-collected mid-flight (see camera/client.py).
+_BG_TASKS: set = set()
+
+
+def _spawn_bg(coro):
+    _t = asyncio.ensure_future(coro)
+    _BG_TASKS.add(_t)
+
+    def _done(task):
+        _BG_TASKS.discard(task)
+        # Retrieve the exception so a failing background task doesn't surface as
+        # an unhandled "Task exception was never retrieved" at GC time; log it.
+        if not task.cancelled():
+            exc = task.exception()
+            if exc is not None:
+                _LOGGER.debug("aidot background task failed: %r", exc, exc_info=exc)
+
+    _t.add_done_callback(_done)
+    return _t
+
 
 def rsa_password_encrypt(message: str) -> str:
     """RSA-encrypt the password using the AiDot public key (for loginWithFreeVerification)."""
@@ -513,9 +534,7 @@ class AidotClient:
             device_client.set_token_refresh_cb(self.async_ensure_token)
             self._device_clients[device_id] = device_client
             # Pre-warm ICE config cache so stream open does not block on this fetch.
-            asyncio.get_running_loop().create_task(
-                _prefetch_ice_config(device_client)
-            )
+            _spawn_bg(_prefetch_ice_config(device_client))
         # Started lazily here as well: __init__ cannot start discovery when
         # constructed outside a running event loop (stored-token sync path).
         if self._discover is None:
@@ -583,7 +602,7 @@ class AidotClient:
 
     def cleanup(self) -> None:
         """Sync entry point: fire-and-forget async_close()."""
-        asyncio.get_running_loop().create_task(self.async_close())
+        _spawn_bg(self.async_close())
 
     async def async_cleanup(self) -> None:
         """Async entry point: close the client and release resources."""

{python_aidot_cameras-0.11.5 → python_aidot_cameras-0.11.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-aidot-cameras"
-version = "0.11.5"
+version = "0.11.6"
 description = "Control AiDot/Leedarson WiFi lights and cameras (WebRTC streaming, two-way audio, PTZ, controls)"
 readme = "README.md"
 license = "MIT"

{python_aidot_cameras-0.11.5 → python_aidot_cameras-0.11.6/python_aidot_cameras.egg-info}/PKG-INFO

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

@@ -90,6 +90,7 @@ tests/test_keyframe_prompter.py
 tests/test_lan_control.py
 tests/test_live_stream_param.py
 tests/test_motion_poll.py
+tests/test_mqtt_session_reconnect.py
 tests/test_narrow_pc_ice.py
 tests/test_no_undefined_names.py
 tests/test_offline_keepalive_pause.py
@@ -103,6 +104,7 @@ tests/test_sdes_adaptive.py
 tests/test_sdes_echo_wait_timeout.py
 tests/test_sdes_fast_liveplay.py
 tests/test_sdes_idle_release.py
+tests/test_sdes_open_cleanup.py
 tests/test_sdes_serve_audio.py
 tests/test_sdes_serve_cmd.py
 tests/test_sdes_sprop.py
@@ -114,6 +116,7 @@ tests/test_serve_relay.py
 tests/test_session_stats.py
 tests/test_speak.py
 tests/test_stream_cap.py
+tests/test_stream_drain_ownership.py
 tests/test_stream_idle.py
 tests/test_stream_teardown.py
 tests/test_talk.py

python_aidot_cameras-0.11.6/tests/test_mqtt_session_reconnect.py

@@ -0,0 +1,84 @@
+"""Transient-reconnect resilience of the per-stream MQTT signaling session.
+
+_mqtt_session_sync runs one paho session for the (up to 3600s) lifetime of a
+stream on the non-persistent transport. A transient broker drop must NOT end the
+receive loop - paho's loop_start auto-reconnects and _on_connect re-subscribes
+(clean_session retains nothing). Only a disconnect that happens before the first
+successful connect should end the session. Driven with a fake paho client.
+"""
+import queue
+import threading
+import time
+
+import aidot.camera.protocol as proto
+
+
+class _FakeMsg:
+    def __init__(self, topic, payload):
+        self.topic = topic
+        self.payload = payload
+
+
+def _install_fake_client(monkeypatch, driver):
+    """Patch paho's Client with a fake whose loop_start() runs ``driver(client)``
+    in a daemon thread, so it can fire callbacks while the receive loop runs."""
+    class _FakeClient:
+        def __init__(self, *a, **k):
+            self.subs = []
+            self.on_connect = self.on_message = self.on_disconnect = self.on_log = None
+        def ws_set_options(self, **k): pass
+        def username_pw_set(self, *a, **k): pass
+        def tls_set_context(self, *a, **k): pass
+        def connect(self, *a, **k): pass
+        def subscribe(self, topic): self.subs.append(topic)
+        def publish(self, *a, **k): pass
+        def loop_start(self):
+            threading.Thread(target=driver, args=(self,), daemon=True).start()
+        def loop_stop(self): pass
+        def disconnect(self): pass
+
+    monkeypatch.setattr("paho.mqtt.client.Client", _FakeClient)
+
+
+def test_transient_disconnect_keeps_receiving_and_resubscribes(monkeypatch):
+    outgoing = queue.Queue()
+    seen_subs = []
+
+    def driver(c):
+        c.on_connect(c, None, {}, 0)          # first successful connect
+        seen_subs.append(list(c.subs))
+        c.on_disconnect(c, None, 0)           # transient drop (already connected)
+        time.sleep(0.02)
+        c.on_connect(c, None, {}, 0)          # paho auto-reconnect -> resubscribe
+        seen_subs.append(list(c.subs))
+        # Arrives only AFTER the transient drop: collected only if the receive
+        # loop survived the disconnect.
+        c.on_message(c, None, _FakeMsg("t/after", b"live"))
+        time.sleep(0.02)
+        outgoing.put_nowait(None)             # clean stop
+
+    _install_fake_client(monkeypatch, driver)
+
+    messages, status = proto._mqtt_session_sync(
+        "wss://broker.example/mqtt", "u", "p", "cid",
+        ["t/a", "t/b"], [], 5.0,
+        outgoing_queue=outgoing,
+    )
+
+    assert ("t/after", "live") in messages               # survived the transient drop
+    assert seen_subs[0] == ["t/a", "t/b"]                # subscribed on first connect
+    assert seen_subs[1] == ["t/a", "t/b", "t/a", "t/b"]  # resubscribed on reconnect
+
+
+def test_disconnect_before_connect_ends_session(monkeypatch):
+    def driver(c):
+        c.on_disconnect(c, None, 7)           # never connected -> end + report failure
+
+    _install_fake_client(monkeypatch, driver)
+
+    messages, status = proto._mqtt_session_sync(
+        "wss://broker.example/mqtt", "u", "p", "cid",
+        ["t/a"], [], 5.0,
+    )
+    assert messages == []
+    assert status["connected"] is False

python_aidot_cameras-0.11.6/tests/test_sdes_open_cleanup.py

@@ -0,0 +1,72 @@
+"""Resource-cleanup plumbing for the SDES cold-open wrapper.
+
+_open_sdes_stream reserves UDP sockets, a bridge thread, ffmpeg and a temp SDP
+before handing them to the returned SdesSession.  If the cold open is cancelled
+mid-handshake (or raises) before that hand-off, the wrapper must release them via
+its ExitStack; on a successful return it must NOT (the session now owns them).
+These tests exercise that wrapper mechanism directly with a stub impl.
+"""
+import asyncio
+import types
+
+import pytest
+
+from aidot.camera.client import CameraMixin
+
+
+def _wrapper_for(impl):
+    obj = types.SimpleNamespace()
+    obj._open_sdes_stream_impl = impl
+    return CameraMixin._open_sdes_stream.__get__(obj)
+
+
+def test_open_sdes_wrapper_cleans_up_on_cancel():
+    ran = []
+
+    async def impl(_cleanup=None, **kwargs):
+        _cleanup.callback(lambda: ran.append("cleaned"))
+        raise asyncio.CancelledError()
+
+    with pytest.raises(asyncio.CancelledError):
+        asyncio.run(_wrapper_for(impl)(peer_id="x"))
+    assert ran == ["cleaned"]
+
+
+def test_open_sdes_wrapper_cleans_up_on_error():
+    ran = []
+
+    async def impl(_cleanup=None, **kwargs):
+        _cleanup.callback(lambda: ran.append("cleaned"))
+        raise RuntimeError("boom")
+
+    with pytest.raises(RuntimeError):
+        asyncio.run(_wrapper_for(impl)(peer_id="x"))
+    assert ran == ["cleaned"]
+
+
+def test_open_sdes_wrapper_skips_cleanup_on_success():
+    ran = []
+    sentinel = object()
+
+    async def impl(_cleanup=None, **kwargs):
+        _cleanup.callback(lambda: ran.append("cleaned"))
+        return sentinel
+
+    result = asyncio.run(_wrapper_for(impl)(peer_id="x"))
+    assert result is sentinel
+    assert ran == []  # ownership transferred to the session; cleanup must NOT run
+
+
+def test_open_sdes_wrapper_runs_cleanups_lifo():
+    # Steps run last-registered-first, so ffmpeg is killed before its sockets
+    # close (mirrors the impl's registration order: sockets, then sdp, then proc).
+    order = []
+
+    async def impl(_cleanup=None, **kwargs):
+        _cleanup.callback(lambda: order.append("sock"))
+        _cleanup.callback(lambda: order.append("proc"))
+        raise asyncio.CancelledError()
+
+    with pytest.raises(asyncio.CancelledError):
+        asyncio.run(_wrapper_for(impl)(peer_id="x"))
+    assert order == ["proc", "sock"]  # LIFO

{python_aidot_cameras-0.11.5 → python_aidot_cameras-0.11.6}/tests/test_sdes_sprop.py

@@ -52,6 +52,22 @@ def test_stap_a_carries_both():
     assert _extract_param_sets_from_rtp(RTP + stap) == {7: SPS, 8: PPS}
 
 
+def test_stap_a_truncated_size_is_dropped():
+    # Advertised NAL size overruns the packet (frame loss / relay truncation):
+    # the parser must NOT slice a short NAL and cache it as a corrupt SPS.
+    stap = bytes([0x78])
+    stap += (len(SPS) + 50).to_bytes(2, "big") + SPS   # claims 50 extra bytes
+    assert _extract_param_sets_from_rtp(RTP + stap) == {}
+
+
+def test_stap_a_keeps_valid_prefix_before_truncation():
+    # A valid SPS followed by a truncated PPS: keep the SPS, drop the garbage.
+    stap = bytes([0x78])
+    stap += len(SPS).to_bytes(2, "big") + SPS            # valid SPS
+    stap += (len(PPS) + 20).to_bytes(2, "big") + PPS     # truncated PPS
+    assert _extract_param_sets_from_rtp(RTP + stap) == {7: SPS}
+
+
 def test_slice_packet_yields_nothing():
     # NAL type 1 (non-IDR slice) - not a parameter set
     assert _extract_param_sets_from_rtp(RTP + bytes([0x61, 0x00, 0x11])) == {}

python_aidot_cameras-0.11.6/tests/test_stream_drain_ownership.py

@@ -0,0 +1,73 @@
+"""Persistent-MQTT signaling-drain ownership on the camera stream path.
+
+The DeviceClient keeps a single backstop slot (_stream_mqtt_drain/_stream_mqtt_outq)
+for a drain whose open was cancelled before a WebRTC/SdesSession took ownership.
+A successful open hands ownership to the session (which reaps the drain on stop)
+and clears the slot - so a *concurrent* open on the same camera (e.g. a snapshot
+during a live view) no longer reaps, and kills, the live session's drain.
+"""
+import asyncio
+import types
+
+from aidot.camera.client import CameraMixin
+
+
+class _FakeFut:
+    def __init__(self):
+        self.cancelled_flag = False
+
+    def done(self):
+        return False
+
+    def cancel(self):
+        self.cancelled_flag = True
+
+    def __await__(self):
+        if False:
+            yield
+        return None
+
+
+class _RecordingQueue:
+    def __init__(self):
+        self.puts = []
+
+    def put_nowait(self, item):
+        self.puts.append(item)
+
+
+def _client_with_drain():
+    obj = types.SimpleNamespace(
+        _stream_mqtt_drain=_FakeFut(),
+        _stream_mqtt_outq=_RecordingQueue(),
+        device_id="cam",
+    )
+    obj._reap_stream_drain = CameraMixin._reap_stream_drain.__get__(obj)
+    obj._release_stream_drain_to_session = (
+        CameraMixin._release_stream_drain_to_session.__get__(obj)
+    )
+    return obj
+
+
+def test_handoff_makes_a_concurrent_reap_a_noop():
+    obj = _client_with_drain()
+    fut, q = obj._stream_mqtt_drain, obj._stream_mqtt_outq
+
+    obj._release_stream_drain_to_session()          # session took ownership
+    assert obj._stream_mqtt_drain is None
+
+    asyncio.run(obj._reap_stream_drain())           # a concurrent open reaps
+    assert q.puts == []                             # live drain NOT sentinel-killed
+    assert not fut.cancelled_flag                   # live drain NOT cancelled
+
+
+def test_backstop_still_reaps_an_orphaned_drain():
+    # Without a hand-off (open cancelled mid-handshake) the slot still holds the
+    # drain, and the reap must release it: sentinel to the queue + cancel.
+    obj = _client_with_drain()
+    fut, q = obj._stream_mqtt_drain, obj._stream_mqtt_outq
+
+    asyncio.run(obj._reap_stream_drain())
+    assert q.puts == [None]                          # orphan drain released
+    assert fut.cancelled_flag
+    assert obj._stream_mqtt_drain is None            # slot cleared