python-aidot-cameras 0.11.1__tar.gz → 0.11.3__tar.gz

{python_aidot_cameras-0.11.1/python_aidot_cameras.egg-info → python_aidot_cameras-0.11.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.11.1
+Version: 0.11.3
 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
@@ -94,10 +94,18 @@ pipx install "python-aidot-cameras[webrtc]"
 # or:
 uv tool install "python-aidot-cameras[webrtc]"
 
+export AIDOT_USERNAME=... AIDOT_PASSWORD=...   # or AIDOT_TOKEN_FILE, see below
 aidot-go2rtc --list                  # discover cameras + their transport
 aidot-go2rtc <device_id> '{output}'  # stream one camera (as a go2rtc exec: source)
 ```
 
+Authenticates via `AIDOT_USERNAME`/`AIDOT_PASSWORD` (`AIDOT_COUNTRY`, default
+`US`) - a dedicated login is recommended for long-running standalone use, so
+it doesn't fight Home Assistant over a shared rotating refresh token. Set
+`AIDOT_TOKEN_FILE=/path/to/token.json` to cache the login across restarts;
+token rotations are written back automatically. Run `aidot-go2rtc --help` for
+the full list of authentication and stream env vars.
+
 ## Usage
 
 Open a live WebRTC stream from a camera device client:
@@ -159,7 +167,7 @@ audio, idle release, the sprop cache path) are documented in
 | `AIDOT_SDES_ADAPTIVE` | Adaptive fast-with-fallback for the SDES keepalive loop: try the fast path first 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. Truthy value enables. | unset (off) |
 | `AIDOT_SDES_FAST_LIVEPLAY` | Don't block on the `livePlayResp` wait for eligible SDES cameras (~4.5 s faster cold start). Role-reversal models (A001064 PTZ) always excluded for correctness. **On by default**; set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
 | `AIDOT_DTLS_FAST_LIVEPLAY` | The DTLS (A000088) analogue: skip the `livePlayReq`-echo and `livePlayResp` waits (the dominant LAN cold-start cost) while keeping the full ICE/TURN/DTLS handshake, so remote/relay viewing is unaffected. **On by default**; set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
-| `AIDOT_PERSISTENT_MQTT` | Reuse ONE account-level persistent MQTT connection for commands, attribute fetches, and stream-open signaling (matching the official app) instead of connecting per operation. **On by default** (live soak cut SDES NO_MEDIA ~57%->~19%); set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
+| `AIDOT_PERSISTENT_MQTT` | Reuse ONE account-level persistent MQTT connection for commands, attribute fetches, and stream-open signaling (matching the official app) instead of connecting per operation. **On by default** (live soaks cut SDES NO_MEDIA from ~57% to ~11-19%); set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
 | `AIDOT_SERVE_RELAY` | Hold 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_LIVESTREAM_PARAM` | Set to `0` to skip the cloud `liveStreamParam` pre-connect that provisions battery cameras' live-stream sessions before signaling (without it, battery cameras like the L2 models reject streaming with `-50019`). | `1` (enabled) |
 

{python_aidot_cameras-0.11.1 → python_aidot_cameras-0.11.3}/README.md

@@ -64,10 +64,18 @@ pipx install "python-aidot-cameras[webrtc]"
 # or:
 uv tool install "python-aidot-cameras[webrtc]"
 
+export AIDOT_USERNAME=... AIDOT_PASSWORD=...   # or AIDOT_TOKEN_FILE, see below
 aidot-go2rtc --list                  # discover cameras + their transport
 aidot-go2rtc <device_id> '{output}'  # stream one camera (as a go2rtc exec: source)
 ```
 
+Authenticates via `AIDOT_USERNAME`/`AIDOT_PASSWORD` (`AIDOT_COUNTRY`, default
+`US`) - a dedicated login is recommended for long-running standalone use, so
+it doesn't fight Home Assistant over a shared rotating refresh token. Set
+`AIDOT_TOKEN_FILE=/path/to/token.json` to cache the login across restarts;
+token rotations are written back automatically. Run `aidot-go2rtc --help` for
+the full list of authentication and stream env vars.
+
 ## Usage
 
 Open a live WebRTC stream from a camera device client:
@@ -129,7 +137,7 @@ audio, idle release, the sprop cache path) are documented in
 | `AIDOT_SDES_ADAPTIVE` | Adaptive fast-with-fallback for the SDES keepalive loop: try the fast path first 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. Truthy value enables. | unset (off) |
 | `AIDOT_SDES_FAST_LIVEPLAY` | Don't block on the `livePlayResp` wait for eligible SDES cameras (~4.5 s faster cold start). Role-reversal models (A001064 PTZ) always excluded for correctness. **On by default**; set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
 | `AIDOT_DTLS_FAST_LIVEPLAY` | The DTLS (A000088) analogue: skip the `livePlayReq`-echo and `livePlayResp` waits (the dominant LAN cold-start cost) while keeping the full ICE/TURN/DTLS handshake, so remote/relay viewing is unaffected. **On by default**; set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
-| `AIDOT_PERSISTENT_MQTT` | Reuse ONE account-level persistent MQTT connection for commands, attribute fetches, and stream-open signaling (matching the official app) instead of connecting per operation. **On by default** (live soak cut SDES NO_MEDIA ~57%->~19%); set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
+| `AIDOT_PERSISTENT_MQTT` | Reuse ONE account-level persistent MQTT connection for commands, attribute fetches, and stream-open signaling (matching the official app) instead of connecting per operation. **On by default** (live soaks cut SDES NO_MEDIA from ~57% to ~11-19%); set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
 | `AIDOT_SERVE_RELAY` | Hold 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_LIVESTREAM_PARAM` | Set to `0` to skip the cloud `liveStreamParam` pre-connect that provisions battery cameras' live-stream sessions before signaling (without it, battery cameras like the L2 models reject streaming with `-50019`). | `1` (enabled) |
 

{python_aidot_cameras-0.11.1 → python_aidot_cameras-0.11.3}/aidot/__main__.py

@@ -59,6 +59,7 @@ import logging
 import os
 import signal
 import sys
+import tempfile
 
 import aiohttp
 
@@ -85,10 +86,25 @@ def _read_token_file(path: str) -> dict:
 
 
 def _write_token_file(path: str, data: dict) -> None:
-    """Blocking write of login_info to ``path`` with 0600 perms."""
-    with open(path, "w", encoding="utf-8") as fh:
-        json.dump(data, fh)
-    os.chmod(path, 0o600)
+    """Atomic, 0600-secure write of login_info to ``path``.
+
+    Serialize into a temp file in the same directory (mkstemp creates it 0600,
+    closing the world-readable window os.chmod-after-write leaves) and only then
+    os.replace it over ``path`` - so a serialization failure never truncates the
+    previously-valid token. On any error the temp file is removed and re-raised.
+    """
+    directory = os.path.dirname(path) or "."
+    fd, tmp = tempfile.mkstemp(dir=directory, prefix=".token-", suffix=".tmp")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as fh:
+            json.dump(data, fh)
+        os.replace(tmp, path)
+    except BaseException:
+        try:
+            os.unlink(tmp)
+        except OSError:
+            pass
+        raise
 
 
 def _install_token_cache(client: AidotClient, path: str) -> None:
@@ -102,9 +118,17 @@ def _install_token_cache(client: AidotClient, path: str) -> None:
     """
     def _cb() -> None:
         try:
-            _write_token_file(path, client.login_info)
+            _write_token_file(path, client.serializable_login_info())
             _LOGGER.debug("Cached refreshed token to %s", path)
-        except OSError as exc:
+        except (OSError, TypeError) as exc:
+            # TypeError: a defensive belt-and-suspenders catch alongside
+            # serializable_login_info() itself - if a future runtime-only key
+            # is ever added to login_info without also being added to
+            # RUNTIME_ONLY_LOGIN_INFO_KEYS, this keeps a caching bug from
+            # ever propagating out of a callback and interrupting a token
+            # refresh that had otherwise already succeeded (confirmed live:
+            # this exact TypeError - "Object of type Lock is not JSON
+            # serializable" - previously escaped this callback uncaught).
             _LOGGER.warning("Could not cache refreshed token to %s: %s", path, exc)
 
     client.set_token_fresh_cb(_cb)
@@ -125,10 +149,17 @@ async def _make_client(session: aiohttp.ClientSession) -> AidotClient:
     password = os.environ.get("AIDOT_PASSWORD")
 
     if token_file and os.path.exists(token_file):
-        token = await loop.run_in_executor(None, _read_token_file, token_file)
-        client = AidotClient(session=session, token=token)
-        _install_token_cache(client, token_file)
-        return client
+        try:
+            token = await loop.run_in_executor(None, _read_token_file, token_file)
+        except (OSError, ValueError) as exc:
+            # ValueError covers json.JSONDecodeError (empty/partial/corrupt
+            # cache). Fall through to the username/password path rather than
+            # crash CLI startup.
+            _LOGGER.warning("ignoring unreadable token cache %s: %s", token_file, exc)
+        else:
+            client = AidotClient(session=session, token=token)
+            _install_token_cache(client, token_file)
+            return client
 
     if not username or not password:
         sys.exit(
@@ -149,8 +180,10 @@ async def _make_client(session: aiohttp.ClientSession) -> AidotClient:
     if token_file:
         _install_token_cache(client, token_file)
         try:
-            await loop.run_in_executor(None, _write_token_file, token_file, client.login_info)
-        except OSError as exc:
+            await loop.run_in_executor(
+                None, _write_token_file, token_file, client.serializable_login_info()
+            )
+        except (OSError, TypeError) as exc:
             _LOGGER.warning("Could not seed token cache %s: %s", token_file, exc)
     return client
 

{python_aidot_cameras-0.11.1 → python_aidot_cameras-0.11.3}/aidot/camera/client.py

@@ -10,6 +10,10 @@ from typing import Any, Callable, List, Optional
 
 from ..exceptions import AidotCameraBusy, AidotCameraNotReady
 from ..login_const import APP_ID as _AIDOT_APP_ID
+from ..const import (
+    LOGIN_INFO_PERSISTENT_MQTT_KEY,
+    LOGIN_INFO_PERSISTENT_MQTT_LOCK_KEY,
+)
 
 # Wire/protocol constants live in constants.py; re-imported here so all
 # in-module references (and any external importers) keep resolving.
@@ -691,7 +695,9 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
         self._motion_active: bool = False
         self._motion_cb: Optional[Callable] = None
         self._motion_task: Optional["asyncio.Task[None]"] = None
-        self._motion_seen: set = set()
+        # Insertion-ordered set (dict keys) so the memory-bound trim can evict
+        # the OLDEST uids deterministically rather than arbitrary ones.
+        self._motion_seen: dict = {}
         self._motion_interval: float = 30.0
 
     # -- Pre-0.6 core API, kept for existing consumers ----------------------- #
@@ -1016,9 +1022,12 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
             if not mqtt_host:
                 # Fall back to the regional MQTT broker URL known to work from
                 # the AiDot web client: wss://{region}-mqtt.arnoo.com:8443/mqtt
+                # Redacted: `data`/`body` carries mqttPassword; log only the
+                # non-sensitive key names present, mirroring the hasPwd-style
+                # redaction of the debug log below.
                 _LOGGER.warning(
                     "getServerUrlConfig returned no mqttServerUrl; "
-                    "using regional fallback. body=%s", body
+                    "using regional fallback. keys=%s", sorted(data)
                 )
                 mqtt_host = f"wss://{self._region}-mqtt.arnoo.com:8443/mqtt"
 
@@ -2112,11 +2121,16 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                     return
             frame_event.set()
 
-        session = await self.async_open_webrtc_stream(
-            on_frame=_on_frame,
-            timeout=timeout,
-            status_callback=status_callback,
-        )
+        try:
+            session = await self.async_open_webrtc_stream(
+                on_frame=_on_frame,
+                timeout=timeout,
+                status_callback=status_callback,
+            )
+        except Exception as _snap_exc:
+            _LOGGER.error(
+                "async_snapshot DTLS failed for %s: %s", self.device_id, _snap_exc)
+            return False
         try:
             try:
                 await _asyncio.wait_for(frame_event.wait(), timeout=timeout)
@@ -2239,7 +2253,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
         if self._motion_task is not None and not self._motion_task.done():
             return
         self._motion_active = True
-        self._motion_seen = set()
+        self._motion_seen = {}
         self._motion_task = asyncio.ensure_future(self._motion_poll_loop(lookback_s))
 
     async def async_stop_motion_polling(self) -> None:
@@ -2269,7 +2283,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                     uid = it.get("eventUuid") or it.get("eventId") or it.get("recordId")
                     if not uid or uid in self._motion_seen:
                         continue
-                    self._motion_seen.add(uid)
+                    self._motion_seen[uid] = None
                     fresh.append(it)
                 if primed and fresh and self._motion_cb is not None:
                     for it in sorted(fresh, key=lambda x: x.get("eventTime") or 0):
@@ -2281,7 +2295,9 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                             _LOGGER.debug("motion callback raised", exc_info=True)
                 primed = True
                 if len(self._motion_seen) > 1000:  # bound memory
-                    self._motion_seen = set(list(self._motion_seen)[-400:])
+                    # Keep the 400 most-recent uids (insertion order), evicting
+                    # the oldest so still-in-window events stay deduplicated.
+                    self._motion_seen = dict.fromkeys(list(self._motion_seen)[-400:])
             except asyncio.CancelledError:
                 return
             except Exception as exc:
@@ -3096,7 +3112,12 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
         li = self._user_info if isinstance(getattr(self, "_user_info", None), dict) else None
         if li is None:
             return None
-        pm = li.get("_persistent_mqtt")
+        # These two keys are deliberately live runtime objects (a connection,
+        # its guarding lock), NOT persistable state - see
+        # RUNTIME_ONLY_LOGIN_INFO_KEYS and AidotClient.serializable_login_info(),
+        # which strips them before this shared dict is ever written to
+        # disk/config storage.
+        pm = li.get(LOGIN_INFO_PERSISTENT_MQTT_KEY)
         if pm is not None:
             return pm
         # Serialize get-or-create. Without this, two concurrent first-callers
@@ -3105,9 +3126,9 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
         # clobbering the first and orphaning a connection on the single-client_id
         # broker. dict.setdefault is atomic (no await between create and insert),
         # so every caller for this account shares the one lock.
-        lock = li.setdefault("_persistent_mqtt_lock", asyncio.Lock())
+        lock = li.setdefault(LOGIN_INFO_PERSISTENT_MQTT_LOCK_KEY, asyncio.Lock())
         async with lock:
-            pm = li.get("_persistent_mqtt")  # re-check under the lock
+            pm = li.get(LOGIN_INFO_PERSISTENT_MQTT_KEY)  # re-check under the lock
             if pm is not None:
                 return pm
             smarthome_auth = await self._async_get_smarthome_auth()
@@ -3119,7 +3140,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                 return None
             from .protocol import _PersistentMqtt
             pm = _PersistentMqtt(mqtt_url, mqtt_user, mqtt_pwd, client_id)
-            li["_persistent_mqtt"] = pm
+            li[LOGIN_INFO_PERSISTENT_MQTT_KEY] = pm
             return pm
 
     @staticmethod

{python_aidot_cameras-0.11.1 → python_aidot_cameras-0.11.3}/aidot/camera/lan_control.py

@@ -309,6 +309,10 @@ class CameraLanClient:
                                      "attr": [], "channel": "tcp", "ascNumber": asc},
                          "tst": int(time.time() * 1000), "deviceId": self.device_id})]
         replies = await self._session(build)
+        if not replies:
+            raise CameraLanError(
+                f"{self.device_id}: no reply to attribute query"
+            )
         return (replies[0].get("payload") or {}).get("attr") or {}
 
     async def async_set_attributes(self, attr: dict) -> bool:

{python_aidot_cameras-0.11.1 → python_aidot_cameras-0.11.3}/aidot/camera/playback.py

@@ -193,15 +193,18 @@ class CloudPlaybackSession:
             )
         except TimeoutError:
             _LOGGER.error("Cloud playback: login response timed out")
+            await self._cleanup()
             return False
         except Exception as exc:
             _LOGGER.error("Cloud playback: login read error: %s", exc)
+            await self._cleanup()
             return False
 
         if hdr["cmd"] != _CMD_LOGIN_RES:
             _LOGGER.error(
                 "Cloud playback: unexpected login response cmd=0x%04x", hdr["cmd"]
             )
+            await self._cleanup()
             return False
 
         try:
@@ -211,6 +214,7 @@ class CloudPlaybackSession:
                     "Cloud playback: login rejected code=%s body=%s",
                     body_obj.get("code"), body_obj,
                 )
+                await self._cleanup()
                 return False
         except (json.JSONDecodeError, ValueError):
             pass  # some firmware sends no JSON body - treat as success
@@ -292,6 +296,13 @@ class CloudPlaybackSession:
             else:
                 _LOGGER.warning("Cloud playback: unexpected stream result=%d", result)
 
+        # Loop exited on end-of-stream or a receive error/timeout (not via an
+        # external stop(), which cancels this task and owns its own teardown).
+        # Tear down here so the heartbeat loop wakes to a closed writer and
+        # exits, and the socket is not left open until stop() is called.
+        self._running = False
+        await self._cleanup()
+
     async def start(self) -> bool:
         self._running = True
         if not await self._connect_and_login():
@@ -326,12 +337,19 @@ class CloudPlaybackSession:
                     pass
         self._hb_task = None
         self._rx_task = None
+        await self._cleanup()
+
+    async def _cleanup(self) -> None:
+        # Close the TCP writer and drop the reader/writer refs. Nulling the
+        # writer makes a subsequent stop() (or a second call) a safe no-op, so
+        # this is the single teardown path shared by the login-failure returns,
+        # the receive-loop exit, and stop().
         if self._writer is not None:
             try:
                 self._writer.close()
                 await self._writer.wait_closed()
             except Exception:
-                _LOGGER.debug("swallowed exception in %s", 'stop', exc_info=True)
+                _LOGGER.debug("swallowed exception in %s", '_cleanup', exc_info=True)
             self._writer = None
             self._reader = None
 

{python_aidot_cameras-0.11.1 → python_aidot_cameras-0.11.3}/aidot/camera/sdes_open.py

@@ -672,6 +672,15 @@ class _SdesOpenMixin:
                 # proceed rather than abort on a code we can't classify as terminal
                 # (genuine terminal rejects are still caught on the webrtcResp ack).
                 if _lp_on_sdes == 0:
+                    # Match the sibling raises: close the reserved sockets and
+                    # signal the MQTT thread before propagating.  (No sdp_path
+                    # unlink here - it is not created until later, below.)
+                    for _rsock in (_audio_sock, _video_sock):
+                        try:
+                            _rsock.close()
+                        except Exception:
+                            _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_bridge_fn', exc_info=True)
+                    outgoing_q.put_nowait(None)   # stop MQTT thread
                     raise RuntimeError(
                         f"livePlay refused by camera (livePlay=0, code={_lp_code_sdes})")
                 elif _lp_code_sdes not in (0, 200):
@@ -3604,6 +3613,12 @@ class _SdesOpenMixin:
                             stdout=subprocess.DEVNULL,
                             stderr=subprocess.PIPE,
                         )
+                        # Point the shared holder at the live proc immediately.
+                        # The bridge thread polls _proc_holder[0]; if it still
+                        # sees the terminated old proc it logs "stream ended",
+                        # breaks, and closes the loopback sockets - starving the
+                        # restarted ffmpeg (0-frame stream).
+                        _proc_holder[0] = proc
                         _status("ffmpeg restarted with camera's SRTP keys")
         except TimeoutError:
             if _cam_echo_received:

{python_aidot_cameras-0.11.1 → python_aidot_cameras-0.11.3}/aidot/camera/webrtc_open.py

@@ -1156,6 +1156,7 @@ class _WebRTCOpenMixin:
                     # transient on battery cameras and recover via ICE; abort
                     # there would spuriously kill otherwise-good streams.
                     if _lp_on == 0:
+                        outgoing_q.put_nowait(None)   # stop MQTT thread (avoid orphan)
                         raise RuntimeError(
                             f"livePlay refused by camera (livePlay=0, code={_lp_code})"
                         )
@@ -1207,6 +1208,7 @@ class _WebRTCOpenMixin:
                     _lp_code2 = int(_lp_resp2.get("code", 200))
                     _lp_on2   = int(_lp_resp2.get("livePlay", 1))
                     if _lp_on2 == 0:
+                        outgoing_q.put_nowait(None)   # stop MQTT thread (avoid orphan)
                         raise RuntimeError(
                             f"livePlay refused by camera (livePlay=0, code={_lp_code2})"
                         )
@@ -3210,6 +3212,7 @@ class _WebRTCOpenMixin:
                 # encoder is still cold.  Tear down and raise so the serve loop
                 # fast-retries in a bounded burst instead of letting DTLS
                 # co-fail into the full 15s-gated generic retry.
+                outgoing_q.put_nowait(None)   # stop MQTT thread (avoid orphan)
                 try:
                     await pc.close()
                 except Exception:

{python_aidot_cameras-0.11.1 → python_aidot_cameras-0.11.3}/aidot/client.py

@@ -38,6 +38,9 @@ from .const import (
     SUPPORTED_COUNTRYS,
     DEFAULT_COUNTRY_CODE,
     CONF_IS_OWNER,
+    LOGIN_INFO_PERSISTENT_MQTT_KEY,
+    LOGIN_INFO_PERSISTENT_MQTT_LOCK_KEY,
+    RUNTIME_ONLY_LOGIN_INFO_KEYS,
     ServerErrorCode,
 )
 
@@ -346,6 +349,28 @@ class AidotClient:
                 raise AidotAuthFailed
             return None
 
+    def serializable_login_info(self) -> dict[str, Any]:
+        """A JSON-safe copy of ``login_info`` for persisting to disk/config storage.
+
+        ``login_info`` doubles as the account-shared cache for the
+        persistent-MQTT connection and its guarding ``asyncio.Lock`` (see
+        ``camera/client.py``'s ``_get_persistent_mqtt``, which reads/writes
+        this identical dict object via ``DeviceClient._user_info``) - live
+        runtime objects that raise ``TypeError: Object of type Lock is not
+        JSON serializable`` if ever handed to ``json.dump`` directly.
+        Confirmed live: a token-refresh callback that persisted the raw
+        ``login_info`` dict hit exactly this once a persistent MQTT
+        connection was active (the default since 2026-06-17).
+
+        Anything that persists ``login_info`` - this library's own
+        standalone CLI, or an integration's config-entry storage - should
+        call this instead of serializing ``login_info`` directly.
+        """
+        return {
+            k: v for k, v in self.login_info.items()
+            if k not in RUNTIME_ONLY_LOGIN_INFO_KEYS
+        }
+
     async def async_ensure_token(self) -> bool:
         """Force a fresh access token for camera/smarthome HTTP calls.
 
@@ -544,7 +569,12 @@ class AidotClient:
         # Close the account-shared persistent MQTT connection, if one was opened
         # (AIDOT_PERSISTENT_MQTT). Stored on the shared login_info by the camera
         # command/attr paths; closing here stops its background paho loop.
-        pm = self.login_info.pop("_persistent_mqtt", None) if isinstance(self.login_info, dict) else None
+        pm = None
+        if isinstance(self.login_info, dict):
+            pm = self.login_info.pop(LOGIN_INFO_PERSISTENT_MQTT_KEY, None)
+            # Also drop the lock so the asyncio.Lock does not linger on the
+            # account-shared login_info after close.
+            self.login_info.pop(LOGIN_INFO_PERSISTENT_MQTT_LOCK_KEY, None)
         if pm is not None:
             try:
                 pm.close()

{python_aidot_cameras-0.11.1 → python_aidot_cameras-0.11.3}/aidot/const.py

@@ -230,6 +230,21 @@ class ServerErrorCode(IntEnum):
     USER_PWD_INCORRECT = 560080
 
 
+# AidotClient.login_info is also used as the account-shared cache for the
+# persistent-MQTT connection + its guarding asyncio.Lock (see
+# camera/client.py's _get_persistent_mqtt: one connection per account,
+# looked up on this same shared dict via DeviceClient._user_info - the
+# identical object, not a copy). Those are live runtime objects, never
+# persistable state. Anything that serializes login_info to disk (this
+# library's own standalone CLI, or an integration's config-entry storage)
+# must exclude these keys first - see AidotClient.serializable_login_info().
+LOGIN_INFO_PERSISTENT_MQTT_KEY = "_persistent_mqtt"
+LOGIN_INFO_PERSISTENT_MQTT_LOCK_KEY = "_persistent_mqtt_lock"
+RUNTIME_ONLY_LOGIN_INFO_KEYS = frozenset(
+    {LOGIN_INFO_PERSISTENT_MQTT_KEY, LOGIN_INFO_PERSISTENT_MQTT_LOCK_KEY}
+)
+
+
 # -- Cloud API credentials ---------------------------------------------------- #
 
 from .login_const import APP_ID  # noqa: E402, F401 - back-compat re-export

{python_aidot_cameras-0.11.1 → python_aidot_cameras-0.11.3}/pyproject.toml

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

{python_aidot_cameras-0.11.1 → python_aidot_cameras-0.11.3/python_aidot_cameras.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.11.1
+Version: 0.11.3
 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
@@ -94,10 +94,18 @@ pipx install "python-aidot-cameras[webrtc]"
 # or:
 uv tool install "python-aidot-cameras[webrtc]"
 
+export AIDOT_USERNAME=... AIDOT_PASSWORD=...   # or AIDOT_TOKEN_FILE, see below
 aidot-go2rtc --list                  # discover cameras + their transport
 aidot-go2rtc <device_id> '{output}'  # stream one camera (as a go2rtc exec: source)
 ```
 
+Authenticates via `AIDOT_USERNAME`/`AIDOT_PASSWORD` (`AIDOT_COUNTRY`, default
+`US`) - a dedicated login is recommended for long-running standalone use, so
+it doesn't fight Home Assistant over a shared rotating refresh token. Set
+`AIDOT_TOKEN_FILE=/path/to/token.json` to cache the login across restarts;
+token rotations are written back automatically. Run `aidot-go2rtc --help` for
+the full list of authentication and stream env vars.
+
 ## Usage
 
 Open a live WebRTC stream from a camera device client:
@@ -159,7 +167,7 @@ audio, idle release, the sprop cache path) are documented in
 | `AIDOT_SDES_ADAPTIVE` | Adaptive fast-with-fallback for the SDES keepalive loop: try the fast path first 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. Truthy value enables. | unset (off) |
 | `AIDOT_SDES_FAST_LIVEPLAY` | Don't block on the `livePlayResp` wait for eligible SDES cameras (~4.5 s faster cold start). Role-reversal models (A001064 PTZ) always excluded for correctness. **On by default**; set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
 | `AIDOT_DTLS_FAST_LIVEPLAY` | The DTLS (A000088) analogue: skip the `livePlayReq`-echo and `livePlayResp` waits (the dominant LAN cold-start cost) while keeping the full ICE/TURN/DTLS handshake, so remote/relay viewing is unaffected. **On by default**; set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
-| `AIDOT_PERSISTENT_MQTT` | Reuse ONE account-level persistent MQTT connection for commands, attribute fetches, and stream-open signaling (matching the official app) instead of connecting per operation. **On by default** (live soak cut SDES NO_MEDIA ~57%->~19%); set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
+| `AIDOT_PERSISTENT_MQTT` | Reuse ONE account-level persistent MQTT connection for commands, attribute fetches, and stream-open signaling (matching the official app) instead of connecting per operation. **On by default** (live soaks cut SDES NO_MEDIA from ~57% to ~11-19%); set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
 | `AIDOT_SERVE_RELAY` | Hold 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_LIVESTREAM_PARAM` | Set to `0` to skip the cloud `liveStreamParam` pre-connect that provisions battery cameras' live-stream sessions before signaling (without it, battery cameras like the L2 models reject streaming with `-50019`). | `1` (enabled) |
 

{python_aidot_cameras-0.11.1 → python_aidot_cameras-0.11.3}/python_aidot_cameras.egg-info/SOURCES.txt

@@ -108,6 +108,7 @@ tests/test_sdes_sprop.py
 tests/test_sdes_talk.py
 tests/test_sdes_watchdog.py
 tests/test_security_hardening.py
+tests/test_serializable_login_info.py
 tests/test_serve_relay.py
 tests/test_session_stats.py
 tests/test_speak.py
@@ -116,5 +117,6 @@ tests/test_stream_idle.py
 tests/test_stream_teardown.py
 tests/test_talk.py
 tests/test_terminal_ack.py
+tests/test_token_file_robustness.py
 tests/test_token_refresh.py
 tests/test_wait_or_event.py

{python_aidot_cameras-0.11.1 → python_aidot_cameras-0.11.3}/tests/test_lan_control.py

@@ -80,3 +80,23 @@ def test_network_helpers_are_callable():
     assert inspect.iscoroutinefunction(discover_subnet)
     sig = inspect.signature(discover_subnet)
     assert list(sig.parameters) == ["cidr24", "timeout", "concurrency"]
+
+
+def test_get_attributes_empty_replies_raises_lanerror():
+    # If the camera accepts login but never answers getDevAttrReq (read timeout),
+    # _session returns [] - async_get_attributes must raise CameraLanError (the
+    # contract callers rely on for cloud fallback), not an unguarded IndexError.
+    import asyncio
+
+    c = CameraLanClient(DEVICE, USER, ip="192.0.2.10")
+
+    async def _empty(_build):
+        return []
+
+    c._session = _empty
+
+    async def _go():
+        with pytest.raises(CameraLanError):
+            await c.async_get_attributes()
+
+    asyncio.run(_go())

{python_aidot_cameras-0.11.1 → python_aidot_cameras-0.11.3}/tests/test_motion_poll.py

@@ -24,7 +24,7 @@ class _FakeDC:
         self._call = 0
         self._motion_active = True
         self._motion_cb = None
-        self._motion_seen = set()
+        self._motion_seen: dict = {}  # insertion-ordered set (dict keys); see CameraMixin
         self._motion_interval = 0.01  # fast for the test
 
     async def async_get_cloud_recordings(self, *a, **k):

python_aidot_cameras-0.11.3/tests/test_serializable_login_info.py

@@ -0,0 +1,82 @@
+"""Regression test for a live bug: AidotClient.login_info doubles as the
+account-shared cache for the persistent-MQTT connection and its guarding
+asyncio.Lock (camera/client.py's _get_persistent_mqtt), so anything that
+json.dumps login_info directly - once a persistent MQTT connection has been
+created (the default since 2026-06-17) - hits
+"TypeError: Object of type Lock is not JSON serializable".
+
+Confirmed live (2026-07-07): a standalone aidot-go2rtc run's token-refresh
+callback threw exactly this while persisting client.login_info to disk.
+serializable_login_info() is the fix: a JSON-safe view that excludes the
+known runtime-only keys.
+"""
+import asyncio
+import json
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from aidot.client import AidotClient
+from aidot.const import (
+    LOGIN_INFO_PERSISTENT_MQTT_KEY,
+    LOGIN_INFO_PERSISTENT_MQTT_LOCK_KEY,
+    RUNTIME_ONLY_LOGIN_INFO_KEYS,
+)
+
+
+def _client_with_login_info(extra: dict) -> AidotClient:
+    c = AidotClient.__new__(AidotClient)
+    c.login_info = {
+        "id": "u1",
+        "accessToken": "tok",
+        "refreshToken": "rtok",
+        "mqttPassword": "mp",
+        **extra,
+    }
+    return c
+
+
+def test_serializable_login_info_strips_runtime_keys():
+    c = _client_with_login_info({
+        LOGIN_INFO_PERSISTENT_MQTT_LOCK_KEY: asyncio.Lock(),
+        LOGIN_INFO_PERSISTENT_MQTT_KEY: object(),  # stand-in for a live _PersistentMqtt
+    })
+    result = c.serializable_login_info()
+    assert LOGIN_INFO_PERSISTENT_MQTT_KEY not in result
+    assert LOGIN_INFO_PERSISTENT_MQTT_LOCK_KEY not in result
+    # Everything else survives unchanged.
+    assert result == {
+        "id": "u1", "accessToken": "tok", "refreshToken": "rtok",
+        "mqttPassword": "mp",
+    }
+
+
+def test_serializable_login_info_is_actually_json_dumpable():
+    # The exact failure mode this fixes: json.dumps on the raw dict must
+    # raise, but on the filtered view it must not.
+    c = _client_with_login_info({
+        LOGIN_INFO_PERSISTENT_MQTT_LOCK_KEY: asyncio.Lock(),
+    })
+    try:
+        json.dumps(c.login_info)
+        raise AssertionError("expected TypeError serializing the raw login_info")
+    except TypeError:
+        pass
+    json.dumps(c.serializable_login_info())  # must not raise
+
+
+def test_serializable_login_info_noop_when_no_runtime_keys_present():
+    # Common case (no persistent-MQTT connection created yet): unaffected.
+    c = _client_with_login_info({})
+    assert c.serializable_login_info() == c.login_info
+
+
+def test_runtime_only_keys_constant_matches_persistent_mqtt_key_names():
+    # Locks the two literal key names camera/client.py's _get_persistent_mqtt
+    # actually writes (see LOGIN_INFO_PERSISTENT_MQTT_KEY /
+    # LOGIN_INFO_PERSISTENT_MQTT_LOCK_KEY) against the shared frozenset, so a
+    # rename on one side without the other can't silently reopen this bug.
+    assert RUNTIME_ONLY_LOGIN_INFO_KEYS == {
+        LOGIN_INFO_PERSISTENT_MQTT_KEY, LOGIN_INFO_PERSISTENT_MQTT_LOCK_KEY,
+    }

python_aidot_cameras-0.11.3/tests/test_token_file_robustness.py

@@ -0,0 +1,43 @@
+"""Tests for the standalone CLI's token-cache read/write robustness.
+
+Covers the 0.11.3 fixes: the token file is written atomically at 0600 (a
+serialization failure must not truncate a previously-valid token), and a
+corrupt/partial cache is a caught ValueError (so _make_client can fall back
+to username/password login instead of crashing).
+"""
+import os
+import stat
+
+import pytest
+
+from aidot.__main__ import _read_token_file, _write_token_file
+
+
+def test_write_token_file_round_trips_and_is_0600(tmp_path):
+    p = tmp_path / "token.json"
+    _write_token_file(str(p), {"accessToken": "abc", "id": "u1"})
+    assert _read_token_file(str(p)) == {"accessToken": "abc", "id": "u1"}
+    assert stat.S_IMODE(os.stat(p).st_mode) == 0o600
+
+
+def test_write_token_file_preserves_previous_on_serialization_failure(tmp_path):
+    p = tmp_path / "token.json"
+    _write_token_file(str(p), {"accessToken": "good"})  # seed a valid token
+
+    # A set is not JSON-serializable, so json.dump raises mid-write. The atomic
+    # temp-then-replace write must leave the previously-valid token untouched.
+    with pytest.raises(TypeError):
+        _write_token_file(str(p), {"broken": {1, 2, 3}})
+
+    assert _read_token_file(str(p)) == {"accessToken": "good"}
+    # And it must not leave a stray temp file behind.
+    assert [f for f in os.listdir(tmp_path) if f.startswith(".token-")] == []
+
+
+def test_read_token_file_raises_valueerror_on_corrupt(tmp_path):
+    p = tmp_path / "token.json"
+    p.write_text("{ not valid json", encoding="utf-8")
+    # json.JSONDecodeError is a subclass of ValueError - the exact type
+    # _make_client catches to fall back to password login rather than crash.
+    with pytest.raises(ValueError):
+        _read_token_file(str(p))