python-aidot-cameras 0.5.4__tar.gz → 0.5.6__tar.gz

{python_aidot_cameras-0.5.4/src/python_aidot_cameras.egg-info → python_aidot_cameras-0.5.6}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-aidot-cameras"
-version = "0.5.4"
+version = "0.5.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.5.4 → python_aidot_cameras-0.5.6}/src/aidot/device_client.py

@@ -4042,7 +4042,11 @@ class DeviceClient(object):
             except asyncio.CancelledError:
                 return
 
-    async def start_keepalive(self, rtsp_push_url: Optional[str] = None) -> None:
+    async def start_keepalive(
+        self,
+        rtsp_push_url: Optional[str] = None,
+        fast_connect: Optional[bool] = None,
+    ) -> None:
         """Start a persistent stream that keeps the camera session alive.
 
         For SDES cameras (A001064/A001513): opens an indefinite ffmpeg stream and
@@ -4054,8 +4058,15 @@ class DeviceClient(object):
         pulls (real play/pause video, no decode/re-encode). Without a serve URL
         it falls back to the on_frame keepalive loop (latest_jpeg / MJPEG).
 
+        ``fast_connect`` enables LAN-direct mode (skip the ~2.5s livePlay/ICE-config
+        waits + TURN relay; see _async_open_webrtc_stream_impl).  ``None`` leaves it
+        to the ``AIDOT_FAST_CONNECT`` env var; ``True``/``False`` override it (e.g.
+        from a Home Assistant config-entry option, since HA OS can't set env vars).
+
         Safe to call multiple times - does nothing if already running.
         """
+        if fast_connect is not None:
+            self._fast_connect_opt = fast_connect
         if self._stream_task is not None and not self._stream_task.done():
             return
         self._keepalive_rtsp_url = rtsp_push_url
@@ -5154,6 +5165,24 @@ class DeviceClient(object):
 
         use_sdes = force_sdes if force_sdes is not None else self.is_sdes_camera
 
+        # AIDOT_FAST_CONNECT (default off): LAN-direct mode.  Both transports stall
+        # the offer on a TURN relay allocation to the cloud TURN server before ICE
+        # can even start — for DTLS, aiortc's setLocalDescription blocks until ICE
+        # gathering (incl. TURN Allocate) completes; for SDES we synchronously
+        # pre-allocate relay before building the offer.  On a LAN the camera's host
+        # candidate wins anyway, so this is pure cold-start latency (~2-3 s).  When
+        # set, we skip relay allocation so the offer goes out immediately and the
+        # LAN host candidate connects in ~1 s.  TRADE-OFF: no relay means cameras
+        # on a different network segment / behind strict NAT cannot connect, so
+        # this is opt-in and off by default.
+        # Prefer an explicit per-camera setting (e.g. HA config-entry option via
+        # start_keepalive(fast_connect=...)); fall back to the env var otherwise.
+        _fast_connect = getattr(self, "_fast_connect_opt", None)
+        if _fast_connect is None:
+            _fast_connect = os.environ.get("AIDOT_FAST_CONNECT", "").strip().lower() in (
+                "1", "true", "yes", "on",
+            )
+
         # 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
@@ -5924,36 +5953,61 @@ class DeviceClient(object):
             _status(f"livePlayReq sent  peerid={peer_id}")
             # Wait for the broker to echo livePlayReq back (confirms delivery).
             # Proceed as soon as the echo arrives; fall through after 0.5 s.
-            try:
-                await asyncio.wait_for(liveplay_echo_ev.wait(), timeout=0.5)
-            except asyncio.TimeoutError:
-                pass
+            # AIDOT_FAST_CONNECT skips this too (the echo often just times out,
+            # costing a flat 0.5 s); we proceed straight to SDP/ICE.
+            if not _fast_connect:
+                try:
+                    await asyncio.wait_for(liveplay_echo_ev.wait(), timeout=0.5)
+                except asyncio.TimeoutError:
+                    pass
             # livePlayResp carries camera-side accept/reject.  If the camera
             # rejects start-play, continuing to SDP/ICE causes large STUN churn
             # but no media.  Fail fast with the concrete code.
-            try:
-                _lp_resp = await asyncio.wait_for(
-                    asyncio.shield(liveplay_resp_fut), timeout=2.0
-                )
-                _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:
-                    raise RuntimeError(
-                        f"livePlay rejected by camera (code={_lp_code}, livePlay={_lp_on})"
+            # MEASURED (2026-06-07, live A/B): this up-to-2 s wait is the DOMINANT
+            # cold-start cost (camera-awake → ICE-servers ≈ 2.5 s = 0.5 s echo +
+            # 2.0 s here).  The official app does NOT wait for/parse livePlayResp
+            # (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:
+                try:
+                    _lp_resp = await asyncio.wait_for(
+                        asyncio.shield(liveplay_resp_fut), timeout=2.0
                     )
-            except asyncio.TimeoutError:
-                pass
+                    _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:
+                        raise RuntimeError(
+                            f"livePlay rejected by camera (code={_lp_code}, livePlay={_lp_on})"
+                        )
+                except asyncio.TimeoutError:
+                    pass
+            else:
+                _status(
+                    "AIDOT_FAST_CONNECT: skipping livePlayResp wait (~2s) -"
+                    " proceeding to SDP/ICE (app-parity, no fast-fail on reject)"
+                )
             # 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
-            # is created.  The 3-second window is long enough for typical Arnoo
-            # broker round-trips without adding noticeable latency to fast paths.
-            if not ice_config_fut.done():
+            # is created.  MEASURED (2026-06-07, live): this wait is the DOMINANT
+            # cold-start cost — ~2.5 s for getIceConfigResp to arrive after camera
+            # wake (NOT the TURN gather, which is ~70 ms).  AIDOT_FAST_CONNECT
+            # skips it: we proceed immediately on STUN/host candidates (no relay),
+            # so a LAN camera connects in ~1 s.  getIceConfigResp only supplies the
+            # 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:
                 try:
                     await asyncio.wait_for(asyncio.shield(ice_config_fut), timeout=3.0)
                     _status("getIceConfigResp received (post-livePlayReq)")
                 except asyncio.TimeoutError:
                     pass  # proceed without TURN; synthetic candidates are fallback
+            elif _fast_connect:
+                _status(
+                    "AIDOT_FAST_CONNECT: skipping getIceConfigResp wait"
+                    " (~2.5s) - STUN/host candidates only, LAN-direct"
+                )
 
         # ------------------------------------------------------------------ #
         # Branch: SDES-SRTP cameras use ffmpeg; DTLS cameras use aiortc
@@ -6152,6 +6206,28 @@ class DeviceClient(object):
             f"ICE servers: STUN={_stun_url}"
             f"  relay×{len(_turn_entries)}: {_turn_entries}"
         )
+        if _fast_connect:
+            # Strip TURN URIs so aiortc's setLocalDescription doesn't block on a
+            # TURN Allocate round-trip during ICE gathering — the LAN host
+            # candidate then connects in ~1 s.  Keep STUN (cheap, no allocate).
+            _stun_only = []
+            for _srv in _ice_servers:
+                _su = [
+                    u for u in (_srv.urls if isinstance(_srv.urls, list) else [_srv.urls])
+                    if not str(u).startswith(("turn:", "turns:"))
+                ]
+                if _su:
+                    _stun_only.append(
+                        RTCIceServer(urls=_su, username=_srv.username,
+                                     credential=_srv.credential)
+                    )
+            _ice_servers = _stun_only or [
+                RTCIceServer(urls=["stun:stun.l.google.com:19302"])
+            ]
+            _status(
+                "AIDOT_FAST_CONNECT: stripped TURN (STUN-only, LAN-direct) -"
+                f" {len(_ice_servers)} ICE server(s), no relay gather stall"
+            )
         pc = RTCPeerConnection(
             configuration=RTCConfiguration(iceServers=_ice_servers)
         )
@@ -8810,7 +8886,10 @@ class DeviceClient(object):
         # Allocate relay now so offer c= and m= carry relay IP/port.
         # Camera reads offer's c= to know where to send SRTP - relay address
         # here means SRTP reaches us even through port-restricted / hairpin NAT.
-        if _sdes_turn_entries:
+        # AIDOT_FAST_CONNECT skips this blocking pre-allocation (LAN-direct mode):
+        # the offer goes out immediately with host/srflx candidates and the LAN
+        # path connects without waiting on a cloud TURN Allocate round-trip.
+        if _sdes_turn_entries and not _fast_connect:
             try:
                 import re as _re_pre, hashlib as _hlk_pre
                 _our_te_pre = next(
@@ -9500,7 +9579,10 @@ class DeviceClient(object):
         # Early allocation was done inside the echo handler above.  This block
         # handles cameras that did not produce an echo (non-echo-reversal path)
         # so _relay_addrs is still empty at this point.
-        if not _relay_addrs:
+        # Skipped in AIDOT_FAST_CONNECT (LAN-direct): no relay alloc, host/srflx
+        # candidates only (the synchronous allocate would block the post-offer
+        # candidate trickle on a cloud round-trip).
+        if not _relay_addrs and not _fast_connect:
             try:
                 import re as _re_relay, hashlib as _hlk
                 _our_turn_entry = None

{python_aidot_cameras-0.5.4 → python_aidot_cameras-0.5.6/src/python_aidot_cameras.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.5.4
+Version: 0.5.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