python-aidot-cameras 0.7.21__tar.gz → 0.7.23__tar.gz

{python_aidot_cameras-0.7.21/src/python_aidot_cameras.egg-info → python_aidot_cameras-0.7.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.7.21
+Version: 0.7.23
 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.7.21 → python_aidot_cameras-0.7.23}/pyproject.toml

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

{python_aidot_cameras-0.7.21 → python_aidot_cameras-0.7.23}/src/aidot/camera/client.py

@@ -2531,6 +2531,19 @@ class CameraMixin(_CameraControlsMixin):
         except (TypeError, ValueError):
             return 120.0
 
+    def _resolve_sdes_fast_liveplay(self) -> bool:
+        """Whether to use SDES fast-liveplay (shorten the always-timing-out
+        echo/livePlayResp signaling) - validated in soak, opt-in, default off.
+
+        Per-camera ``sdes_fast_liveplay`` (set via start_keepalive) wins; else the
+        ``AIDOT_SDES_FAST_LIVEPLAY`` env (truthy = 1/true/yes/on), default off.
+        Only consulted for SDES cameras (the caller gates on is_sdes_camera)."""
+        opt = getattr(self, "_sdes_fast_liveplay_opt", None)
+        if opt is not None:
+            return bool(opt)
+        return os.environ.get("AIDOT_SDES_FAST_LIVEPLAY", "").strip().lower() in (
+            "1", "true", "yes", "on")
+
     def _maybe_start_serve_relay(self, serve_url: Optional[str]) -> "Optional[_ServeRelay]":
         """Hold the public serve port via a _ServeRelay so an eager go2rtc pull
         connects-and-waits instead of hitting ECONNREFUSED during the ~16-25s
@@ -3347,16 +3360,9 @@ class CameraMixin(_CameraControlsMixin):
         # the livePlayResp ack, which is purely a camera accept/reject we don't
         # need to block on (the official app never waits for it).  So this targeted
         # skip is expected to be SCTP-safe and shave ~2 s off the SDES cold start.
-        # Off by default, pending live A/B validation.  start_keepalive(
+        # Off by default, pending live validation.  Applied in _open_sdes_stream
+        # (the SDES path has its own livePlayResp wait); start_keepalive(
         # sdes_fast_liveplay=...) wins, else AIDOT_SDES_FAST_LIVEPLAY env.
-        _sdes_skip_lp = False
-        if self.is_sdes_camera:
-            _sl = getattr(self, "_sdes_fast_liveplay_opt", None)
-            if _sl is None:
-                _sl = os.environ.get(
-                    "AIDOT_SDES_FAST_LIVEPLAY", "").strip().lower() in (
-                    "1", "true", "yes", "on")
-            _sdes_skip_lp = bool(_sl)
 
         # Wake battery cameras via the cloud HTTP low-power endpoint before the
         # handshake (matches the app, which fires the HTTP wake so a sleeping camera
@@ -4145,20 +4151,24 @@ class CameraMixin(_CameraControlsMixin):
             # SDP/ICE immediately - losing fast-fail on rejection (rare; ICE then
             # fails instead) in exchange for ~2 s off every LAN connect.
             if _fast_connect:
+                _LOGGER.info(
+                    "signaling-wait[%s] livePlayResp skipped (fast_connect)",
+                    self.device_id)
                 _status(
                     "AIDOT_FAST_CONNECT: skipping livePlayResp wait (~2s) -"
                     " proceeding to SDP/ICE (app-parity, no fast-fail on reject)"
                 )
-            elif _sdes_skip_lp:
-                _status(
-                    "AIDOT_SDES_FAST_LIVEPLAY: skipping livePlayResp wait (~2s)"
-                    " for SDES - full ICE/TURN/SCTP handshake retained (experiment)"
-                )
             else:
+                # Instrumented: how long this wait actually costs (it returns as
+                # soon as livePlayResp arrives; the 2s is only paid on timeout).
+                # This is exactly the cost the sdes_fast_liveplay experiment skips.
+                _lp_t0 = time.monotonic()
+                _lp_arrived = False
                 try:
                     _lp_resp = await asyncio.wait_for(
                         asyncio.shield(liveplay_resp_fut), timeout=2.0
                     )
+                    _lp_arrived = True
                     _lp_code = int(_lp_resp.get("code", 200))
                     _lp_on = int(_lp_resp.get("livePlay", 1))
                     if _lp_code not in (0, 200) or _lp_on == 0:
@@ -4167,6 +4177,10 @@ class CameraMixin(_CameraControlsMixin):
                         )
                 except TimeoutError:
                     pass
+                _LOGGER.info(
+                    "signaling-wait[%s] livePlayResp elapsed=%dms arrived=%s",
+                    self.device_id,
+                    int((time.monotonic() - _lp_t0) * 1000), _lp_arrived)
             # Short extra wait for getIceConfigResp - the server may only respond
             # once a live camera session is active (i.e. after livePlayReq).
             # Waiting here ensures TURN credentials arrive before RTCPeerConnection
@@ -4178,11 +4192,18 @@ class CameraMixin(_CameraControlsMixin):
             # per-session TURN relay credentials, which LAN-direct doesn't need;
             # remote/strict-NAT cameras do, hence this is opt-in (see flag above).
             if not ice_config_fut.done() and not _fast_connect:
+                _ic_t0 = time.monotonic()
+                _ic_arrived = False
                 try:
                     await asyncio.wait_for(asyncio.shield(ice_config_fut), timeout=3.0)
+                    _ic_arrived = True
                     _status("getIceConfigResp received (post-livePlayReq)")
                 except TimeoutError:
                     pass  # proceed without TURN; synthetic candidates are fallback
+                _LOGGER.info(
+                    "signaling-wait[%s] getIceConfigResp elapsed=%dms arrived=%s",
+                    self.device_id,
+                    int((time.monotonic() - _ic_t0) * 1000), _ic_arrived)
             elif _fast_connect:
                 _status(
                     "AIDOT_FAST_CONNECT: skipping getIceConfigResp wait"
@@ -7027,24 +7048,52 @@ class CameraMixin(_CameraControlsMixin):
         # webrtcReq.  The echo confirms the MQTT pipeline to this device is live
         # and the broker session is registered.  Fall through after 5 s if it
         # never arrives (same safety as the old fixed 0.5 s sleep, but adaptive).
+        # SDES fast-liveplay (opt-in via sdes_fast_liveplay): instrumentation showed
+        # the echo and livePlayResp waits BOTH always time out for the SDES cameras
+        # measured (echo/resp never arrive) yet streaming succeeds - i.e. ~6 s of
+        # dead padding.  When the flag is on, cap the echo wait short and skip the
+        # livePlayResp wait; the full ICE/TURN/SCTP handshake is untouched.  This
+        # is the SDES path's OWN livePlay waits (the DTLS gate above never runs for
+        # SDES: use_sdes is True there).  VALIDATED in a 3 h live soak (15 SDES
+        # opens across battery cameras, flag engaged on all, 0 churn / 0 fail,
+        # ~4.5 s signaling saved); kept off by default pending broader multi-day
+        # use (per-open + near-term stability proven, long-haul not yet).
+        _skip_lp = self._resolve_sdes_fast_liveplay()
+        _echo_timeout = 1.5 if _skip_lp else 5.0
+        _echo_t0 = time.monotonic()
         try:
-            await _asyncio.wait_for(liveplay_echo_ev.wait(), timeout=5.0)
+            await _asyncio.wait_for(liveplay_echo_ev.wait(), timeout=_echo_timeout)
             _status("livePlayReq echo received - sending webrtcReq, ICE, then launching ffmpeg")
         except TimeoutError:
-            _status("no livePlayReq echo in 5s - sending webrtcReq, ICE, then launching ffmpeg anyway")
-        # If camera provided explicit livePlayResp failure, abort before SDP/ICE.
-        try:
-            _lp_resp_sdes = await _asyncio.wait_for(
-                _asyncio.shield(liveplay_resp_fut), timeout=1.0
-            )
-            _lp_code_sdes = int(_lp_resp_sdes.get("code", 200))
-            _lp_on_sdes = int(_lp_resp_sdes.get("livePlay", 1))
-            if _lp_code_sdes not in (0, 200) or _lp_on_sdes == 0:
-                raise RuntimeError(
-                    f"livePlay rejected by camera (code={_lp_code_sdes}, livePlay={_lp_on_sdes})"
+            _status(f"no livePlayReq echo in {_echo_timeout:.1f}s - sending webrtcReq,"
+                    " ICE, then launching ffmpeg anyway")
+        _LOGGER.info(
+            "signaling-wait[%s] livePlayReq-echo elapsed=%dms (timeout=%.1fs)",
+            self.device_id, int((time.monotonic() - _echo_t0) * 1000), _echo_timeout)
+        # livePlayResp: explicit camera accept/reject before SDP/ICE.
+        if _skip_lp:
+            _LOGGER.info(
+                "signaling-wait[%s] livePlayResp skipped (sdes_fast_liveplay)",
+                self.device_id)
+        else:
+            _lp_t0 = time.monotonic()
+            _lp_arrived = False
+            try:
+                _lp_resp_sdes = await _asyncio.wait_for(
+                    _asyncio.shield(liveplay_resp_fut), timeout=1.0
                 )
-        except TimeoutError:
-            pass
+                _lp_arrived = True
+                _lp_code_sdes = int(_lp_resp_sdes.get("code", 200))
+                _lp_on_sdes = int(_lp_resp_sdes.get("livePlay", 1))
+                if _lp_code_sdes not in (0, 200) or _lp_on_sdes == 0:
+                    raise RuntimeError(
+                        f"livePlay rejected by camera (code={_lp_code_sdes}, livePlay={_lp_on_sdes})"
+                    )
+            except TimeoutError:
+                pass
+            _LOGGER.info(
+                "signaling-wait[%s] livePlayResp elapsed=%dms arrived=%s",
+                self.device_id, int((time.monotonic() - _lp_t0) * 1000), _lp_arrived)
 
         # --- Build local-receiver SDP for ffmpeg ----------------------------- #
         # Built BEFORE sending webrtcReq so ffmpeg is already listening on the

{python_aidot_cameras-0.7.21 → python_aidot_cameras-0.7.23/src/python_aidot_cameras.egg-info}/PKG-INFO

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

@@ -43,6 +43,7 @@ tests/test_live_stream_param.py
 tests/test_motion_poll.py
 tests/test_no_undefined_names.py
 tests/test_post_merge_hardening.py
+tests/test_sdes_fast_liveplay.py
 tests/test_sdes_idle_release.py
 tests/test_sdes_sprop.py
 tests/test_sdes_talk.py

python_aidot_cameras-0.7.23/tests/test_sdes_fast_liveplay.py

@@ -0,0 +1,70 @@
+"""Unit tests for _resolve_sdes_fast_liveplay - the P5 flag (EXPERIMENTAL).
+
+P5 skips only the ~2s livePlayResp wait for SDES cameras. This locks the
+opt/env precedence (per-camera kwarg wins over AIDOT_SDES_FAST_LIVEPLAY env,
+default off) so the wiring is verifiable without a camera. The actual stability
+effect is validated by real-world soak (see scripts/sdes_soak_monitor.py), not
+here.
+"""
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "src"))
+
+import aidot.camera.client as cc
+
+_CAM = next(v for v in vars(cc).values()
+            if isinstance(v, type) and "_resolve_sdes_fast_liveplay" in v.__dict__)
+
+
+def _cam():
+    return _CAM.__new__(_CAM)
+
+
+def test_default_off(monkeypatch):
+    monkeypatch.delenv("AIDOT_SDES_FAST_LIVEPLAY", raising=False)
+    assert _cam()._resolve_sdes_fast_liveplay() is False
+
+
+def test_env_truthy_values(monkeypatch):
+    for val in ("1", "true", "TRUE", "yes", "on", " On "):
+        monkeypatch.setenv("AIDOT_SDES_FAST_LIVEPLAY", val)
+        assert _cam()._resolve_sdes_fast_liveplay() is True, val
+
+
+def test_env_falsey_values(monkeypatch):
+    for val in ("0", "false", "no", "off", ""):
+        monkeypatch.setenv("AIDOT_SDES_FAST_LIVEPLAY", val)
+        assert _cam()._resolve_sdes_fast_liveplay() is False, val
+
+
+def test_kwarg_option_wins_over_env(monkeypatch):
+    monkeypatch.setenv("AIDOT_SDES_FAST_LIVEPLAY", "1")
+    cam = _cam()
+    cam._sdes_fast_liveplay_opt = False  # start_keepalive(sdes_fast_liveplay=False)
+    assert cam._resolve_sdes_fast_liveplay() is False
+
+    cam2 = _cam()
+    monkeypatch.delenv("AIDOT_SDES_FAST_LIVEPLAY", raising=False)
+    cam2._sdes_fast_liveplay_opt = True
+    assert cam2._resolve_sdes_fast_liveplay() is True
+
+
+if __name__ == "__main__":
+    import traceback
+
+    class _MP:
+        def setenv(self, k, v): os.environ[k] = v
+        def delenv(self, k, raising=False): os.environ.pop(k, None)
+
+    _fail = 0
+    for _k, _v in sorted(globals().items()):
+        if _k.startswith("test_"):
+            try:
+                _v(_MP()) if _v.__code__.co_argcount else _v()
+                print(f"PASS {_k}")
+            except Exception:
+                _fail += 1
+                print(f"FAIL {_k}")
+                traceback.print_exc()
+    raise SystemExit(1 if _fail else 0)