python-aidot-cameras 0.7.20__tar.gz → 0.7.22__tar.gz

{python_aidot_cameras-0.7.20/src/python_aidot_cameras.egg-info → python_aidot_cameras-0.7.22}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-aidot-cameras"
-version = "0.7.20"
+version = "0.7.22"
 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.20 → python_aidot_cameras-0.7.22}/src/aidot/camera/client.py

@@ -1950,6 +1950,7 @@ class CameraMixin(_CameraControlsMixin):
         live_stream_param: Optional[bool] = None,
         serve_relay: Optional[bool] = None,
         stream_idle_s: Optional[float] = None,
+        sdes_fast_liveplay: Optional[bool] = None,
     ) -> None:
         """Start a persistent stream that keeps the camera session alive.
 
@@ -1998,6 +1999,8 @@ class CameraMixin(_CameraControlsMixin):
             self._serve_relay_opt = serve_relay
         if stream_idle_s is not None:
             self._stream_idle_opt = stream_idle_s
+        if sdes_fast_liveplay is not None:
+            self._sdes_fast_liveplay_opt = sdes_fast_liveplay
         if self._stream_task is not None and not self._stream_task.done():
             return
         self._keepalive_rtsp_url = rtsp_push_url
@@ -2528,6 +2531,18 @@ class CameraMixin(_CameraControlsMixin):
         except (TypeError, ValueError):
             return 120.0
 
+    def _resolve_sdes_fast_liveplay(self) -> bool:
+        """Whether to skip the ~2 s livePlayResp wait for SDES (P5, EXPERIMENTAL).
+
+        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
@@ -3337,6 +3352,17 @@ class CameraMixin(_CameraControlsMixin):
         if self.is_sdes_camera:
             _fast_connect = False
 
+        # P5 EXPERIMENT (opt-in): skip ONLY the livePlayResp blocking wait (~2 s)
+        # for SDES, while keeping the full ICE/TURN/SCTP handshake.  Rationale: the
+        # SDES instability that forces _fast_connect off comes from skipping the
+        # ICE/TURN waits + stripping TURN (under-arming SCTP) - NOT from skipping
+        # 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 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.
+
         # 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
         # gets the signal even with no live MQTT session; the MQTT
@@ -4123,11 +4149,25 @@ class CameraMixin(_CameraControlsMixin):
             # (parity-confirmed).  AIDOT_FAST_CONNECT skips it and proceeds to
             # SDP/ICE immediately - losing fast-fail on rejection (rare; ICE then
             # fails instead) in exchange for ~2 s off every LAN connect.
-            if not _fast_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)"
+                )
+            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:
@@ -4136,11 +4176,10 @@ class CameraMixin(_CameraControlsMixin):
                         )
                 except TimeoutError:
                     pass
-            else:
-                _status(
-                    "AIDOT_FAST_CONNECT: skipping livePlayResp wait (~2s) -"
-                    " proceeding to SDP/ICE (app-parity, no fast-fail on reject)"
-                )
+                _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
@@ -4152,11 +4191,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"
@@ -7001,24 +7047,49 @@ 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).
+        # P5 (experimental, 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).
+        _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.20 → python_aidot_cameras-0.7.22/src/python_aidot_cameras.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.7.20
+Version: 0.7.22
 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.20 → python_aidot_cameras-0.7.22}/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.22/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)