python-aidot-cameras 0.16.0__tar.gz → 0.17.0__tar.gz

{python_aidot_cameras-0.16.0/python_aidot_cameras.egg-info → python_aidot_cameras-0.17.0}/PKG-INFO

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

@@ -376,6 +376,18 @@ _SERVE_REORDER_QUEUE = int(os.environ.get("AIDOT_SERVE_REORDER_QUEUE", "500"))
 #: failure this is meant to prevent.
 _SERVE_MAX_DELAY_US = int(os.environ.get("AIDOT_SERVE_MAX_DELAY_US", "500000"))
 
+#: How long to wait after a camera answers -50002 / -50015 ("no free session").
+#: Both loops used to wait _MAX_DELAY (300s) on the belief that the camera
+#: "releases slowly". Measured 2026-08-07 on an A001064: reopening 2s after a
+#: close is refused, 8s reopens cleanly, every time - and that was minting a
+#: fresh peerid each attempt, the case the old comment warned about. A camera
+#: that clears in seconds paired with a five-minute refusal to retry is
+#: indistinguishable from one that needs a long rest, which is the likeliest
+#: origin of this project's "battery cameras need 30-45 minutes" rule.
+#: Still a real wait: retrying instantly would hammer a camera that genuinely
+#: has none free, and on a battery model risks a wake-then-sleep loop.
+_BUSY_BACKOFF_S = float(os.environ.get("AIDOT_BUSY_BACKOFF_S", "20"))
+
 
 def _build_sdes_serve_cmd(
     *,
@@ -773,6 +785,39 @@ _KEEPALIVE_WINDOW_S = 25
 _KEEPALIVE_RENEW_S = 20
 
 
+def _ack_matches_seq(msg, seq):
+    """Is ``msg`` the device's answer to the command we sent as ``seq``?
+
+    ``True`` for our own 200, the integer response code for our own non-200,
+    and ``False`` for anything that is not attributable to us - another
+    command's ack, the battery wake response, a message with no seq at all.
+
+    Correlating matters because several messages are in flight on the same four
+    wildcard subscriptions: battery cameras get a ``lowPowerActiveStateReq``
+    published alongside the write, and Home Assistant writes attributes in
+    bursts. Accepting a stranger's 200 reports that one control landed on the
+    evidence of a different one landing.
+    """
+    if not isinstance(msg, dict) or seq is None:
+        return False
+    got = msg.get("seq")
+    if got is None:
+        return False
+    # We send a string; nothing obliges the camera to echo the same type.
+    if str(got) != str(seq):
+        return False
+    code = (msg.get("ack") or {}).get("code")
+    if code is None:
+        code = msg.get("code")
+    if code is None:
+        inner = msg.get("payload") or {}
+        if isinstance(inner, dict):
+            code = inner.get("code")
+    if code == 200:
+        return True
+    return code if isinstance(code, int) else False
+
+
 class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
     """All camera/streaming methods, mixed into DeviceClient via inheritance."""
 
@@ -1902,6 +1947,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
         *,
         timeout: float = 8.0,
         ack_keyword: str = "setDevAttr",
+        seq: "Optional[str]" = None,
     ) -> bool:
         """Connect MQTT, optionally wake battery camera, publish command, wait for ack.
 
@@ -1980,6 +2026,36 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                 duration=timeout,
             )
 
+        # Two passes, because being sure is worth more than being quick. A
+        # response carrying OUR seq is proof; anything else on these topics is
+        # only evidence that SOMETHING was acked - and several things are in
+        # flight here (the battery wake goes out alongside the write, and Home
+        # Assistant writes attributes in bursts).
+        for topic, raw in messages:
+            if ack_keyword and ack_keyword not in topic:
+                continue
+            try:
+                msg = _json.loads(raw)
+            except Exception:
+                continue
+            mine = _ack_matches_seq(msg, seq)
+            if mine is True:
+                _LOGGER.debug("device cmd ack 200 for seq=%s: topic=%s", seq, topic)
+                return True
+            if mine is not False:
+                # The camera answered OUR command with a non-200. Logged, not
+                # acted on: whether this firmware ever sends one is unknown, and
+                # turning it into a failure on a guess would report every
+                # working write as broken the moment the guess is wrong. If
+                # these show up in the wild, that is the evidence needed to make
+                # it a real error.
+                _LOGGER.warning(
+                    "device cmd for %s answered with code %s (seq=%s, topic=%s) "
+                    "- reporting the command as sent anyway; please report this "
+                    "log line, it is the evidence needed to handle it properly",
+                    device_id, mine, seq, topic,
+                )
+
         for topic, raw in messages:
             if ack_keyword and ack_keyword not in topic:
                 continue
@@ -1987,14 +2063,17 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                 msg = _json.loads(raw)
             except Exception:
                 continue
+            if _ack_matches_seq(msg, seq) is not False:
+                continue  # already considered above
             code = (msg.get("ack") or {}).get("code") or msg.get("code")
             if code == 200:
-                _LOGGER.debug("device cmd ack 200: topic=%s", topic)
+                _LOGGER.debug("device cmd ack 200 (unattributed): topic=%s", topic)
                 return True
             # Some firmware ACKs with code in payload.payload
             inner = msg.get("payload") or {}
             if isinstance(inner, dict) and inner.get("code") == 200:
-                _LOGGER.debug("device cmd ack 200 (inner): topic=%s", topic)
+                _LOGGER.debug(
+                    "device cmd ack 200 (inner, unattributed): topic=%s", topic)
                 return True
 
         # Fire-and-forget fallback: the official app uses a delivery callback,
@@ -2070,7 +2149,8 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
         pub_topic = f"iot/v1/c/{device_id}/device/setDevAttrReq"
         _LOGGER.info("setDevAttrReq: %s=%s -> %s  seq=%s", attr, value, device_id, seq)
         ok = await self._mqtt_device_cmd(
-            pub_topic, payload, timeout=timeout, ack_keyword="setDevAttr")
+            pub_topic, payload, timeout=timeout, ack_keyword="setDevAttr",
+            seq=seq)
         if ok:
             # Reflect the change in local status right away (optimistic), so HA
             # control entities show the new value immediately instead of waiting
@@ -3352,14 +3432,17 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                 # wake-then-sleep loop that serves nothing. Wait out the release
                 # window instead. (The DTLS loops have always done this; the SDES
                 # loop silently did not.)
+                #
+                # That release window is now measured rather than assumed: 8s is
+                # enough, 2s is not. See _BUSY_BACKOFF_S.
                 self._fast_attempt_override = None
                 _LOGGER.warning(
                     "SDES keepalive: camera %s refused the stream (%s) - "
                     "backing off %.0fs so its sessions can be released",
-                    self.device_id, busy, _MAX_DELAY,
+                    self.device_id, busy, _BUSY_BACKOFF_S,
                 )
                 try:
-                    await asyncio.sleep(_MAX_DELAY)
+                    await asyncio.sleep(_BUSY_BACKOFF_S)
                 except asyncio.CancelledError:
                     return
                 continue
@@ -3577,10 +3660,10 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                 # before trying again rather than hammering it.
                 _LOGGER.warning(
                     "Stream refused for %s (%s) - backing off %.0fs before retry",
-                    self.device_id, busy, _MAX_DELAY,
+                    self.device_id, busy, _BUSY_BACKOFF_S,
                 )
                 try:
-                    await asyncio.sleep(_MAX_DELAY)
+                    await asyncio.sleep(_BUSY_BACKOFF_S)
                 except asyncio.CancelledError:
                     return
                 continue

{python_aidot_cameras-0.16.0 → python_aidot_cameras-0.17.0}/aidot_cameras/camera/controls.py

@@ -13,6 +13,11 @@ from .constants import _PTZ_DIR_CODES, _STREAM_QUALITY, SETSTREAMCTRL_CMD
 
 _LOGGER = logging.getLogger(__name__)
 
+#: The camera's ack for SETSTREAMCTRL (800).
+SETSTREAMCTRL_RESP_CMD = 801
+#: Measured 0.01-0.03s; short so a control call never holds up a view.
+_SETSTREAMCTRL_ACK_S = 1.5
+
 
 class _CameraControlsMixin:
     """Device-control setters mixed into CameraMixin."""
@@ -166,12 +171,32 @@ class _CameraControlsMixin:
                 "resolution %s remembered; the camera is not streaming, so it "
                 "will be applied when a session next starts", quality)
             return True
-        ok = session._avio_cmd(SETSTREAMCTRL_CMD, payload)
-        _LOGGER.debug(
-            "set resolution %s (quality=%d) -> %s",
-            quality, q, "sent" if ok else "no channel yet",
+        # Ask, and read what comes back.  The camera acks with 801 in
+        # 0.01-0.03s (measured 2026-08-07 on an A000088) and reports the new
+        # value through GETSTREAMCTRL afterwards, so the command is genuinely
+        # accepted - it simply does not change the encode.
+        #
+        # The RETURN value deliberately still means "the command went out". An
+        # A001064 answers SPEAKERSTART but does not implement GETSTREAMCTRL at
+        # all, so how much a given firmware answers is model-dependent, and
+        # turning silence into a failure would break this call on exactly the
+        # quieter cameras. Reading the reply is what we could not do before; it
+        # makes a refusal visible instead of indistinguishable from success.
+        reply = await session.async_avio_request(
+            SETSTREAMCTRL_CMD, payload,
+            response_cmd=SETSTREAMCTRL_RESP_CMD, timeout=_SETSTREAMCTRL_ACK_S,
         )
-        return ok
+        if reply is None:
+            _LOGGER.debug(
+                "set resolution %s (quality=%d): sent, no ack within %.1fs",
+                quality, q, _SETSTREAMCTRL_ACK_S,
+            )
+        else:
+            _LOGGER.debug(
+                "set resolution %s (quality=%d): camera acked %d payload=%s",
+                quality, q, reply.command, reply.payload.hex() or "<empty>",
+            )
+        return True
 
     def _apply_pending_resolution(self) -> None:
         """Re-send the remembered resolution now that a session exists.

{python_aidot_cameras-0.16.0 → python_aidot_cameras-0.17.0}/aidot_cameras/camera/protocol.py

@@ -2356,6 +2356,69 @@ def _avio_cmd_id(frame: bytes) -> "Optional[int]":
 AVIO_RESPONSE_TIMEOUT_S = 2.0
 
 
+#: How long to wait for the camera's SPEAKERSTART ack before opening the mic
+#: anyway.  Measured 0.01-0.86s across both transports; this is generous enough
+#: to cover a slow SDES open without making a press-to-talk feel stuck.
+SPEAKER_ACK_TIMEOUT_S = 2.0
+
+#: Ack payloads observed for SPEAKERSTART, all of them on speakers that opened:
+#: 0x0064 (M3 Pro / DTLS, PTZ / SDES, and an L2) and 0x00c8 (the same L2, on the
+#: very next session). One camera returning both across consecutive successful
+#: opens is what settles it - the payload is not a verdict, so there is nothing
+#: here to read as a refusal.
+_SPEAKER_ACKS_SEEN = (b"\x00\x64", b"\x00\xc8")
+
+
+async def _speaker_opened(session, cmd: int, resp_cmd: int, timeout: float) -> bool:
+    """Send SPEAKERSTART and decide whether the camera opened its speaker.
+
+    Everything currently counts as success, and that is the honest position
+    rather than a placeholder. Silence does, because an A001064 answers 848 but
+    does not implement 802 at all - a firmware with no response for a command is
+    a real and common state, and failing on it would remove two-way audio from
+    every camera quieter than the one measured. And any ack does, because no
+    refusal has ever been observed: the payload varies across models AND across
+    consecutive sessions on one camera, so it carries no verdict to read.
+
+    An earlier version treated 0x0064 as "the" success value and any other
+    two-byte payload as a refusal. That was a discriminator invented from a
+    single sample, and it would have disabled talk outright on an L2, which
+    answers 0x00c8 about half the time. The payload is logged instead, so a
+    genuine refusal can be recognised from evidence when one appears.
+    """
+    waiter = session._avio_responses.expect(resp_cmd)
+    try:
+        sent = session._avio_cmd(cmd, b"\x00" * 8)
+    except Exception:
+        sent = False
+    if not sent:
+        waiter.cancel()
+        return True  # no channel to refuse on; unchanged from before
+    return await _speaker_ack_accepted(waiter, timeout)
+
+
+async def _speaker_ack_accepted(waiter, timeout: float) -> bool:
+    """Read a SPEAKERSTART ack, defaulting to acceptance on anything unfamiliar.
+
+    Shared by both transports because the decision is the same, even though the
+    send is not: on SDES the command leaves from the bridge thread and this only
+    ever waits.
+    """
+    reply = await waiter.result(timeout)
+    if reply is None:
+        _LOGGER.debug("SPEAKERSTART: no ack within %.1fs - treating as opened", timeout)
+        return True
+    if reply.payload not in _SPEAKER_ACKS_SEEN:
+        _LOGGER.info(
+            "SPEAKERSTART acked with an unrecorded payload %s - treating the "
+            "speaker as open. Please report this: the payloads seen so far all "
+            "belong to speakers that opened, so a genuine refusal has never "
+            "been identified and this may be the first",
+            reply.payload.hex() or "<empty>",
+        )
+    return True
+
+
 class AvioRequestMixin:
     """Ask an AVIO command and wait for the camera's reply.
 

{python_aidot_cameras-0.16.0 → python_aidot_cameras-0.17.0}/aidot_cameras/camera/sdes.py

@@ -9,11 +9,25 @@ import asyncio
 import logging
 from typing import Callable, Optional
 
-from .constants import SDES_TALK_PUMP_IDLE_TICK
-from .protocol import AvioRequestMixin, AvioResponseRouter
+from .constants import SDES_SPEAKERSTART_DELAY, SDES_TALK_PUMP_IDLE_TICK
+from .protocol import (
+    SPEAKER_ACK_TIMEOUT_S,
+    AvioRequestMixin,
+    AvioResponseRouter,
+    _speaker_ack_accepted,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
+#: The bridge does not send SPEAKERSTART the moment talk starts - it waits
+#: SDES_SPEAKERSTART_DELAY after the command channel is up, because a
+#: SPEAKERSTART sent too early is ignored and never acked.  The ack budget
+#: has to cover that delay as well as the round trip, or the wait expires
+#: before the command has even left and every press-to-talk pays the full
+#: timeout for no verdict.
+SDES_SPEAKER_ACK_TIMEOUT_S = SDES_SPEAKERSTART_DELAY + SPEAKER_ACK_TIMEOUT_S
+
+
 
 class SdesSession(AvioRequestMixin):
     """Active SDES-SRTP stream session managed by an ffmpeg subprocess.
@@ -41,6 +55,7 @@ class SdesSession(AvioRequestMixin):
         first_audio_pt=None,
         device_id=None,
         responses=None,
+        abort_chan=None,
     ) -> None:
         # Which camera this session belongs to, for logging only.  Optional so
         # an existing caller that does not pass it still works; the logs then
@@ -87,6 +102,12 @@ class SdesSession(AvioRequestMixin):
         self._avio_responses = (
             responses if responses is not None else AvioResponseRouter()
         )
+        # Mutable one-element list the bridge fills with a callable that sends
+        # an SCTP ABORT.  Unlike SPEAKERSTART this is safe to call from here:
+        # ABORT carries no TSN, so there is nothing for it to race, and it is
+        # the last thing the association ever sees.  None when the caller
+        # supplied no holder - teardown then behaves exactly as it did before.
+        self._abort_chan = abort_chan if abort_chan is not None else [None]
         # Shared talk state (dict) for outbound two-way audio, or None when the
         # session was not opened talk-capable (offer stayed recvonly).  Populated
         # by the bridge (camera audio addr) and by async_start_talk (provider).
@@ -138,13 +159,24 @@ class SdesSession(AvioRequestMixin):
         # SPEAKERSTART(848) is sent by the BRIDGE thread (not here) once the SCTP
         # command channel is up - all SCTP DATA must stay on one thread or the
         # command races the heartbeat's TSN and the camera drops it.
+        # Register interest BEFORE the pump starts, so the ack cannot arrive
+        # while nothing is listening.  Note this does NOT send 848 - the bridge
+        # thread does, once want_speaker is set.  Moving the send here would put
+        # SCTP DATA on a second thread, racing the heartbeat's TSN.
+        waiter = self._avio_responses.expect(851)
         if self._talk_thread is None or not self._talk_thread.is_alive():
             import threading
             self._talk_thread = threading.Thread(
                 target=_run_sdes_talk_pump, args=(self._talk_state,), daemon=True
             )
             self._talk_thread.start()
-        return True
+        if await _speaker_ack_accepted(waiter, SDES_SPEAKER_ACK_TIMEOUT_S):
+            return True
+        # The camera refused. Stop the microphone rather than stream viewer
+        # audio at a speaker that never opened.
+        self._talk_state["want_speaker"] = False
+        self._talk_state["provider"] = None
+        return False
 
     async def async_stop_talk(self) -> bool:
         """End two-way audio: close the camera speaker and stop sending audio."""
@@ -279,6 +311,23 @@ class SdesSession(AvioRequestMixin):
                 await asyncio.sleep(0.3)
             self._talk_state["stop"] = True
             self._talk_state["provider"] = None
+        # Close the SCTP association BEFORE anything else, while the bridge
+        # loop that sends it is still running - it dies with ffmpeg.  Measured
+        # 2026-08-07: reopening 2s after a close is refused with -50002 while 8s
+        # is fine, because the camera holds the session until it works out we
+        # have gone.  We were the only one of the three implementations that
+        # never said so; the official app disposes its data channel and our own
+        # DTLS path sends this same chunk.
+        _abort = self._abort_chan[0]
+        if _abort is not None:
+            try:
+                if _abort():
+                    _LOGGER.debug("camera %s: sent SCTP ABORT at teardown",
+                                  self._device_id)
+            except Exception:
+                # Never let closing politely stop us closing at all.
+                _LOGGER.debug("camera %s: swallowed exception in %s",
+                              self._device_id, 'stop', exc_info=True)
         # Flag this as a locally-initiated teardown BEFORE signalling ffmpeg, so
         # the bridge thread's observe loop never races a look at a stale False
         # if it polls the exit code immediately after terminate()/kill().

{python_aidot_cameras-0.16.0 → python_aidot_cameras-0.17.0}/aidot_cameras/camera/sdes_open.py

@@ -48,6 +48,22 @@ _LOGGER = logging.getLogger(__name__)
 _MEDIA_RCVBUF_BYTES = 4 * 1024 * 1024
 
 
+def _sctp_abort_chunk() -> bytes:
+    """An SCTP ABORT chunk (RFC 4960 s3.3.7): type 6, T=0, no parameters.
+
+    Sent at teardown so the camera learns the association is over rather than
+    timing it out. Measured 2026-08-07: reopening 2s after a close is refused
+    with -50002 (session-exceed) while 8s is fine, and we were the only one of
+    the three implementations saying nothing - the official app disposes its
+    data channel and our own DTLS path (aiortc) sends this same chunk.
+
+    T=0 because we hold the peer's verification tag and send it in the common
+    header; the T bit is for an endpoint reflecting a tag it does not have.
+    """
+    import struct as _st_ab
+    return _st_ab.pack("!BBH", 6, 0, 4)
+
+
 def _dispatch_sctp_avio(responses, payload) -> bool:
     """Offer an inbound SCTP DATA payload to the AVIO response router.
 
@@ -2793,6 +2809,9 @@ class _SdesOpenMixin:
         # once the SCTP DataChannel is established.  SdesSession reads it via
         # _cmd_chan[0] to dispatch PTZ / IOCtrl commands from the main thread.
         _cmd_chan: list = [None]
+        # Bridge installs the SCTP ABORT sender here once the command
+        # channel is up; teardown calls it to close the association.
+        _abort_chan: list = [None]
         # The other direction: matches the camera's AVIO replies to the commands
         # that asked for them.  Created here, not in SdesSession, because the
         # bridge thread starts dispatching into it before the session object
@@ -3153,7 +3172,30 @@ class _SdesOpenMixin:
                                     except Exception:
                                         _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_persistent_sdes_cmd', exc_info=True)
 
+                                def _persistent_sdes_abort():
+                                    """ABORT the association from the same socket the commands use.
+
+                                    Lives here rather than in the bridge's main
+                                    loop because this is where the encrypted
+                                    SCTP context actually is - the dcep socket,
+                                    the peer tag and the encrypt helper. An
+                                    earlier attempt to send it from the media
+                                    loop referenced none of them and would not
+                                    have compiled.
+                                    """
+                                    _csock = _sctp.get('dcep_sock')
+                                    _csrc  = _sctp.get('dcep_src')
+                                    if _csock is None or _csrc is None:
+                                        return False
+                                    _csock.sendto(
+                                        _enc_c8_sctp(_sctp_pkt(_sctp['peer_tag'],
+                                                               _sctp_abort_chunk())),
+                                        _csrc,
+                                    )
+                                    return True
+
                                 _cmd_chan[0] = _persistent_sdes_cmd
+                                _abort_chan[0] = _persistent_sdes_abort
                             except Exception as _dw_e:
                                 _status(f"SDES DC: DCEP_WAIT LIVING err: {_dw_e}")
 
@@ -5024,4 +5066,5 @@ class _SdesOpenMixin:
             first_audio_pt=_first_audio_pt,
             device_id=getattr(self, "device_id", None),
             responses=_avio_responses,
+            abort_chan=_abort_chan,
         )

{python_aidot_cameras-0.16.0 → python_aidot_cameras-0.17.0}/aidot_cameras/camera/webrtc.py

@@ -12,7 +12,12 @@ import struct
 import time
 from typing import Any, Callable, Optional
 
-from .protocol import AvioRequestMixin, AvioResponseRouter
+from .protocol import (
+    SPEAKER_ACK_TIMEOUT_S,
+    AvioRequestMixin,
+    AvioResponseRouter,
+    _speaker_opened,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -92,14 +97,23 @@ class WebRTCSession(AvioRequestMixin):
         """
         if not self.talk_supported:
             return False
+        # Ask the camera to open its speaker FIRST, and only enable the
+        # microphone once it has.  The other order left the mic live and
+        # encoding for the whole round trip, so a refused speaker had already
+        # been sent viewer audio by the time we detached it.  The verdict is
+        # cheap here - 0.01-0.38s measured on an A000088.
+        #
+        # IOTYPE_USER_IPCAM_SPEAKERSTART = 848 (AVIOCTRLDEFs.java), 8-byte
+        # channel=0 payload; the camera answers 851.
         self._talk_holder["provider"] = pcm_provider
+        if not await _speaker_opened(self, 848, 851, SPEAKER_ACK_TIMEOUT_S):
+            self._talk_holder["provider"] = None
+            return False
         try:
             self._audio_sender.replaceTrack(self._talk_track)
         except Exception:
             self._talk_holder["provider"] = None
             return False
-        # IOTYPE_USER_IPCAM_SPEAKERSTART = 848 (AVIOCTRLDEFs.java), 8-byte channel=0 payload.
-        self._avio_cmd(848, b"\x00" * 8)
         self._talk_holder["was_active"] = True  # ensure stop() releases the speaker
         return True
 

{python_aidot_cameras-0.16.0 → python_aidot_cameras-0.17.0}/pyproject.toml

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

{python_aidot_cameras-0.16.0 → python_aidot_cameras-0.17.0/python_aidot_cameras.egg-info}/PKG-INFO

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

@@ -82,8 +82,11 @@ tests/test_battery_evidence_corroboration.py
 tests/test_battery_skip_turn.py
 tests/test_ble_gateway.py
 tests/test_bridge_state_sentinels.py
+tests/test_busy_backoff.py
 tests/test_constants_imports_resolve.py
+tests/test_control_verdicts.py
 tests/test_deferred_hardening.py
+tests/test_device_cmd_seq_match.py
 tests/test_device_login_guard.py
 tests/test_device_user_info_cache.py
 tests/test_dormant_camera_cleanup.py
@@ -143,6 +146,7 @@ tests/test_sdes_fast_liveplay.py
 tests/test_sdes_ffmpeg_stderr_log.py
 tests/test_sdes_idle_release.py
 tests/test_sdes_open_cleanup.py
+tests/test_sdes_sctp_abort.py
 tests/test_sdes_serve_audio.py
 tests/test_sdes_serve_cmd.py
 tests/test_sdes_serve_stderr_drain.py

python_aidot_cameras-0.17.0/tests/test_busy_backoff.py

@@ -0,0 +1,35 @@
+"""How long to wait after a camera says it has no free session.
+
+On `-50002` both keepalive loops slept `_MAX_DELAY` - **300 seconds** - on the
+reasoning that "the camera only releases slowly". Measured 2026-08-07 on a mains
+A001064, that is wrong by more than an order of magnitude:
+
+    close, reopen after 2s  -> -50002 refused   (three times, reproducibly)
+    close, reopen after 8s  -> reopened fine    (every time)
+    close, reopen after 20s -> reopened fine
+
+The probe minted a fresh peerid on every attempt - the case the comment warned
+about - and still recovered inside 8 seconds.
+
+This matters beyond a slow reconnect. A camera that clears in seconds, paired
+with a five-minute refusal to retry, is indistinguishable from a camera that
+needs a long rest, and that appearance is most likely where the project's
+"battery cameras need 30-45 minutes between sessions" rule came from. Three
+back-to-back sessions on a battery L2 all streamed fine the same day.
+
+The wait still has to be a real wait. Retrying immediately would hammer a camera
+that genuinely has no free session, and on a battery model that risks the
+wake-then-sleep loop the original comment was guarding against. So: comfortably
+past the measured window, nowhere near five minutes.
+"""
+from aidot_cameras.camera.client import _BUSY_BACKOFF_S
+
+
+def test_the_wait_clears_the_measured_refusal_window():
+    """8s reopened cleanly every time; leave real headroom above that."""
+    assert _BUSY_BACKOFF_S >= 15.0
+
+
+def test_the_wait_is_not_a_five_minute_rest():
+    """The whole point: a camera that clears in seconds must not cost minutes."""
+    assert _BUSY_BACKOFF_S <= 60.0