python-aidot-cameras 0.14.0__tar.gz → 0.15.0b2__tar.gz

{python_aidot_cameras-0.14.0/python_aidot_cameras.egg-info → python_aidot_cameras-0.15.0b2}/PKG-INFO

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

@@ -22,9 +22,11 @@ from ..const import (
 from .constants import (
     _LEEDARSON_APP_ID,
     _LIVE_PLAY_NOT_READY,
-    _SMARTHOME_URL_TEMPLATE,
+    _SMARTHOME_URL_TEMPLATE,  # noqa: F401 - re-exported for back-compat; reads go through smarthome_base()
     GETSTREAMCTRL_CMD,  # noqa: F401 - re-exported for back-compat (public pair; unused in-module)
     SDES_SPEAKERSTART_DELAY,  # noqa: F401 - used by the sdes_open mixin; kept re-exported
+    aidot_api_base,
+    smarthome_base,
 )
 from .constants import (  # noqa: F401 - re-exported for device_client / back-compat
     TALK_PCM_FRAME_BYTES,
@@ -1156,7 +1158,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
 
     @property
     def _smarthome_base(self) -> str:
-        return _SMARTHOME_URL_TEMPLATE.format(region=self._region)
+        return smarthome_base(self._region)
 
     def set_token_refresh_cb(self, cb: "Callable") -> None:
         """Register the AidotClient coroutine that refreshes the access token."""
@@ -1371,6 +1373,15 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
         if self._mqtt_url:
             return self._mqtt_url
 
+        # Test seam: point the whole client at a local broker without any cloud
+        # call (paho derives ws-vs-wss and the port from the scheme, so a plain
+        # "ws://127.0.0.1:PORT/mqtt" needs nothing else).  Unset in production.
+        _env_mqtt = os.environ.get("AIDOT_MQTT_URL")
+        if _env_mqtt:
+            _LOGGER.debug("AIDOT_MQTT_URL override in effect: %s", _env_mqtt)
+            self._mqtt_url = _env_mqtt
+            return self._mqtt_url
+
         import aiohttp
 
         async def _fetch():
@@ -1603,11 +1614,11 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
 
     @property
     def _aidot_v21_base(self) -> str:
-        return f"https://prod-{self._region}-api.arnoo.com/v21"
+        return f"{aidot_api_base(self._region)}/v21"
 
     @property
     def _aidot_v32_base(self) -> str:
-        return f"https://prod-{self._region}-api.arnoo.com/v32/api/ipc"
+        return f"{aidot_api_base(self._region)}/v32/api/ipc"
 
     def _aidot_headers(self) -> dict:
         # Auth headers for the AiDot platform API (prod-{region}-api.arnoo.com).
@@ -4847,7 +4858,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
             return None
 
         url = (
-            f"https://prod-{self._region}-api.arnoo.com"
+            f"{aidot_api_base(self._region)}"
             f"/v29/api/webrtc/iceConfig?forceRefresh=0"
         )
 

{python_aidot_cameras-0.14.0 → python_aidot_cameras-0.15.0b2}/aidot_cameras/camera/constants.py

@@ -4,6 +4,7 @@ Extracted verbatim from client.py (behavior-preserving). client.py
 re-imports these names, so the public/runtime surface is unchanged.
 """
 
+import os
 import struct
 
 # AppKey from LDSAppOpenSDK CocoaPods docs (kLDSAppOpenSDKKey = "appa070")
@@ -17,6 +18,57 @@ _LEEDARSON_APP_ID = "1392315867093508098"
 # e.g. "us" -> "https://us-smarthome.arnoo.com:443"
 _SMARTHOME_URL_TEMPLATE = "https://{region}-smarthome.arnoo.com:443"
 
+# AiDot platform API base (the prod-{region}-api.arnoo.com family).
+_AIDOT_API_BASE_TEMPLATE = "https://prod-{region}-api.arnoo.com"
+
+# --------------------------------------------------------------------------- #
+# Test-environment seams.
+#
+# Every cloud endpoint the camera layer contacts routes through one of these
+# helpers, so an end-to-end test can point the WHOLE client at a local fake
+# environment via env vars (the same opt-in pattern as
+# AIDOT_SDES_HOLEPUNCH_HOST).  Read at call time, never cached at import, and
+# defaulting to today's production URLs - unset means byte-identical behavior.
+#
+# These exist so the e2e tier CANNOT reach the real cloud: without them the
+# fake-lab tests fall through to prod-{region}-api.arnoo.com and the live MQTT
+# broker, which is real egress with test credentials from CI.
+
+
+def smarthome_base(region: str) -> str:
+    """Smarthome API base for ``region`` (AIDOT_SMARTHOME_URL_TEMPLATE override)."""
+    tmpl = os.environ.get("AIDOT_SMARTHOME_URL_TEMPLATE") or _SMARTHOME_URL_TEMPLATE
+    return tmpl.format(region=region)
+
+
+def aidot_api_base(region: str) -> str:
+    """Platform API base for ``region`` (AIDOT_API_BASE_TEMPLATE override)."""
+    tmpl = os.environ.get("AIDOT_API_BASE_TEMPLATE") or _AIDOT_API_BASE_TEMPLATE
+    return tmpl.format(region=region)
+
+
+def _ice_uris_from_env(var: str, default: list) -> list:
+    """Comma-separated ICE URI list from ``var``; unset -> default, "" -> []."""
+    env = os.environ.get(var)
+    if env is None:
+        return list(default)
+    return [u.strip() for u in env.split(",") if u.strip()]
+
+
+def stun_server_uris() -> list:
+    """Default STUN server URIs (AIDOT_STUN_SERVERS override; "" disables)."""
+    return _ice_uris_from_env("AIDOT_STUN_SERVERS", ["stun:stun.l.google.com:19302"])
+
+
+def fallback_turn_uris() -> list:
+    """TURN relay URIs appended when the cloud ICE config carries none
+    (AIDOT_TURN_SERVERS override; "" disables the hardcoded Arnoo fallback)."""
+    return _ice_uris_from_env(
+        "AIDOT_TURN_SERVERS",
+        ["stun:3.230.182.123:3478", "turn:3.230.182.123:5349"],
+    )
+
+
 # --------------------------------------------------------------------------- #
 # Playback TCP binary framing constants
 #

{python_aidot_cameras-0.14.0 → python_aidot_cameras-0.15.0b2}/aidot_cameras/camera/protocol.py

@@ -583,6 +583,26 @@ def _sprop_cache_path(devid: str) -> str:
     return os.path.join(_SPROP_DIR, f"{safe}.sprop")
 
 
+def _sprop_unstable_path(devid: str) -> str:
+    """Marker file: this camera does NOT keep its parameter sets stable."""
+    return _sprop_cache_path(devid) + ".unstable"
+
+
+def _sprop_is_unstable(devid: str) -> bool:
+    """True once this camera has been seen to change its parameter sets.
+
+    Injecting a cached ``sprop-parameter-sets`` is only safe while the camera
+    keeps sending the SAME sets.  An A001064 was measured changing its
+    ``seq_parameter_set_id`` between sessions (cache held id 0, the stream then
+    referenced id 3), and out-of-band parameter sets that name the wrong id are
+    far worse than none: ffmpeg initialises its decoder from them, every slice
+    then references an id the decoder does not have, and the whole session
+    decodes nothing - "sps_id 3 out of range", "non-existing PPS 0 referenced",
+    "no frame!".  A MISSING set only costs the wait for the next in-band IDR.
+    """
+    return os.path.exists(_sprop_unstable_path(devid))
+
+
 def _load_sprop(devid: str) -> "Optional[str]":
     """Cached ``sprop-parameter-sets`` for ``devid`` (captured from a prior
     stream), or None.  Fail-safe: any error -> None (SDP omits sprop = today's
@@ -596,8 +616,33 @@ def _load_sprop(devid: str) -> "Optional[str]":
 
 
 def _save_sprop(devid: str, sprop: str) -> None:
-    """Persist the ``sprop-parameter-sets`` string for ``devid`` (best-effort)."""
+    """Persist the ``sprop-parameter-sets`` string for ``devid`` (best-effort).
+
+    If a DIFFERENT value was already cached, this camera does not keep its
+    parameter sets stable: mark it and drop the cache, so nothing is injected
+    for it again (see _sprop_is_unstable).  The caller only reaches here from
+    in-band capture, so such a camera demonstrably sends its sets in-band and
+    loses nothing by the injection being skipped.
+    """
+    if _sprop_is_unstable(devid):
+        return          # already known unstable; nothing to cache for this camera
     try:
+        prev = _load_sprop(devid)
+        if prev is not None and prev != sprop:
+            _LOGGER.warning(
+                "camera %s: in-band parameter sets differ from the cached ones - "
+                "this camera changes them between sessions, so out-of-band "
+                "injection is now disabled for it (a stale set decodes nothing)",
+                devid,
+            )
+            try:
+                os.makedirs(_SPROP_DIR, exist_ok=True)
+                with open(_sprop_unstable_path(devid), "w") as fh:
+                    fh.write("parameter sets changed between sessions\n")
+                os.remove(_sprop_cache_path(devid))
+            except OSError:
+                pass
+            return
         os.makedirs(_SPROP_DIR, exist_ok=True)
         tmp = _sprop_cache_path(devid) + ".tmp"
         with open(tmp, "w") as fh:
@@ -616,6 +661,8 @@ def _inject_sprop(sdp: str, devid: str) -> str:
     in-band SPS loss).  No-op if nothing is cached yet or sprop is already
     present.  Applied at every ffmpeg-input SDP write so both the serve path and
     the snapshot/file path benefit."""
+    if _sprop_is_unstable(devid):
+        return sdp
     sprop = _load_sprop(devid)
     if not sprop or "sprop-parameter-sets=" in sdp:
         return sdp

{python_aidot_cameras-0.14.0 → python_aidot_cameras-0.15.0b2}/aidot_cameras/camera/sdes.py

@@ -34,7 +34,10 @@ class SdesSession:
         cmd_chan=None,
         talk_state=None,
         media_progress=None,
+        media_counts=None,
         teardown_requested=None,
+        first_video_pt=None,
+        first_audio_pt=None,
     ) -> None:
         self._proc       = proc
         self._sdp_path   = sdp_path
@@ -48,6 +51,14 @@ class SdesSession:
         # that stopped sending (battery teardown ~49-72s) and reconnect - ffmpeg
         # itself never exits on a dead UDP input, so wait_done() alone would hang.
         self._media_progress = media_progress if media_progress is not None else [0.0]
+        # Shared with the bridge thread: [packets, bytes] forwarded to ffmpeg.
+        # See media_stats() - the SDES path never calls on_frame, so this is the
+        # in-process signal that media is actually flowing.
+        self._media_counts = media_counts if media_counts is not None else [0, 0]
+        # Shared with the bridge thread: the payload types the camera actually
+        # sent (video 96/97/98, audio 0/8), or None before first media.
+        self._first_video_pt = first_video_pt if first_video_pt is not None else [None]
+        self._first_audio_pt = first_audio_pt if first_audio_pt is not None else [None]
         # Mutable one-element list shared with the bridge thread: [0] flips True
         # the moment ANY locally-initiated ffmpeg-kill path fires (this stop(),
         # the cold-open _reap(), the key-restart proc replace, or the DTLS-
@@ -146,6 +157,26 @@ class SdesSession:
         """time.monotonic() of the last media packet forwarded, 0.0 if none yet."""
         return self._media_progress[0]
 
+    def media_stats(self) -> dict:
+        """Snapshot of media actually forwarded to ffmpeg by the bridge.
+
+        The SDES path decodes nothing in-process (ffmpeg owns the media), so
+        ``on_frame`` is never invoked and callers cannot count frames the way
+        the DTLS path allows.  These counters are the supported substitute:
+        non-zero ``packets``/``bytes`` means real media reached the consumer.
+
+        Returns ``{packets, bytes, last_media_monotonic, video_pt, audio_pt}``;
+        the payload types are ``None`` until the camera's first packet of that
+        kind arrives.
+        """
+        return {
+            "packets": self._media_counts[0],
+            "bytes": self._media_counts[1],
+            "last_media_monotonic": self._media_progress[0],
+            "video_pt": self._first_video_pt[0],
+            "audio_pt": self._first_audio_pt[0],
+        }
+
     def _log_ffmpeg_stderr(self, stderr_bytes: bytes) -> None:
         """Log ffmpeg's captured stderr at a level that matches what happened.
 

{python_aidot_cameras-0.14.0 → python_aidot_cameras-0.15.0b2}/aidot_cameras/camera/sdes_open.py

@@ -15,7 +15,12 @@ import random
 import time
 from typing import Callable, Optional  # noqa: F401 - method annotations
 
-from .constants import _LIVE_PLAY_NOT_READY, SDES_SPEAKERSTART_DELAY
+from ..exceptions import AidotCameraBusy
+from .constants import (
+    _LIVE_PLAY_NOT_READY,
+    SDES_SPEAKERSTART_DELAY,
+    stun_server_uris,
+)
 from .models import VideoFrame  # noqa: F401 - forward-ref annotation
 from .sdes import SdesSession
 from .protocol import (
@@ -173,6 +178,52 @@ def narrow_sdp_payload_types(sdp_text: str, keep_video=None, keep_audio=None) ->
     return "".join(kept)
 
 
+async def _sdes_await_answer_or_terminal(
+    answer_fut, terminal_error_fut, timeout: float, _status=None
+):
+    """Await the camera's SDES answer, but give up at once on a terminal ack.
+
+    A terminal webrtcResp ack (-50002 max-streams / -50015 SD-cap) means the
+    camera REFUSED this stream; the whole point of classifying it as terminal
+    is that neither waiting nor retrying can help.  The SDES path used to watch
+    only ``answer_fut``, so a refusal cost the full answer budget and then a
+    pointless DTLS-fallback offer on top.
+
+    Raises ``AidotCameraBusy`` the moment the refusal lands, ``TimeoutError``
+    if neither arrives in ``timeout`` (the caller's existing no-answer path).
+    """
+    if terminal_error_fut is None:
+        return await asyncio.wait_for(answer_fut, timeout=timeout)
+
+    _waits = {answer_fut, terminal_error_fut}
+    _done, _pending = await asyncio.wait(
+        _waits, timeout=timeout, return_when=asyncio.FIRST_COMPLETED
+    )
+    if terminal_error_fut in _done:
+        code, desc = terminal_error_fut.result()
+        if _status is not None:
+            _status(f"camera refused: ack {code} {desc} - terminal, not retrying")
+        raise AidotCameraBusy(code, desc)
+    if answer_fut in _done:
+        return answer_fut.result()
+    # Timed out.  ``answer_fut`` MUST be cancelled here, exactly as the
+    # ``asyncio.wait_for(answer_fut, ...)`` this replaced did.  The MQTT handler
+    # routes a late webrtcResp to ``second_answer_fut`` only ``if
+    # answer_fut.done()`` (webrtc_open.py), and the late-ICE-credential recovery
+    # reads ``second_answer_fut``.  Leaving it pending swallows the late answer,
+    # so USE-CANDIDATE is never sent, the camera stays in ICE "Checking" and the
+    # view shows a black frame with no media - the 0.12.16 failure mode.
+    #
+    # ``terminal_error_fut`` is deliberately NOT cancelled: it is checked again
+    # after the open returns (webrtc_open.py) to surface a refusal that landed
+    # during the fallback.
+    answer_fut.cancel()
+    # Builtin TimeoutError (asyncio.TimeoutError is an alias since 3.11); this
+    # is what the caller's `except TimeoutError` no-answer path already catches,
+    # which is what triggers the DTLS fallback.
+    raise TimeoutError()
+
+
 def _sdes_echo_wait_timeout(skip_liveplay: bool) -> float:
     """Seconds to block on the camera's webrtcReq echo before proceeding.
 
@@ -328,6 +379,10 @@ class _SdesOpenMixin:
         rtsp_push_url: Optional[str] = None,
         talk: bool = False,
         ice_cands_seen=None,
+        # So the SDES answer-wait can abandon at once when the camera says
+        # -50002/-50015 instead of waiting out its budget and then paying for a
+        # DTLS-fallback offer that cannot succeed.
+        terminal_error_fut=None,
     ) -> "SdesSession":
         """SDES-SRTP streaming path using a hand-crafted SDP offer and ffmpeg.
 
@@ -341,6 +396,27 @@ class _SdesOpenMixin:
         import base64
         import subprocess
 
+        # Stop the MQTT signaling thread on ANY abnormal exit from this impl.
+        # The explicit `outgoing_q.put_nowait(None)` calls further down cover the
+        # paths that existed when they were written, but an exception raised
+        # before one of them is reached (AidotCameraBusy on a terminal ack, or a
+        # CancelledError mid-handshake) skipped the sentinel entirely and left
+        # `_mqtt_session_sync` running in an executor thread for its full 3600s.
+        # Those orphans all reconnect with the same stable account clientId, so
+        # they take the session away from later opens and signaling for other
+        # cameras on the account stops being delivered until HA restarts.
+        # The wrapper only closes this stack when the impl did NOT return a
+        # session, so a live session is unaffected.  A duplicate sentinel on the
+        # paths that already send one is harmless - the reader exits on the first.
+        if outgoing_q is not None:
+            def _stop_mqtt_thread() -> None:
+                try:
+                    outgoing_q.put_nowait(None)
+                except Exception:
+                    _LOGGER.debug("camera %s: could not signal MQTT thread to exit",
+                                  getattr(self, "device_id", "?"), exc_info=True)
+            _cleanup.callback(_stop_mqtt_thread)
+
         # SDES path: fast_connect's wait-skips / TURN-strip destabilise the SCTP
         # handshake (session churns ~every 60-90s -> live view drops to snapshot),
         # so the SDES path always uses the full, stable handshake.
@@ -1052,7 +1128,12 @@ class _SdesOpenMixin:
         # agent can gather its own srflx candidate.  Append any TURN entries from
         # ice_config so the camera can allocate a relay and probe our srflx/host
         # candidates when direct connectivity fails (e.g. symmetric NAT).
-        _sdes_ice_server_list = [{"Uris": ["stun:stun.l.google.com:19302"]}]
+        # Advertise an ICE server to the camera only when we actually have a
+        # URI for it.  With AIDOT_STUN_SERVERS="" this used to put
+        # {"Uris": []} into webrtcReq - an entry the camera must parse and
+        # that names no server.
+        _sdes_stun_uris = stun_server_uris()
+        _sdes_ice_server_list = [{"Uris": _sdes_stun_uris}] if _sdes_stun_uris else []
         _sdes_ice_server_list.extend(_sdes_turn_entries)
         # _psk_value_req was generated before the SDP offer (see above).
         # Reused here in webrtcReq and webrtcResp for consistency.
@@ -1893,20 +1974,42 @@ class _SdesOpenMixin:
         # sends SRTP no matter how long the first-media wait runs.
         # shield() so a timeout here cannot cancel the future the real answer
         # await (and the DTLS-fallback path) still consume further down.
+        # A TERMINAL refusal races the harvest.  A camera at its viewer cap acks
+        # -50002/-50015 about a second after webrtcReq and then, by definition,
+        # never answers - so without this the refusal sat unread for the whole
+        # _PRE_LAUNCH_ANSWER_WAIT_S before the later checks could see it, and we
+        # launched a bridge for a stream the camera had already declined.
         if not answer_fut.done():
             _ans_wait_t0 = time.monotonic()
             try:
-                await asyncio.wait_for(
-                    asyncio.shield(answer_fut), timeout=_PRE_LAUNCH_ANSWER_WAIT_S
-                )
-                _status("webrtcResp answer harvested after %.2fs"
-                        % (time.monotonic() - _ans_wait_t0))
-            except TimeoutError:   # asyncio.TimeoutError is an alias since 3.11
-                _status(
-                    "no webrtcResp answer within %.0fs - proceeding without ICE"
-                    " credentials (nomination will retry during the first-media"
-                    " wait)" % _PRE_LAUNCH_ANSWER_WAIT_S
+                _harvest_waits = [asyncio.shield(answer_fut)]
+                if terminal_error_fut is not None:
+                    _harvest_waits.append(asyncio.shield(terminal_error_fut))
+                _h_done, _h_pending = await asyncio.wait(
+                    _harvest_waits,
+                    timeout=_PRE_LAUNCH_ANSWER_WAIT_S,
+                    return_when=asyncio.FIRST_COMPLETED,
                 )
+                # Cancel the shield WRAPPERS only; the futures they guard are
+                # owned by the MQTT handler and are still consumed below.
+                for _h in _h_pending:
+                    _h.cancel()
+                if terminal_error_fut is not None and terminal_error_fut.done():
+                    _code, _desc = terminal_error_fut.result()
+                    _status(f"camera refused: ack {_code} {_desc}"
+                            " - terminal, not launching the bridge")
+                    raise AidotCameraBusy(_code, _desc)
+                if answer_fut.done():
+                    _status("webrtcResp answer harvested after %.2fs"
+                            % (time.monotonic() - _ans_wait_t0))
+                else:
+                    _status(
+                        "no webrtcResp answer within %.0fs - proceeding without ICE"
+                        " credentials (nomination will retry during the first-media"
+                        " wait)" % _PRE_LAUNCH_ANSWER_WAIT_S
+                    )
+            except AidotCameraBusy:
+                raise
             except Exception:
                 _LOGGER.debug("camera %s: swallowed exception awaiting answer",
                               getattr(self, "device_id", "?"), exc_info=True)
@@ -2613,6 +2716,11 @@ class _SdesOpenMixin:
         # media packet; the keepalive watchdog reads it via SdesSession to
         # restart a session the camera silently stopped feeding.
         _media_progress: list = [0.0]
+        # Shared with the bridge thread: [packets, bytes] actually forwarded to
+        # ffmpeg.  The SDES path decodes nothing in-process, so on_frame never
+        # fires and these counters are the only in-process proof media flowed -
+        # see SdesSession.media_stats(), which the live-validation gate reads.
+        _media_counts: list = [0, 0]
 
         def _bridge_fn():
             nonlocal _br_first_di_logged, _br_first_srtp_logged, _br_first_req_dumped
@@ -3681,6 +3789,18 @@ class _SdesOpenMixin:
                                                 _rtp_hdr + _pd_plain,
                                                 ('127.0.0.1', _lo_audio_port),
                                             )
+                                            # Count it: media_stats() documents
+                                            # itself as "media actually forwarded
+                                            # to ffmpeg by the bridge", and
+                                            # scripts/live_validate.py uses it as
+                                            # the SDES release gate.  This is a
+                                            # real forward, so omitting it made a
+                                            # camera whose audio arrives on the
+                                            # TUTK path under-report - far enough
+                                            # to fail an otherwise healthy release.
+                                            _media_progress[0] = _time_br.monotonic()
+                                            _media_counts[0] += 1
+                                            _media_counts[1] += len(_rtp_hdr) + len(_pd_plain)
                                             if not _br_first_audio_logged:
                                                 _br_first_audio_logged = True
                                                 # Record the payload type this path
@@ -3921,6 +4041,8 @@ class _SdesOpenMixin:
                                     _fwd_pkt, ('127.0.0.1', _btgt)
                                 )
                                 _media_progress[0] = _time_br.monotonic()
+                                _media_counts[0] += 1
+                                _media_counts[1] += len(_fwd_pkt)
                             except Exception:
                                 _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_bridge_fn', exc_info=True)
                     # Periodic ICE controlling check: re-send USE-CANDIDATE every 2.5 s.
@@ -4188,9 +4310,19 @@ class _SdesOpenMixin:
         _early_nominated = bool(_cam_ice_ufrag and _cam_ice_pwd and _cam_ice_cands)
         _media_deadline = time.monotonic() + _FIRST_MEDIA_WAIT_S
         while _first_video_pt[0] is None and time.monotonic() < _media_deadline:
-            if not _early_nominated and answer_fut is not None and answer_fut.done():
+            if terminal_error_fut is not None and terminal_error_fut.done():
+                _code, _desc = terminal_error_fut.result()
+                _status(f"camera refused: ack {_code} {_desc}"
+                        " - terminal, abandoning the first-media wait")
+                raise AidotCameraBusy(_code, _desc)
+            if (not _early_nominated and answer_fut is not None
+                    and answer_fut.done() and not answer_fut.cancelled()):
                 # Read-only peek: the real await below still consumes this
                 # future and drives the answer/fallback paths unchanged.
+                # ``cancelled()`` is checked explicitly because the answer-wait
+                # cancels this future on timeout, and ``.exception()`` on a
+                # cancelled future raises CancelledError - a BaseException that
+                # the ``except Exception`` below would NOT catch.
                 _peek_sdp = ""
                 try:
                     if answer_fut.exception() is None:
@@ -4214,7 +4346,8 @@ class _SdesOpenMixin:
         # Which single payload type (if any) each line can be narrowed to. Audio
         # is usable only when its type was actually observed; otherwise the "0 8"
         # line cannot be narrowed.
-        if _vpt not in _SDP_VIDEO_PTS and answer_fut is not None and answer_fut.done():
+        if (_vpt not in _SDP_VIDEO_PTS and answer_fut is not None
+                and answer_fut.done() and not answer_fut.cancelled()):
             # No video packet arrived inside the window, but the camera's answer
             # still names the codec it agreed to send. Narrowing on that beats
             # leaving both codecs advertised: an unnarrowed video line makes
@@ -4404,7 +4537,16 @@ class _SdesOpenMixin:
             else min(timeout, 8.0 if dtls_fallback_ok else 20.0)
         )
         try:
-            answer = await asyncio.wait_for(answer_fut, timeout=_sdes_answer_timeout)
+            # Race the answer against a TERMINAL refusal (-50002 max-streams /
+            # -50015 SD-cap).  Without this the SDES path is blind to a camera
+            # that explicitly said no: it waited out its whole answer budget and
+            # then handed a "no answer" to the DTLS fallback, which sent a second
+            # offer and only THEN surfaced AidotCameraBusy.  Measured ~48s to
+            # report a refusal that arrived in about one second - and two of the
+            # three validated models (A001513, A001064) take this path.
+            answer = await _sdes_await_answer_or_terminal(
+                answer_fut, terminal_error_fut, _sdes_answer_timeout, _status,
+            )
             _ans_sdp = answer.get("sdp", "")
             _ans_mlines = [ln for ln in _ans_sdp.splitlines() if ln.startswith("m=")]
             _status(
@@ -4709,5 +4851,8 @@ class _SdesOpenMixin:
             cmd_chan=_cmd_chan,
             talk_state=_talk_state,
             media_progress=_media_progress,
+            media_counts=_media_counts,
             teardown_requested=_teardown_holder,
+            first_video_pt=_first_video_pt,
+            first_audio_pt=_first_audio_pt,
         )

{python_aidot_cameras-0.14.0 → python_aidot_cameras-0.15.0b2}/aidot_cameras/camera/webrtc_open.py

@@ -17,7 +17,7 @@ import logging
 from typing import Callable, Optional
 
 from ..exceptions import AidotCameraBusy, AidotCameraNotReady
-from .constants import _LIVE_PLAY_NOT_READY
+from .constants import _LIVE_PLAY_NOT_READY, fallback_turn_uris, stun_server_uris
 from .models import VideoFrame
 from .webrtc import WebRTCSession
 from .protocol import (
@@ -705,6 +705,26 @@ class _WebRTCOpenMixin:
                 # AidotCameraBusy instead of timing out into a generic retry.
                 _term = _terminal_webrtc_ack(msg)
                 if _term is not None:
+                    # Isolate per camera/stream BEFORE accepting the refusal.  We
+                    # subscribe to the account-wide topic (iot/v1/c/{user_id}/#),
+                    # so without this a -50002 for a DIFFERENT camera aborts this
+                    # camera's healthy open with AidotCameraBusy.  That matters
+                    # now that the SDES path polls terminal_error_fut across the
+                    # whole first-media wait rather than reading it once.
+                    # Same accept rule the answer branch below uses: an exact
+                    # peerid match, or BOTH devId and dstAddr (dstAddr alone is
+                    # the shared account id and matches every camera).
+                    _t_pid = inner.get("peerid")
+                    if not (_t_pid == peer_id
+                            or (inner.get("devId") == device_id
+                                and inner.get("dstAddr") == user_id)):
+                        loop.call_soon_threadsafe(
+                            lambda rp=_t_pid, c=_term[0]: _status(
+                                f"terminal ack {c} IGNORED - belongs to another"
+                                f" camera/stream: peerid {rp!r}"
+                            )
+                        )
+                        return
                     if not terminal_error_fut.done():
                         loop.call_soon_threadsafe(terminal_error_fut.set_result, _term)
                     return
@@ -1302,6 +1322,7 @@ class _WebRTCOpenMixin:
                     rtsp_push_url=rtsp_push_url,
                     talk=talk,
                     ice_cands_seen=ice_cands_seen,
+                    terminal_error_fut=terminal_error_fut,
                 )
                 # Success: the SdesSession now owns outgoing_q + mqtt_fut and
                 # reaps them on stop(); clear the backstop slot so a concurrent
@@ -1372,7 +1393,11 @@ class _WebRTCOpenMixin:
                 result.append(u)
             return result
 
-        _ice_servers = [RTCIceServer(urls=["stun:stun.l.google.com:19302"])]
+        # Omit the entry entirely when the URI list is empty (STUN disabled
+        # via AIDOT_STUN_SERVERS=""): RTCIceServer(urls=[]) is not the same as
+        # "no server" - it is an ICE server that advertises nothing.
+        _stun_uris = stun_server_uris()
+        _ice_servers = [RTCIceServer(urls=_stun_uris)] if _stun_uris else []
         if ice_config_fut.done():
             try:
                 _ice_data = ice_config_fut.result()
@@ -1478,10 +1503,10 @@ class _WebRTCOpenMixin:
         # that are on a different network segment or behind strict NAT.  The Arnoo
         # TURN server (confirmed from browser webrtc_internals - ALL candidates are
         # relay type) accepts connections without explicit per-session credentials.
-        _arnoo_stun = "stun:3.230.182.123:3478"
-        _arnoo_turn = "turn:3.230.182.123:5349"
-        if not _has_turn_in_resp:
-            _ice_servers.append(RTCIceServer(urls=[_arnoo_stun, _arnoo_turn]))
+        # AIDOT_TURN_SERVERS overrides the hardcoded pair (empty disables it).
+        _arnoo_fallback = fallback_turn_uris()
+        if not _has_turn_in_resp and _arnoo_fallback:
+            _ice_servers.append(RTCIceServer(urls=_arnoo_fallback))
         # Log the final ICE server configuration.
         _stun_url = (_ice_servers[0].urls[0]
                      if _ice_servers and _ice_servers[0].urls
@@ -1512,9 +1537,10 @@ class _WebRTCOpenMixin:
                         RTCIceServer(urls=_su, username=_srv.username,
                                      credential=_srv.credential)
                     )
-            _ice_servers = _stun_only or [
-                RTCIceServer(urls=["stun:stun.l.google.com:19302"])
-            ]
+            _fallback_stun = stun_server_uris()
+            _ice_servers = _stun_only or (
+                [RTCIceServer(urls=_fallback_stun)] if _fallback_stun else []
+            )
             _status(
                 "AIDOT_FAST_CONNECT: stripped TURN (STUN-only, LAN-direct) -"
                 f" {len(_ice_servers)} ICE server(s), no relay gather stall"

{python_aidot_cameras-0.14.0 → python_aidot_cameras-0.15.0b2}/aidot_cameras/client.py

@@ -635,9 +635,13 @@ class CameraClient(_UpstreamAidotClient):
             _LOGGER.warning("_async_fetch_user_config: no HTTP session")
             return
 
+        # Imported here, not at module scope: aidot_cameras.camera.__init__
+        # re-exports camera.client, which imports back through device_client -
+        # a top-level import would close that cycle during package init.
+        from .camera.constants import aidot_api_base
+
         region = account_region(self)
-        base = f"https://prod-{region}-api.arnoo.com"
-        url = f"{base}/commons/userConfig"
+        url = f"{aidot_api_base(region)}/commons/userConfig"
         headers = {
             "appid": _CLOUD_APP_ID,
             "owner": user_id,

{python_aidot_cameras-0.14.0 → python_aidot_cameras-0.15.0b2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-aidot-cameras"
-version = "0.14.0"
+version = "0.15.0b2"
 description = "Control AiDot/Leedarson WiFi lights and cameras (WebRTC streaming, two-way audio, PTZ, controls)"
 readme = "README.md"
 license = "MIT"
@@ -84,6 +84,21 @@ include = ["aidot_cameras*"]
 [tool.setuptools.package-data]
 aidot_cameras = ["py.typed"]
 
+[tool.pytest.ini_options]
+# Test tiers. A bare `pytest tests/` must never touch hardware: the `live`
+# marker (real cameras on the LAN, release gate only) is deselected by
+# default and has to be requested explicitly with `-m live`.
+markers = [
+    "e2e: fake-lab end-to-end tests (fake cloud / MQTT broker / camera / go2rtc)",
+    "live: requires real cameras on the LAN; release-gate tier, never selected by default",
+    "mux: exercises the real ffmpeg/libavformat mux path",
+]
+addopts = "-m 'not live'"
+# The e2e tier uses async fixtures (fake broker / cloud servers); auto mode
+# keeps them working without decorating every test.
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+
 [tool.coverage.run]
 # Vendored third-party code (aiortc) is exercised via streaming, not our tests;
 # keep it out of the coverage report so the numbers reflect our own code.