python-aidot-cameras 0.11.0__tar.gz → 0.11.2__tar.gz

{python_aidot_cameras-0.11.0/python_aidot_cameras.egg-info → python_aidot_cameras-0.11.2}/PKG-INFO

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

{python_aidot_cameras-0.11.0 → python_aidot_cameras-0.11.2}/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:

{python_aidot_cameras-0.11.0 → python_aidot_cameras-0.11.2}/aidot/__main__.py

@@ -102,9 +102,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)
@@ -149,8 +157,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.0 → python_aidot_cameras-0.11.2}/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.
@@ -86,6 +90,13 @@ from .protocol import (  # noqa: F401 - re-exported for device_client / back-com
 
 _LOGGER = logging.getLogger(__name__)
 
+# Offline keepalive pause (see CameraMixin._backoff_or_offline_pause): while the
+# cloud explicitly reports a device offline, failed-open retries re-check the
+# flag every RECHECK seconds and only probe a real open every PROBE seconds,
+# instead of consuming an open-gate slot on the normal reconnect cadence.
+_OFFLINE_RECHECK_S = float(os.environ.get("AIDOT_OFFLINE_RECHECK_S", "30"))
+_OFFLINE_PROBE_S = float(os.environ.get("AIDOT_OFFLINE_PROBE_S", "600"))
+
 # Strong refs to fire-and-forget tasks: asyncio only keeps weak refs, so a
 # discarded task can be garbage-collected mid-flight. Discarded on completion.
 _BG_TASKS: set = set()
@@ -761,8 +772,56 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
             self.status.update_from_camera_attributes(props)
         if device.get("online") is not None:
             self.status.online = bool(device.get("online"))
+            # The cloud explicitly reported reachability - only then may the
+            # keepalive loops trust an offline flag (see
+            # _backoff_or_offline_pause; DeviceStatusData.online defaults to
+            # False, which must not read as "offline").
+            self._cloud_online_explicit = True
         return self.status
 
+    async def _backoff_or_offline_pause(self, delay: float) -> None:
+        """Sleep a reconnect backoff, extended while the device is cloud-offline.
+
+        Normal case (device online, or the cloud never reported an online
+        flag): plain ``asyncio.sleep(delay)`` - behavior unchanged.
+
+        When an open just failed AND the cloud has explicitly reported the
+        device offline (``update_status_from_device`` saw ``online: false``),
+        hold here instead of retrying on the pacer cadence: re-check the flag
+        every ``AIDOT_OFFLINE_RECHECK_S`` (default 30 s) and resume the moment
+        it flips back on, or fall through after ``AIDOT_OFFLINE_PROBE_S``
+        (default 600 s) so one probe open still runs in case the cloud flag is
+        stale.  This keeps a dead/unpowered camera from consuming an open-gate
+        slot every backoff cycle and starving live cameras' cold opens
+        (observed live: two unpowered A000088s cycling 30 s open attempts
+        pushed a healthy camera's cold open past two minutes).
+        """
+        if self.status.online or not getattr(self, "_cloud_online_explicit", False):
+            await asyncio.sleep(delay)
+            return
+        _LOGGER.info(
+            "keepalive[%s]: device is cloud-offline - pausing open retries "
+            "(recheck %.0fs, probe %.0fs)",
+            self.device_id, _OFFLINE_RECHECK_S, _OFFLINE_PROBE_S,
+        )
+        _t0 = time.monotonic()
+        while (_elapsed := time.monotonic() - _t0) < _OFFLINE_PROBE_S:
+            await asyncio.sleep(
+                min(_OFFLINE_RECHECK_S, max(0.1, _OFFLINE_PROBE_S - _elapsed))
+            )
+            if not getattr(self, "_streaming_active", False):
+                return
+            if self.status.online:
+                _LOGGER.info(
+                    "keepalive[%s]: device back online - resuming opens",
+                    self.device_id,
+                )
+                return
+        _LOGGER.debug(
+            "keepalive[%s]: offline probe interval elapsed - probing one open",
+            self.device_id,
+        )
+
     # -- Camera helpers ------------------------------------------------------ #
 
     @property
@@ -2560,7 +2619,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                     self.device_id, _delay, exc,
                 )
                 try:
-                    await asyncio.sleep(_delay)
+                    await self._backoff_or_offline_pause(_delay)
                 except asyncio.CancelledError:
                     return
                 continue
@@ -2735,7 +2794,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                     self.device_id, _delay, exc,
                 )
                 try:
-                    await asyncio.sleep(_delay)
+                    await self._backoff_or_offline_pause(_delay)
                 except asyncio.CancelledError:
                     return
                 continue
@@ -3041,7 +3100,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
@@ -3050,9 +3114,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()
@@ -3064,7 +3128,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
@@ -3231,7 +3295,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                     self.device_id, _delay, exc,
                 )
                 try:
-                    await asyncio.sleep(_delay)
+                    await self._backoff_or_offline_pause(_delay)
                 except asyncio.CancelledError:
                     return
                 continue

{python_aidot_cameras-0.11.0 → python_aidot_cameras-0.11.2}/aidot/client.py

@@ -38,6 +38,7 @@ from .const import (
     SUPPORTED_COUNTRYS,
     DEFAULT_COUNTRY_CODE,
     CONF_IS_OWNER,
+    RUNTIME_ONLY_LOGIN_INFO_KEYS,
     ServerErrorCode,
 )
 
@@ -346,6 +347,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.
 

{python_aidot_cameras-0.11.0 → python_aidot_cameras-0.11.2}/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.0 → python_aidot_cameras-0.11.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-aidot-cameras"
-version = "0.11.0"
+version = "0.11.2"
 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.0 → python_aidot_cameras-0.11.2/python_aidot_cameras.egg-info}/PKG-INFO

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

{python_aidot_cameras-0.11.0 → python_aidot_cameras-0.11.2}/python_aidot_cameras.egg-info/SOURCES.txt

@@ -91,6 +91,7 @@ tests/test_live_stream_param.py
 tests/test_motion_poll.py
 tests/test_narrow_pc_ice.py
 tests/test_no_undefined_names.py
+tests/test_offline_keepalive_pause.py
 tests/test_open_gate_delay.py
 tests/test_persistent_mqtt.py
 tests/test_persistent_mqtt_robustness.py
@@ -107,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

python_aidot_cameras-0.11.2/tests/test_offline_keepalive_pause.py

@@ -0,0 +1,112 @@
+"""Offline keepalive pause: failed-open retries hold while the device is
+cloud-offline (CameraMixin._backoff_or_offline_pause) instead of consuming an
+open-gate slot on the normal reconnect cadence."""
+
+import asyncio
+import time
+from types import SimpleNamespace
+
+import aidot.camera.client as camera_client
+from aidot.camera.client import CameraMixin
+from aidot.device_client import DeviceStatusData
+
+
+def _stub(online: bool, explicit: bool, streaming: bool = True) -> SimpleNamespace:
+    s = SimpleNamespace(
+        status=DeviceStatusData(),
+        device_id="test-device",
+        _streaming_active=streaming,
+    )
+    s.status.online = online
+    if explicit:
+        s._cloud_online_explicit = True
+    return s
+
+
+def _run(coro):
+    return asyncio.run(coro)
+
+
+def test_online_device_sleeps_plain_delay():
+    stub = _stub(online=True, explicit=True)
+    t0 = time.monotonic()
+    _run(CameraMixin._backoff_or_offline_pause(stub, 0.05))
+    took = time.monotonic() - t0
+    assert 0.04 <= took < 1.0
+
+
+def test_unreported_online_state_never_pauses(monkeypatch):
+    # DeviceStatusData.online defaults to False; without the explicit marker
+    # that must NOT read as "offline" (a long pause here would slow every
+    # camera whose device dict was never merged).
+    monkeypatch.setattr(camera_client, "_OFFLINE_PROBE_S", 60.0)
+    stub = _stub(online=False, explicit=False)
+    t0 = time.monotonic()
+    _run(CameraMixin._backoff_or_offline_pause(stub, 0.05))
+    took = time.monotonic() - t0
+    assert took < 1.0
+
+
+def test_offline_device_holds_then_probes(monkeypatch):
+    # Explicitly offline: the pause holds past the plain delay and falls
+    # through after the probe interval so one probe open still runs.
+    monkeypatch.setattr(camera_client, "_OFFLINE_RECHECK_S", 0.05)
+    monkeypatch.setattr(camera_client, "_OFFLINE_PROBE_S", 0.3)
+    stub = _stub(online=False, explicit=True)
+    t0 = time.monotonic()
+    _run(CameraMixin._backoff_or_offline_pause(stub, 0.01))
+    took = time.monotonic() - t0
+    assert took >= 0.3  # held for the whole probe interval
+    assert took < 2.0
+
+
+def test_offline_device_resumes_when_back_online(monkeypatch):
+    monkeypatch.setattr(camera_client, "_OFFLINE_RECHECK_S", 0.05)
+    monkeypatch.setattr(camera_client, "_OFFLINE_PROBE_S", 30.0)
+    stub = _stub(online=False, explicit=True)
+
+    async def scenario():
+        async def flip():
+            await asyncio.sleep(0.15)
+            stub.status.online = True
+
+        t0 = time.monotonic()
+        await asyncio.gather(
+            CameraMixin._backoff_or_offline_pause(stub, 0.01), flip()
+        )
+        return time.monotonic() - t0
+
+    took = _run(scenario())
+    # resumed within a couple of recheck ticks of the flip, far short of PROBE
+    assert 0.15 <= took < 2.0
+
+
+def test_offline_pause_exits_when_streaming_stops(monkeypatch):
+    monkeypatch.setattr(camera_client, "_OFFLINE_RECHECK_S", 0.05)
+    monkeypatch.setattr(camera_client, "_OFFLINE_PROBE_S", 30.0)
+    stub = _stub(online=False, explicit=True)
+
+    async def scenario():
+        async def stop():
+            await asyncio.sleep(0.15)
+            stub._streaming_active = False
+
+        t0 = time.monotonic()
+        await asyncio.gather(
+            CameraMixin._backoff_or_offline_pause(stub, 0.01), stop()
+        )
+        return time.monotonic() - t0
+
+    took = _run(scenario())
+    assert took < 2.0
+
+
+def test_update_status_sets_explicit_marker():
+    stub = SimpleNamespace(status=DeviceStatusData())
+    CameraMixin.update_status_from_device(stub, {"online": False})
+    assert stub.status.online is False
+    assert getattr(stub, "_cloud_online_explicit", False) is True
+
+    stub2 = SimpleNamespace(status=DeviceStatusData())
+    CameraMixin.update_status_from_device(stub2, {"name": "no online key"})
+    assert getattr(stub2, "_cloud_online_explicit", False) is False

python_aidot_cameras-0.11.2/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,
+    }