python-aidot-cameras 0.6.0__tar.gz → 0.6.1__tar.gz

{python_aidot_cameras-0.6.0/src/python_aidot_cameras.egg-info → python_aidot_cameras-0.6.1}/PKG-INFO

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

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

{python_aidot_cameras-0.6.0 → python_aidot_cameras-0.6.1}/src/aidot/camera/client.py

@@ -17,6 +17,7 @@ from typing import Any, Callable, List, Optional
 
 from ..aes_utils import aes_encrypt, aes_decrypt, aes_ecb_encrypt_str_key, aes_ecb_decrypt_str_key
 from ..exceptions import AidotCameraBusy
+from ..login_const import APP_ID as _AIDOT_APP_ID
 from ..const import (
     CONF_AES_KEY,
     CONF_ASCNUMBER,
@@ -49,12 +50,28 @@ _LOGGER = logging.getLogger(__name__)
 # Runtime import: device_client defines these classes BEFORE importing this
 # module (the package __init__ loads aidot.device_client first), so the
 # partially-initialized module already exposes them here.
-from ..device_client import DeviceStatusData, DeviceInformation
+try:
+    from ..device_client import DeviceStatusData, DeviceInformation
+except ImportError as _exc:  # pragma: no cover - ordering contract violation
+    raise ImportError(
+        "aidot.camera.client must be imported via aidot.device_client "
+        "(import aidot first); keep the camera import block in "
+        "device_client.py below the DeviceStatusData/DeviceInformation "
+        "definitions"
+    ) from _exc
 
 
 class CameraStatusData(DeviceStatusData):
     """Core status plus camera fields; accepts both typed-model and dict updates."""
 
+    # Restore None-as-unknown semantics: the core defaults (red/2700K/100)
+    # would otherwise be pushed to consumers as real state before the first
+    # getDevAttrReq reply arrives.
+    rgdb: "int | None" = None
+    rgbw: "tuple[int, int, int, int] | None" = None
+    cct: "int | None" = None
+    dimming: "int | None" = None
+
     # Camera-specific fields (None = unknown/not yet queried)
     motion_detection: Optional[bool] = None
     motion_sensitivity: Optional[int] = None  # MotionDetection_Sen 1-5
@@ -76,23 +93,16 @@ class CameraStatusData(DeviceStatusData):
             return
         if not isinstance(attr, dict):
             # Typed DeviceAttr model from the core local-control receive path.
+            # Guard: a malformed payload.attr (non-dict, non-model) must not
+            # kill the caller's receive loop.
+            if not hasattr(attr, "OnOff"):
+                return
             super().update(attr)
             return
-        # Dict path (camera attribute / cloud-properties payloads).
-        if attr.get(CONF_ON_OFF) is not None:
-            self.on = attr.get(CONF_ON_OFF)
-        if attr.get(CONF_DIMMING) is not None:
-            self.dimming = int(attr.get(CONF_DIMMING) * 255 / 100)
-        if attr.get(CONF_RGBW) is not None:
-            self.rgdb = attr.get(CONF_RGBW)
-            rgbw = ctypes.c_uint32(self.rgdb).value
-            r = (rgbw >> 24) & 0xFF
-            g = (rgbw >> 16) & 0xFF
-            b = (rgbw >> 8) & 0xFF
-            w = rgbw & 0xFF
-            self.rgbw = (r, g, b, w)
-        if attr.get(CONF_CCT) is not None:
-            self.cct = attr.get(CONF_CCT)
+        # Dict path: camera attributes ONLY.  Light keys (OnOff/Dimming/RGBW/
+        # CCT) are handled by the typed-model path in the core; the dict
+        # feeders either strip them (update_from_camera_attributes) or have
+        # already applied them via the model (receive_data raw-dict pass).
         # Camera attributes
         if (v := attr.get("MotionDetection_Enable")) is not None:
             self.motion_detection = bool(int(v))
@@ -2675,15 +2685,25 @@ def _ip_looks_ascii_garbled(ip_str) -> bool:
 class CameraMixin:
     """All camera/streaming methods, mixed into DeviceClient via inheritance."""
 
+    # Devices without an aesKey never get this set by the core constructor;
+    # default it so get_send_packet and friends see None instead of raising.
+    aes_key = None
+
     def _init_camera_state(self, device: dict, user_info: dict) -> None:
         """Camera-side state init, called once at the end of DeviceClient.__init__.
 
         Everything camera-specific that the upstream constructor does not set
         lives here, so the core __init__ body stays aligned with upstream.
         """
-        # Swap in the camera-aware status/info supersets created by the core.
+        # Swap in the camera-aware status/info supersets created by the core,
+        # carrying forward anything the core constructor seeded into the
+        # originals so upstream-added seeding cannot be lost silently.
+        _core_status, _core_info = self.status, self.info
         self.status = CameraStatusData()
+        self.status.__dict__.update(_core_status.__dict__)
         self.info = CameraDeviceInformation(device)
+        for _k, _v in _core_info.__dict__.items():
+            self.info.__dict__.setdefault(_k, _v)
         # livePlayReq dseq - app parity (Q0(): starts at 100, increments per
         # request).  Camera tracks the live-play sequence; 0 is not a valid seq.
         self._live_dseq = 100
@@ -2702,9 +2722,7 @@ class CameraMixin:
         self._token_refresh_cb: "Optional[Callable]" = None
         # Raw device dict retained for transport-type detection (isDTLS field)
         self._raw_device: dict = device
-        # Devices without an aesKey never set this in the core constructor.
-        if not hasattr(self, "aes_key"):
-            self.aes_key = None
+
         # Seed camera/diagnostic status from the cloud device "properties" payload
         # (Battery_remaining, Occupancy, SDcardStatus, MotionDetection_*, …).  This
         # is the authoritative, always-current source the official app itself reads
@@ -3169,7 +3187,7 @@ class CameraMixin:
         token = (self._user_info.get("accessToken")
                  or self._user_info.get("access_token") or "")
         return {
-            "Appid":        "1383974540041977857",
+            "Appid":        _AIDOT_APP_ID,
             "Token":        token,
             "Terminal":     "app",
             "Content-Type": "application/json",

{python_aidot_cameras-0.6.0 → python_aidot_cameras-0.6.1}/src/aidot/client.py

@@ -58,6 +58,14 @@ def rsa_password_encrypt(message: str) -> str:
 
 
 
+def _is_camera(device_client: "DeviceClient") -> bool:
+    """Cameras get their LAN IP from WebRTC signaling, never from the UDP
+    sweep; pushing a discovered IP would trigger light-protocol logins on
+    TCP:10000 (which can hang - the camera accepts but never answers)."""
+    model = getattr(getattr(device_client, "info", None), "model_id", "") or ""
+    return "IPC" in model
+
+
 async def _prefetch_ice_config(dc: "DeviceClient") -> None:
     """Background task: warm the HTTP ICE config cache for a device."""
     try:
@@ -157,7 +165,11 @@ class AidotClient:
     def update_password(self, password: str) -> None:
         self.password = password
 
+    _terminal_id: "Optional[str]" = None
+
     async def get_terminal_id(self) -> str:
+        if self._terminal_id is not None:
+            return self._terminal_id
         file_path = Path.home() / ".aidot_terminal_id"
 
         def _read_or_create() -> str:
@@ -173,7 +185,8 @@ class AidotClient:
                 return 'gvz3gjae10l4zii00t7y0'
 
         raw_id = await asyncio.to_thread(_read_or_create)
-        return hashlib.md5(raw_id.encode()).hexdigest()
+        self._terminal_id = hashlib.md5(raw_id.encode()).hexdigest()
+        return self._terminal_id
 
     async def async_post_login(self) -> dict[str, Any]:
         """Login via loginWithFreeVerification (RSA-encrypted password)."""
@@ -456,11 +469,15 @@ class AidotClient:
             asyncio.get_running_loop().create_task(
                 _prefetch_ice_config(device_client)
             )
+        # Started lazily here as well: __init__ cannot start discovery when
+        # constructed outside a running event loop (stored-token sync path).
+        if self._discover is None:
+            self.setup_discover()
         # Lights get their LAN IP from UDP discovery.  Cameras do NOT use the
         # broadcast sweep: their LAN IP comes from the WebRTC signaling host
         # candidate (iceCandidateReq), which the camera advertises and we add
         # verbatim - the official app does the same.
-        if self._discover is not None:
+        if self._discover is not None and not _is_camera(device_client):
             ip = self._discover.discovered_device.get(device_id)
             device_client.update_ip_address(ip)
         return device_client
@@ -481,7 +498,7 @@ class AidotClient:
         def _discover_callback(dev_id, event: dict[str, str]) -> None:
             device_ip = event[CONF_IPADDRESS]
             device_client: DeviceClient = self._device_clients.get(dev_id)
-            if device_client is not None:
+            if device_client is not None and not _is_camera(device_client):
                 device_client.update_ip_address(device_ip)
 
         try:
@@ -493,6 +510,8 @@ class AidotClient:
 
     async def async_close(self) -> None:
         """Close the client and release resources."""
+        if self._refresh_task and not self._refresh_task.done():
+            self._refresh_task.cancel()
         if self._discover is not None:
             self._discover.close()
             self._discover = None
@@ -501,14 +520,8 @@ class AidotClient:
         self._device_clients.clear()
 
     def cleanup(self) -> None:
-        if self._discover is not None:
-            self._discover.close()
-            self._discover = None
-        for client in self._device_clients.values():
-            asyncio.get_running_loop().create_task(client.close())
-        self._device_clients.clear()
+        """Sync entry point: fire-and-forget async_close()."""
+        asyncio.get_running_loop().create_task(self.async_close())
 
     async def async_cleanup(self) -> None:
-        if self._refresh_task and not self._refresh_task.done():
-            self._refresh_task.cancel()
         await self.async_close()

{python_aidot_cameras-0.6.0 → python_aidot_cameras-0.6.1}/src/aidot/const.py

@@ -233,8 +233,9 @@ class ServerErrorCode(IntEnum):
 
 # ── Cloud API credentials ──────────────────────────────────────────────────── #
 
-APP_ID = "1383974540041977857"
-BASE_URL = "https://prod-us-api.arnoo.com/v17"
+from .login_const import APP_ID, PUBLIC_KEY_PEM  # noqa: E402 - back-compat re-export
+from .login_const import API_URL_TEMPLATE as _API_URL_TEMPLATE, DEFAULT_REGION as _DEFAULT_REGION  # noqa: E402
+BASE_URL = _API_URL_TEMPLATE.format(region=_DEFAULT_REGION)
 
 PUBLIC_KEY_PEM = b"""-----BEGIN PUBLIC KEY-----
 MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCtQAnPCi8ksPnS1Du6z96PsKfN

{python_aidot_cameras-0.6.0 → python_aidot_cameras-0.6.1}/src/aidot/device_client.py

@@ -201,6 +201,9 @@ class DeviceClient(CameraMixin, object):
             sock: socket.socket = self.writer.get_extra_info("socket")
             sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
             self.seq_num = 1
+            # Cloud polls may have seeded status.online; the gate below must
+            # reflect this TCP login only.
+            self.status.online = False
             await self.login()
             self._connect_and_login = self.status.online
         except Exception as e:
@@ -322,6 +325,9 @@ class DeviceClient(CameraMixin, object):
                     self.ascNumber = response.payload.ascNumber
                 if response.payload.attr:
                     self.status.update(response.payload.attr)
+                    # Camera/floodlight keys are not in the typed DeviceAttr
+                    # model; pass the raw dict so they are not dropped.
+                    self.status.update((json_data.get(CONF_PAYLOAD) or {}).get(CONF_ATTR))
                     self._notify_status_update()
     
     def _schedule_ping(self):
@@ -436,13 +442,29 @@ class DeviceClient(CameraMixin, object):
 
     async def close(self) -> None:
         self._is_close = True
+        if self._login_task is not None and not self._login_task.done():
+            self._login_task.cancel()
         await self.async_stop_streaming()
         await self.reset()
         _LOGGER.info(f"{self.device_id} connect close by user")
 
+    _last_login_attempt: float = 0.0
+
     def _schedule_reconnect(self) -> None:
         """延迟重连"""
+        if self._is_close:
+            return
+        if self._reconnect_handle is not None:
+            return  # a reconnect chain is already armed
         _LOGGER.info(f"{self.device_id} _schedule_reconnect")
         loop = asyncio.get_running_loop()
-        self._reconnect_handle = loop.call_later(60, self._schedule_reconnect)
+        self._reconnect_handle = loop.call_later(60, self._reconnect_fire)
+        now = time.monotonic()
+        if now - self._last_login_attempt < 30:
+            return  # too soon after the last attempt; the timer above retries
+        self._last_login_attempt = now
         self._login_task = asyncio.create_task(self.async_login())
+
+    def _reconnect_fire(self) -> None:
+        self._reconnect_handle = None
+        self._schedule_reconnect()

{python_aidot_cameras-0.6.0 → python_aidot_cameras-0.6.1}/src/aidot/discover.py

@@ -14,7 +14,6 @@ from .exceptions import AidotOSError
 from .models.discover_model import DiscoverResponse, DiscoverRequest
 
 _LOGGER = logging.getLogger(__name__)
-_DISCOVER_TIME = 5      # legacy repeat_broadcast() loop interval (seconds)
 _DISCOVER_FAST = 6      # fast discovery cadence right after startup
 _DISCOVER_SLOW = 120    # slow maintenance cadence once stable
 
@@ -141,13 +140,16 @@ class Discover:
         self._login_info = login_info
         self._callback = callback
         self._protocols: List[BroadcastProtocol] = []
+        self._is_close = False
+        self._broadcast_task: "asyncio.Task | None" = None
 
     async def _ensure_sockets(self) -> None:
         """Create one datagram endpoint per active interface (idempotent)."""
-        if self._protocols:
+        if self._is_close or self._protocols:
             return
 
-        candidates = _get_broadcast_candidates()
+        # subprocess-based interface enumeration must not block the loop
+        candidates = await asyncio.to_thread(_get_broadcast_candidates)
         user_id = self._login_info[CONF_ID]
 
         for bind_ip, broadcast_ip in candidates:
@@ -192,15 +194,6 @@ class Discover:
         for proto in self._protocols:
             proto.send_broadcast()
 
-    async def repeat_broadcast(self) -> None:
-        self._is_close = False
-        while True:
-            await self.send_broadcast()
-            for _ in range(_DISCOVER_TIME):
-                await asyncio.sleep(1)
-                if self._is_close:
-                    return
-
     def start_repeat_broadcast(self) -> None:
         """Timer-driven discovery: a few fast rounds at startup, then slow."""
         self._is_close = False
@@ -208,6 +201,8 @@ class Discover:
         self._schedule_broadcast()
 
     def _schedule_broadcast(self) -> None:
+        if self._is_close:
+            return
         if self._fast_discover_count > 0:
             interval = _DISCOVER_FAST
             self._fast_discover_count -= 1
@@ -215,20 +210,17 @@ class Discover:
             interval = _DISCOVER_SLOW
 
         loop = asyncio.get_running_loop()
-        asyncio.create_task(self._do_broadcast())
+        self._broadcast_task = asyncio.create_task(self._do_broadcast())
         self._timer_handle = loop.call_later(interval, self._schedule_broadcast)
 
     async def _do_broadcast(self) -> None:
+        if self._is_close:
+            return
         try:
             await self.send_broadcast()
         except Exception as e:
             _LOGGER.error(f"Broadcast failed: {e}")
 
-    async def fetch_devices_info(self) -> dict[str, str]:
-        await self.send_broadcast()
-        await asyncio.sleep(2)
-        return self.discovered_device
-
     def _discover_callback(self, dev_id, event: dict[str, str]) -> None:
         self.discovered_device[dev_id] = event[CONF_IPADDRESS]
         if self._callback:
@@ -236,6 +228,8 @@ class Discover:
 
     def close(self) -> None:
         self._is_close = True
+        if self._broadcast_task is not None and not self._broadcast_task.done():
+            self._broadcast_task.cancel()
         if self._timer_handle is not None:
             self._timer_handle.cancel()
             self._timer_handle = None

{python_aidot_cameras-0.6.0 → python_aidot_cameras-0.6.1/src/python_aidot_cameras.egg-info}/PKG-INFO

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

@@ -26,6 +26,7 @@ tests/test_alarm_event.py
 tests/test_highport_nomination.py
 tests/test_motion_poll.py
 tests/test_no_undefined_names.py
+tests/test_post_merge_hardening.py
 tests/test_sdes_idle_release.py
 tests/test_sdes_sprop.py
 tests/test_sdes_talk.py

python_aidot_cameras-0.6.1/tests/test_post_merge_hardening.py

@@ -0,0 +1,178 @@
+"""Regression tests for the post-upstream-sync hardening fixes.
+
+Covers: the connect() login gate, reconnect chain dedup/backoff, discovery
+quiescence after close(), the camera filter on discovered IPs, status
+None-defaults, the dict/model update dispatch, and the DeviceClient/
+CameraMixin name-collision tripwire for future upstream merges.
+"""
+
+import asyncio
+import os
+import sys
+import time
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "src"))
+
+import pytest
+
+from aidot.camera.client import CameraMixin, CameraStatusData, CameraDeviceInformation
+from aidot.client import _is_camera
+from aidot.device_client import DeviceClient, DeviceStatusData
+from aidot.discover import Discover
+from aidot.models.device_client_model import DeviceAttr
+
+
+DEVICE = {
+    "id": "dev1",
+    "name": "Test Light",
+    "modelId": "LK.light.A001497",
+    "aesKey": ["k" * 16],
+    "password": "pw",
+    "online": True,
+}
+CAMERA = {**DEVICE, "id": "cam1", "name": "Test Cam", "modelId": "LK.IPC.A000088"}
+USER = {"id": "user1", "region": "us"}
+
+
+def make_dc(device=DEVICE):
+    return DeviceClient(dict(device), dict(USER))
+
+
+# --------------------------------------------------------------------------- #
+# connect() gate
+# --------------------------------------------------------------------------- #
+
+def test_connect_gate_ignores_cloud_seeded_online(monkeypatch):
+    """A swallowed login failure must not report as connected just because
+    the cloud device dict said online=true."""
+    dc = make_dc()
+    dc.status.online = True  # cloud-seeded (update_status_from_device)
+
+    class _W:
+        def get_extra_info(self, _):
+            import socket as _s
+            s = _s.socket()
+            return s
+
+    async def fake_open(*a, **k):
+        return object(), _W()
+
+    async def fake_login(self):
+        return  # login fails silently (exception swallowed inside login())
+
+    monkeypatch.setattr(asyncio, "open_connection", fake_open)
+    monkeypatch.setattr(DeviceClient, "login", fake_login)
+    asyncio.run(dc.connect("127.0.0.1"))
+    assert dc.connect_and_login is False
+
+
+# --------------------------------------------------------------------------- #
+# reconnect chain
+# --------------------------------------------------------------------------- #
+
+def test_schedule_reconnect_single_chain_and_backoff():
+    async def run():
+        dc = make_dc()
+        dc._ip_address = "127.0.0.1"
+        dc._last_login_attempt = time.monotonic()  # recent attempt -> backoff
+
+        dc._schedule_reconnect()
+        first_handle = dc._reconnect_handle
+        assert first_handle is not None
+        assert dc._login_task is None  # backoff floor suppressed immediate login
+
+        dc._schedule_reconnect()  # concurrent reset path
+        assert dc._reconnect_handle is first_handle  # no second chain
+
+        first_handle.cancel()
+
+    asyncio.run(run())
+
+
+def test_schedule_reconnect_noop_after_close():
+    async def run():
+        dc = make_dc()
+        dc._ip_address = "127.0.0.1"
+        dc._is_close = True
+        dc._schedule_reconnect()
+        assert dc._reconnect_handle is None
+
+    asyncio.run(run())
+
+
+# --------------------------------------------------------------------------- #
+# discovery
+# --------------------------------------------------------------------------- #
+
+def test_discover_quiescent_after_close():
+    async def run():
+        d = Discover({"id": "user1"}, None)
+        d.close()
+        await d._do_broadcast()  # in-flight task firing after close
+        await d._ensure_sockets()
+        assert d._protocols == []  # no sockets recreated
+
+    asyncio.run(run())
+
+
+def test_camera_filter():
+    assert _is_camera(make_dc(CAMERA)) is True
+    assert _is_camera(make_dc(DEVICE)) is False
+
+
+# --------------------------------------------------------------------------- #
+# status semantics
+# --------------------------------------------------------------------------- #
+
+def test_status_defaults_are_unknown():
+    s = CameraStatusData()
+    assert s.dimming is None and s.cct is None and s.rgbw is None and s.rgdb is None
+
+
+def test_update_dispatch_model_vs_dict():
+    s = CameraStatusData()
+    s.update(DeviceAttr(OnOff=1, CCT=4000))
+    assert s.on == 1 and s.cct == 4000
+    # dict path: camera keys applied, light keys ignored (model path owns them)
+    s.update({"Battery_remaining": "77", "CCT": 9999})
+    assert s.battery_remaining == 77
+    assert s.cct == 4000
+    # malformed model-path payload must not raise
+    s.update("garbage")
+    s.update(["garbage"])
+
+
+def test_camera_state_carry_forward():
+    """State seeded into the core status object before the camera swap must
+    survive on the replacement object."""
+    dc = make_dc()
+    # simulate: as if the core constructor had seeded state pre-swap
+    core_status = DeviceStatusData()
+    core_status.online = True
+    dc.status = core_status
+    dc._init_camera_state(dict(DEVICE), dict(USER))
+    assert isinstance(dc.status, CameraStatusData)
+    assert dc.status.online is True
+
+
+# --------------------------------------------------------------------------- #
+# upstream-merge tripwire
+# --------------------------------------------------------------------------- #
+
+def test_no_silent_mro_shadowing():
+    """If upstream adds a DeviceClient method whose name CameraMixin already
+    defines, the upstream version silently shadows the camera one after a
+    conflict-free merge.  Keep this intersection explicitly reviewed."""
+    intentional = {
+        # device_client.py deliberately overrides/joins these:
+        "__init__",
+    }
+    # Compare only non-dunder names: interpreter-added dunders vary by
+    # Python version (3.13 adds __firstlineno__/__static_attributes__).
+    core = {n for n in DeviceClient.__dict__ if not n.startswith("__")}
+    camera = {n for n in CameraMixin.__dict__ if not n.startswith("__")}
+    collisions = (core & camera) - intentional
+    assert collisions == set(), (
+        f"DeviceClient now shadows CameraMixin names {sorted(collisions)}; "
+        "verify intent and update this test's allowlist"
+    )