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

{python_aidot_cameras-0.7.32/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.32
+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

{python_aidot_cameras-0.7.32 → 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.32"
+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.32 → 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.32 → 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.32 → 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.32
+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

{python_aidot_cameras-0.7.32 → 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)