python-aidot-cameras 0.7.31__tar.gz → 0.7.33__tar.gz

{python_aidot_cameras-0.7.31/src/python_aidot_cameras.egg-info → python_aidot_cameras-0.7.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.7.31
+Version: 0.7.33
 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
@@ -124,7 +124,7 @@ chosen to work out of the box; override only when tuning.
 | `AIDOT_FAST_CONNECT` | Enables LAN-direct "fast connect" mode (STUN-only, skips several cloud signaling waits) when set to a truthy value. | unset (off) |
 | `AIDOT_PERSISTENT_MQTT` | Reuse ONE account-level persistent MQTT connection for device commands, attribute fetches, AND stream-open signaling (matching the official app) instead of connecting per operation, cutting cloud connect churn. **On by default** (the app's behaviour; live soak cut SDES NO_MEDIA ~57%→~19%); set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
 | `AIDOT_SDES_ADAPTIVE` | Adaptive fast-with-fallback for the SDES keepalive loop: try the fast path first (skip livePlay waits + TURN relay pre-alloc) and fall back to the full relay path if a fast attempt delivers no media. A per-device cache skips the fast attempt on later views once it has failed for a camera. Truthy value enables. | unset (off) |
-| `AIDOT_SDES_FAST_LIVEPLAY` | Truthy value skips the `livePlayResp` blocking wait for eligible SDES cameras (~4.5 s faster cold start), while keeping the full ICE/SCTP handshake. Role-reversal models (A001064 PTZ) are always excluded. Soak-validated; opt-in. | unset (off) |
+| `AIDOT_SDES_FAST_LIVEPLAY` | Don't block on the `livePlayResp` wait for eligible SDES cameras (~4.5 s faster cold start), going straight to webrtcReq/ICE — what the official app does (it never waits for livePlayResp). Role-reversal models (A001064 PTZ) always excluded for correctness. **On by default**; set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
 | `AIDOT_SERVE_RELAY` | Holds the public stream port via an internal relay that proxies to ffmpeg, so the first (cold) view connects instead of failing while ffmpeg can't pre-bind the port. Set to `0` to serve ffmpeg directly. | `1` (enabled) |
 | `AIDOT_MAX_CONCURRENT_OPENS` | Caps how many stream opens run concurrently. | `2` |
 | `AIDOT_MAX_CONCURRENT_STREAMS` | Caps how many cameras stream at once. | `3` |

{python_aidot_cameras-0.7.31 → python_aidot_cameras-0.7.33}/README.md

@@ -97,7 +97,7 @@ chosen to work out of the box; override only when tuning.
 | `AIDOT_FAST_CONNECT` | Enables LAN-direct "fast connect" mode (STUN-only, skips several cloud signaling waits) when set to a truthy value. | unset (off) |
 | `AIDOT_PERSISTENT_MQTT` | Reuse ONE account-level persistent MQTT connection for device commands, attribute fetches, AND stream-open signaling (matching the official app) instead of connecting per operation, cutting cloud connect churn. **On by default** (the app's behaviour; live soak cut SDES NO_MEDIA ~57%→~19%); set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
 | `AIDOT_SDES_ADAPTIVE` | Adaptive fast-with-fallback for the SDES keepalive loop: try the fast path first (skip livePlay waits + TURN relay pre-alloc) and fall back to the full relay path if a fast attempt delivers no media. A per-device cache skips the fast attempt on later views once it has failed for a camera. Truthy value enables. | unset (off) |
-| `AIDOT_SDES_FAST_LIVEPLAY` | Truthy value skips the `livePlayResp` blocking wait for eligible SDES cameras (~4.5 s faster cold start), while keeping the full ICE/SCTP handshake. Role-reversal models (A001064 PTZ) are always excluded. Soak-validated; opt-in. | unset (off) |
+| `AIDOT_SDES_FAST_LIVEPLAY` | Don't block on the `livePlayResp` wait for eligible SDES cameras (~4.5 s faster cold start), going straight to webrtcReq/ICE — what the official app does (it never waits for livePlayResp). Role-reversal models (A001064 PTZ) always excluded for correctness. **On by default**; set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
 | `AIDOT_SERVE_RELAY` | Holds the public stream port via an internal relay that proxies to ffmpeg, so the first (cold) view connects instead of failing while ffmpeg can't pre-bind the port. Set to `0` to serve ffmpeg directly. | `1` (enabled) |
 | `AIDOT_MAX_CONCURRENT_OPENS` | Caps how many stream opens run concurrently. | `2` |
 | `AIDOT_MAX_CONCURRENT_STREAMS` | Caps how many cameras stream at once. | `3` |

{python_aidot_cameras-0.7.31 → python_aidot_cameras-0.7.33}/pyproject.toml

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

@@ -2607,16 +2607,19 @@ class CameraMixin(_CameraControlsMixin):
             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).
-
-        Role-reversal models (``_NO_FAST_LIVEPLAY_MODELS``, e.g. A001064) are always
-        excluded - their handshake needs the camera armed before our webrtcReq, so
-        the flag's early webrtcReq degrades their media reliability."""
+        """Whether to use SDES fast-liveplay: don't block on the always-timing-out
+        echo/livePlayResp signaling, go straight to webrtcReq/ICE.
+
+        **Default ON** - this is exactly what the official app does (it never waits
+        for/parses livePlayResp; fire-and-forget). Disable via
+        ``AIDOT_SDES_FAST_LIVEPLAY`` in {0,false,no,off} or per-camera
+        ``_sdes_fast_liveplay_opt=False`` (the explicit opt always wins).
+
+        Role-reversal models (``_NO_FAST_LIVEPLAY_MODELS``, e.g. A001064) are ALWAYS
+        excluded regardless of the flag - their handshake needs the camera armed
+        before our webrtcReq, so the early webrtcReq degrades their media (a
+        correctness exclusion, not a default choice). Only consulted for SDES
+        cameras (the caller gates on is_sdes_camera)."""
         model = getattr(getattr(self, "info", None), "model_id", None)
         if model in self._NO_FAST_LIVEPLAY_MODELS:
             return False
@@ -2626,8 +2629,8 @@ class CameraMixin(_CameraControlsMixin):
         ov = getattr(self, "_fast_attempt_override", None)
         if ov is not None:
             return bool(ov)
-        return os.environ.get("AIDOT_SDES_FAST_LIVEPLAY", "").strip().lower() in (
-            "1", "true", "yes", "on")
+        return os.environ.get("AIDOT_SDES_FAST_LIVEPLAY", "").strip().lower() not in (
+            "0", "false", "no", "off")
 
     def _resolve_sdes_skip_turn(self) -> bool:
         """EXPERIMENTAL (opt-in, default off): skip the blocking SDES TURN relay

{python_aidot_cameras-0.7.31 → python_aidot_cameras-0.7.33}/src/aidot/camera/sdes.py

@@ -181,15 +181,23 @@ class SdesSession:
             self._talk_state["stop"] = True
             self._talk_state["provider"] = None
         self._proc.terminate()
+        _stop_loop = asyncio.get_running_loop()
         try:
-            _stop_loop = asyncio.get_running_loop()
             await _stop_loop.run_in_executor(None, lambda: self._proc.wait(5))
         except Exception:
             self._proc.kill()
+        # Read drained stderr in the executor with a hard timeout: proc.stderr.read()
+        # blocks until EOF, which never arrives if the killed process is still a
+        # zombie / stuck in uninterruptible I/O - doing it inline would hang the
+        # whole event loop (and thus all of teardown).  Bound it so a wedged ffmpeg
+        # can't stall the close; we lose only the diagnostic stderr in that case.
         stderr_bytes = b""
         try:
-            stderr_bytes = self._proc.stderr.read()
-        except Exception:
+            stderr_bytes = await asyncio.wait_for(
+                _stop_loop.run_in_executor(None, self._proc.stderr.read),
+                timeout=2.0,
+            )
+        except Exception:   # incl. asyncio.TimeoutError - never let teardown hang here
             _LOGGER.debug("camera %s: swallowed exception", 'stop', exc_info=True)
         if stderr_bytes:
             _LOGGER.warning("ffmpeg SDES stderr:\n%s", stderr_bytes.decode(errors="replace"))

{python_aidot_cameras-0.7.31 → python_aidot_cameras-0.7.33}/src/aidot/device_client.py

@@ -229,14 +229,35 @@ class DeviceClient(CameraMixin):
         if ip is None:
             return
         self._ip_address = ip
-        if self._connecting is not True and self._connect_and_login is not True:
-            self._login_task = asyncio.create_task(self.async_login())
+        if self._connecting is True or self._connect_and_login is True:
+            return
+        # Throttle (shared 30s window with the reconnect chain): a repeated
+        # discovery - or a camera that slipped the _is_camera gate because its
+        # model was momentarily unknown - must not spawn a fresh TCP:10000 login
+        # every broadcast tick.  That hammers a device whose control port refuses
+        # (e.g. a battery camera) and spams "login read status error".  A device
+        # that genuinely needs to connect still does so within 30s.
+        now = time.monotonic()
+        if now - self._last_login_attempt < 30:
+            return
+        self._last_login_attempt = now
+        self._login_task = asyncio.create_task(self.async_login())
 
 
     async def async_login(self) -> None:
         """Connect and log in using the last-known IP if not already connected."""
         if self._ip_address is None:
             return
+        # The base TCP:10000 control channel is the LIGHT protocol.  Cameras never
+        # use it - their local control is the separate CameraLanClient
+        # (camera/lan_control.py) and their LAN IP comes from WebRTC signaling.  A
+        # camera reaching here means a discovered IP slipped the _is_camera gate;
+        # logging in would hammer a port the camera doesn't serve and spam
+        # "login read status error" (and never connect).  This is the single
+        # chokepoint for both the discovery and reconnect-chain login paths.
+        model = getattr(getattr(self, "info", None), "model_id", "") or ""
+        if "IPC" in model:
+            return
         if self._connecting is not True and self._connect_and_login is not True:
             await self.connect(self._ip_address)
 

{python_aidot_cameras-0.7.31 → python_aidot_cameras-0.7.33/src/python_aidot_cameras.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.7.31
+Version: 0.7.33
 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
@@ -124,7 +124,7 @@ chosen to work out of the box; override only when tuning.
 | `AIDOT_FAST_CONNECT` | Enables LAN-direct "fast connect" mode (STUN-only, skips several cloud signaling waits) when set to a truthy value. | unset (off) |
 | `AIDOT_PERSISTENT_MQTT` | Reuse ONE account-level persistent MQTT connection for device commands, attribute fetches, AND stream-open signaling (matching the official app) instead of connecting per operation, cutting cloud connect churn. **On by default** (the app's behaviour; live soak cut SDES NO_MEDIA ~57%→~19%); set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
 | `AIDOT_SDES_ADAPTIVE` | Adaptive fast-with-fallback for the SDES keepalive loop: try the fast path first (skip livePlay waits + TURN relay pre-alloc) and fall back to the full relay path if a fast attempt delivers no media. A per-device cache skips the fast attempt on later views once it has failed for a camera. Truthy value enables. | unset (off) |
-| `AIDOT_SDES_FAST_LIVEPLAY` | Truthy value skips the `livePlayResp` blocking wait for eligible SDES cameras (~4.5 s faster cold start), while keeping the full ICE/SCTP handshake. Role-reversal models (A001064 PTZ) are always excluded. Soak-validated; opt-in. | unset (off) |
+| `AIDOT_SDES_FAST_LIVEPLAY` | Don't block on the `livePlayResp` wait for eligible SDES cameras (~4.5 s faster cold start), going straight to webrtcReq/ICE — what the official app does (it never waits for livePlayResp). Role-reversal models (A001064 PTZ) always excluded for correctness. **On by default**; set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
 | `AIDOT_SERVE_RELAY` | Holds the public stream port via an internal relay that proxies to ffmpeg, so the first (cold) view connects instead of failing while ffmpeg can't pre-bind the port. Set to `0` to serve ffmpeg directly. | `1` (enabled) |
 | `AIDOT_MAX_CONCURRENT_OPENS` | Caps how many stream opens run concurrently. | `2` |
 | `AIDOT_MAX_CONCURRENT_STREAMS` | Caps how many cameras stream at once. | `3` |

{python_aidot_cameras-0.7.31 → python_aidot_cameras-0.7.33}/src/python_aidot_cameras.egg-info/SOURCES.txt

@@ -36,6 +36,7 @@ src/python_aidot_cameras.egg-info/requires.txt
 src/python_aidot_cameras.egg-info/top_level.txt
 tests/test_alarm_event.py
 tests/test_backoff.py
+tests/test_device_login_guard.py
 tests/test_go2rtc.py
 tests/test_highport_nomination.py
 tests/test_lan_control.py

python_aidot_cameras-0.7.33/tests/test_device_login_guard.py

@@ -0,0 +1,95 @@
+"""Unit tests for the base-DeviceClient local-login guard + throttle.
+
+The TCP:10000 control channel is the LIGHT protocol; cameras must never use it
+(they use the separate CameraLanClient + WebRTC signaling for their LAN IP). A
+camera reaching async_login would hammer a refusing port and spam
+"login read status error". These tests lock the camera-exclusion and the
+re-login throttle without a real socket.
+"""
+import asyncio
+import os
+import sys
+from types import SimpleNamespace
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "src"))
+
+import aidot.device_client as dc_mod
+
+DeviceClient = dc_mod.DeviceClient
+
+
+def _client(model_id):
+    c = DeviceClient.__new__(DeviceClient)
+    c.info = SimpleNamespace(model_id=model_id)
+    c._ip_address = "192.168.1.50"
+    c._connecting = False
+    c._connect_and_login = False
+    c._last_login_attempt = 0.0
+    c._connected = []  # record connect() calls
+    async def _fake_connect(ip):
+        c._connected.append(ip)
+    c.connect = _fake_connect
+    return c
+
+
+def test_camera_never_does_base_login():
+    cam = _client("LK.IPC.A001513")          # battery SDES camera
+    asyncio.run(cam.async_login())
+    assert cam._connected == []               # camera excluded - no TCP:10000 login
+
+
+def test_ptz_camera_excluded():
+    cam = _client("LK.IPC.A001064")
+    asyncio.run(cam.async_login())
+    assert cam._connected == []
+
+
+def test_light_still_logs_in():
+    light = _client("lk.WIFI-RGBWLight-D0006")
+    asyncio.run(light.async_login())
+    assert light._connected == ["192.168.1.50"]   # lights keep the base login
+
+
+def test_unknown_model_logs_in():
+    # No "IPC" in model -> treated as a (light) device that uses the base channel.
+    dev = _client("")
+    asyncio.run(dev.async_login())
+    assert dev._connected == ["192.168.1.50"]
+
+
+def test_update_ip_address_throttles_relogin():
+    light = _client("lk.WIFI-RGBWLight-D0006")
+    spawned = []
+    # update_ip_address schedules async_login via create_task; capture the calls
+    # by counting how many times the throttle lets a login attempt through.
+    light._login_task = None
+    orig = dc_mod.asyncio.create_task
+
+    def _count_task(coro):
+        spawned.append(1)
+        coro.close()            # don't actually run the login
+        return SimpleNamespace(done=lambda: True, cancel=lambda: None)
+
+    dc_mod.asyncio.create_task = _count_task
+    try:
+        light.update_ip_address("192.168.1.50")   # first: allowed
+        light.update_ip_address("192.168.1.50")   # immediate repeat: throttled
+        light.update_ip_address("192.168.1.50")   # still throttled
+    finally:
+        dc_mod.asyncio.create_task = orig
+    assert len(spawned) == 1, f"expected 1 login within the 30s window, got {len(spawned)}"
+
+
+if __name__ == "__main__":
+    import traceback
+    _fail = 0
+    for _k, _v in sorted(globals().items()):
+        if _k.startswith("test_"):
+            try:
+                _v()
+                print(f"PASS {_k}")
+            except Exception:
+                _fail += 1
+                print(f"FAIL {_k}")
+                traceback.print_exc()
+    raise SystemExit(1 if _fail else 0)

{python_aidot_cameras-0.7.31 → python_aidot_cameras-0.7.33}/tests/test_sdes_fast_liveplay.py

@@ -21,21 +21,22 @@ def _cam():
     return _CAM.__new__(_CAM)
 
 
-def test_default_off(monkeypatch):
+def test_default_on(monkeypatch):
+    # default ON (matches the app — it never waits for livePlayResp)
     monkeypatch.delenv("AIDOT_SDES_FAST_LIVEPLAY", raising=False)
-    assert _cam()._resolve_sdes_fast_liveplay() is False
+    assert _cam()._resolve_sdes_fast_liveplay() is True
 
 
-def test_env_truthy_values(monkeypatch):
-    for val in ("1", "true", "TRUE", "yes", "on", " On "):
+def test_env_disables(monkeypatch):
+    for val in ("0", "false", "no", "off", " Off "):
         monkeypatch.setenv("AIDOT_SDES_FAST_LIVEPLAY", val)
-        assert _cam()._resolve_sdes_fast_liveplay() is True, val
+        assert _cam()._resolve_sdes_fast_liveplay() is False, val
 
 
-def test_env_falsey_values(monkeypatch):
-    for val in ("0", "false", "no", "off", ""):
+def test_env_truthy_or_unknown_stays_on(monkeypatch):
+    for val in ("1", "true", "yes", "on", "", "anything"):
         monkeypatch.setenv("AIDOT_SDES_FAST_LIVEPLAY", val)
-        assert _cam()._resolve_sdes_fast_liveplay() is False, val
+        assert _cam()._resolve_sdes_fast_liveplay() is True, val
 
 
 def test_role_reversal_model_always_excluded(monkeypatch):