python-aidot-cameras 0.11.9__tar.gz → 0.11.11__tar.gz

{python_aidot_cameras-0.11.9/python_aidot_cameras.egg-info → python_aidot_cameras-0.11.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.11.9
+Version: 0.11.11
 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.11.11/aidot/__init__.py

@@ -0,0 +1,54 @@
+"""AiDot camera and device library."""
+
+import logging as _logging
+
+from .client import AidotClient
+from .device_client import DeviceClient
+from .discover import Discover
+from .exceptions import (
+    AidotAuthFailed,
+    AidotAuthTokenExpired,
+    AidotCameraBusy,
+    AidotError,
+    AidotNotLogin,
+    AidotOSError,
+    AidotUserOrPassIncorrect,
+    HTTPError,
+    InvalidHost,
+    InvalidURL,
+)
+
+# Cap the per-packet loggers that flood the log at DEBUG.  When a user enables
+# DEBUG on the parent ``aidot`` logger to diagnose the integration, these emit
+# thousands of lines per second (in one capture, 99% of all lines) - and on a
+# microSD Home Assistant host that log I/O can starve the recorder.  Cap them at
+# INFO so enabling ``aidot`` DEBUG stays useful; the diagnostically valuable
+# DEBUG (DTLS, SCTP/DCEP, ICE connection state) still flows.  This covers both the
+# vendored aiortc RTP receiver/sender AND the external ``aioice`` package's
+# per-STUN/TURN-packet loggers (aioice is a real dependency, not vendored, so it
+# is not under ``aidot._vendor``).  Respect an explicit level if the user set one.
+for _chatty in (
+    "aidot._vendor.aiortc.rtcrtpreceiver",
+    "aidot._vendor.aiortc.rtcrtpsender",
+    "aioice.ice",
+    "aioice.turn",
+):
+    _lg = _logging.getLogger(_chatty)
+    if _lg.level == _logging.NOTSET:
+        _lg.setLevel(_logging.INFO)
+
+__all__ = [
+    "AidotAuthFailed",
+    "AidotAuthTokenExpired",
+    "AidotCameraBusy",
+    "AidotClient",
+    "AidotError",
+    "AidotNotLogin",
+    "AidotOSError",
+    "AidotUserOrPassIncorrect",
+    "DeviceClient",
+    "Discover",
+    "HTTPError",
+    "InvalidHost",
+    "InvalidURL",
+]

{python_aidot_cameras-0.11.9 → python_aidot_cameras-0.11.11}/aidot/camera/protocol.py

@@ -79,6 +79,13 @@ def _build_stun_binding_success_response(
 
 _WEBRTC_TERMINAL_ACK_CODES = (-50002, -50015)
 
+# If a post-connect MQTT drop stays disconnected longer than this (seconds) with
+# no successful paho reconnect, the receive loop ends the session rather than
+# polling a dead socket until the full duration deadline.  Long enough to ride
+# out an ordinary network blip + paho's auto-reconnect, short enough that a
+# terminal drop (session taken over, revoked creds, broker gone) fails fast.
+_MQTT_RECONNECT_GRACE = 20.0
+
 
 def _terminal_webrtc_ack(msg: dict):
     """Return ``(code, desc)`` if ``msg`` is a webrtcResp carrying a TERMINAL ack
@@ -1188,7 +1195,8 @@ def _mqtt_session_sync(
 
     msg_q   = _queue.Queue()
     conn_ev = threading.Event()
-    status  = {"connected": False, "rc": None, "rc_str": "", "error": None, "log": []}
+    status  = {"connected": False, "rc": None, "rc_str": "", "error": None,
+               "log": [], "disconnected_since": None}
 
     # Build client - handle paho >=2.0 (VERSION2) and <2.0
     try:
@@ -1217,6 +1225,9 @@ def _mqtt_session_sync(
         status["rc"]        = rc
         status["rc_str"]    = str(reason_code)
         if rc == 0:
+            # Successful (re)connect: a prior drop (if any) has recovered, so the
+            # receive loop must not fail it fast - clear the disconnect marker.
+            status["disconnected_since"] = None
             # (Re)subscribe on EVERY successful connect.  paho's loop_start
             # auto-reconnects after a transient drop, but with clean_session the
             # broker retains no subscriptions, so a reconnected client would be
@@ -1250,14 +1261,21 @@ def _mqtt_session_sync(
             conn_ev.set()
             msg_q.put(None)   # sentinel: end the receive loop
             return
-        # Already connected once: this is a transient drop.  paho's loop_start
-        # auto-reconnects and _on_connect re-subscribes, so DON'T end the receive
-        # loop here - a broker blip must not tear down a long-lived stream's
-        # signaling (the non-persistent transport runs one session for the whole
-        # stream).  A real teardown ends the loop via the outgoing-queue None
-        # sentinel or the duration deadline instead.
+        # Already connected once: this is (so far) a transient drop.  paho's
+        # loop_start auto-reconnects and _on_connect re-subscribes AND clears
+        # disconnected_since, so a brief blip must NOT tear down a long-lived
+        # stream's signaling (the non-persistent transport runs one session for
+        # the whole stream).  But a drop that never recovers - session taken over
+        # (rc=142) when the account's persistent client reclaims the clientId,
+        # revoked creds, broker gone - would otherwise leave the receive loop
+        # polling a dead socket until the full duration deadline.  Record when the
+        # drop began; the loop ends the session once it has persisted past
+        # _MQTT_RECONNECT_GRACE.  (dict single-key set/get is atomic under the GIL,
+        # so no lock is needed across the paho thread and the receive loop.)
+        if status.get("disconnected_since") is None:
+            status["disconnected_since"] = time.monotonic()
         _LOGGER.debug(
-            "_mqtt_session: transient disconnect rc=%s (paho will reconnect)",
+            "_mqtt_session: disconnect rc=%s (awaiting paho reconnect)",
             reason_code,
         )
 
@@ -1327,6 +1345,18 @@ def _mqtt_session_sync(
         remaining = deadline - _time.monotonic()
         if remaining <= 0:
             break
+        # End the session if a post-connect drop never recovered: a terminal
+        # disconnect delivers no further messages, so without this the loop would
+        # poll a dead socket (and the caller's camera signaling would silently
+        # stall) until the full duration deadline.
+        _ds = status.get("disconnected_since")
+        if _ds is not None and (_time.monotonic() - _ds) > _MQTT_RECONNECT_GRACE:
+            _LOGGER.warning(
+                "_mqtt_session: MQTT disconnected >%.0fs with no reconnect "
+                "(rc=%s) - ending session; camera signaling can no longer arrive",
+                _MQTT_RECONNECT_GRACE, status.get("rc_str"),
+            )
+            break
         try:
             item = msg_q.get(timeout=min(remaining, 0.1))
         except _queue.Empty:

{python_aidot_cameras-0.11.9 → python_aidot_cameras-0.11.11}/aidot/camera/webrtc_open.py

@@ -1284,8 +1284,11 @@ class _WebRTCOpenMixin:
         # ------------------------------------------------------------------ #
         # aiortc peer connection (DTLS-SRTP path)
         # ------------------------------------------------------------------ #
-        import logging as _logging_dtls
-        _logging_dtls.getLogger("aioice").setLevel(_logging_dtls.DEBUG)
+        # NOTE: do NOT force aioice to DEBUG here.  It floods the log on every DTLS
+        # open, and the package-init cap (aidot/__init__.py) holds aioice.ice /
+        # aioice.turn at INFO anyway, so forcing DEBUG was both self-defeating and
+        # noisy.  To debug ICE, set the aioice logger level explicitly (that
+        # overrides the NOTSET-guarded cap).
         from aidot._vendor.aiortc import RTCConfiguration, RTCIceServer
 
         def _sanitize_ice_uris(uris):

{python_aidot_cameras-0.11.9 → python_aidot_cameras-0.11.11}/pyproject.toml

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.11.9
+Version: 0.11.11
 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.11.11/tests/test_logging_caps.py

@@ -0,0 +1,31 @@
+"""Importing the library caps the chatty per-packet loggers.
+
+aiortc's RTP receiver/sender log every media packet at DEBUG, and the external
+aioice package logs every STUN/TURN packet. Enabling DEBUG on the parent ``aidot``
+logger (the normal way to diagnose the integration) would otherwise unleash
+thousands of lines per second - which on a microSD host can starve the recorder.
+The package init caps those loggers at INFO so DEBUG on ``aidot`` stays useful.
+"""
+import logging
+
+import aidot  # noqa: F401 - import triggers the logger caps
+
+CAPPED = (
+    "aidot._vendor.aiortc.rtcrtpreceiver",
+    "aidot._vendor.aiortc.rtcrtpsender",
+    "aioice.ice",
+    "aioice.turn",
+)
+
+
+def test_packet_loggers_capped_to_info():
+    for name in CAPPED:
+        lg = logging.getLogger(name)
+        assert lg.level == logging.INFO, f"{name} not capped (level={lg.level})"
+
+
+def test_aidot_debug_does_not_unleash_the_packet_firehose():
+    # Even with the parent 'aidot' logger at DEBUG, the per-packet DEBUG is off.
+    logging.getLogger("aidot").setLevel(logging.DEBUG)
+    for name in CAPPED:
+        assert not logging.getLogger(name).isEnabledFor(logging.DEBUG), f"{name} still emits DEBUG"

{python_aidot_cameras-0.11.9 → python_aidot_cameras-0.11.11}/tests/test_mqtt_session_reconnect.py

@@ -82,3 +82,53 @@ def test_disconnect_before_connect_ends_session(monkeypatch):
     )
     assert messages == []
     assert status["connected"] is False
+
+
+def test_terminal_disconnect_ends_session_before_deadline(monkeypatch):
+    """A post-connect drop that never reconnects must end the session via the
+    reconnect grace, not poll a dead socket until the full duration deadline."""
+    monkeypatch.setattr(proto, "_MQTT_RECONNECT_GRACE", 0.15)
+
+    def driver(c):
+        c.on_connect(c, None, {}, 0)                         # connected
+        c.on_message(c, None, _FakeMsg("t/before", b"x"))   # delivered pre-drop
+        time.sleep(0.02)
+        c.on_disconnect(c, None, 142)                       # terminal drop; NO reconnect
+
+    _install_fake_client(monkeypatch, driver)
+
+    t0 = time.monotonic()
+    messages, status = proto._mqtt_session_sync(
+        "wss://broker.example/mqtt", "u", "p", "cid",
+        ["t/a"], [], 30.0,          # 30s duration - must NOT wait this long
+    )
+    elapsed = time.monotonic() - t0
+
+    assert elapsed < 5.0, f"terminal disconnect should end fast, took {elapsed:.1f}s"
+    assert ("t/before", "x") in messages                    # pre-drop message still collected
+    assert status["disconnected_since"] is not None         # the drop was recorded
+
+
+def test_reconnect_within_grace_keeps_session(monkeypatch):
+    """A drop that reconnects within the grace clears disconnected_since, so the
+    receive loop must NOT fail the session fast (guards the transient path)."""
+    monkeypatch.setattr(proto, "_MQTT_RECONNECT_GRACE", 0.5)
+    outgoing = queue.Queue()
+
+    def driver(c):
+        c.on_connect(c, None, {}, 0)
+        c.on_disconnect(c, None, 7)                         # blip
+        time.sleep(0.05)                                   # < grace
+        c.on_connect(c, None, {}, 0)                       # recovered
+        c.on_message(c, None, _FakeMsg("t/after", b"live"))
+        time.sleep(0.05)
+        outgoing.put_nowait(None)                          # clean stop
+
+    _install_fake_client(monkeypatch, driver)
+
+    messages, status = proto._mqtt_session_sync(
+        "wss://broker.example/mqtt", "u", "p", "cid",
+        ["t/a"], [], 30.0, outgoing_queue=outgoing,
+    )
+    assert ("t/after", "live") in messages                  # survived the blip
+    assert status["disconnected_since"] is None             # cleared on reconnect

python_aidot_cameras-0.11.9/aidot/__init__.py

@@ -1,46 +0,0 @@
-"""AiDot camera and device library."""
-
-import logging as _logging
-
-from .client import AidotClient
-from .device_client import DeviceClient
-from .discover import Discover
-from .exceptions import (
-    AidotAuthFailed,
-    AidotAuthTokenExpired,
-    AidotCameraBusy,
-    AidotError,
-    AidotNotLogin,
-    AidotOSError,
-    AidotUserOrPassIncorrect,
-    HTTPError,
-    InvalidHost,
-    InvalidURL,
-)
-
-# The vendored aiortc RTP receiver/sender log EVERY media packet at DEBUG.  When a
-# user enables DEBUG on the parent ``aidot`` logger to diagnose the integration,
-# that becomes thousands of lines per second and floods the logs (in one capture,
-# 99% of all lines).  Cap just those two per-packet loggers at INFO so enabling
-# ``aidot`` DEBUG stays useful - the diagnostically valuable aiortc DEBUG (DTLS,
-# ICE, SCTP/DCEP) still flows.  Respect an explicit level if the user set one.
-for _chatty in ("aidot._vendor.aiortc.rtcrtpreceiver", "aidot._vendor.aiortc.rtcrtpsender"):
-    _lg = _logging.getLogger(_chatty)
-    if _lg.level == _logging.NOTSET:
-        _lg.setLevel(_logging.INFO)
-
-__all__ = [
-    "AidotAuthFailed",
-    "AidotAuthTokenExpired",
-    "AidotCameraBusy",
-    "AidotClient",
-    "AidotError",
-    "AidotNotLogin",
-    "AidotOSError",
-    "AidotUserOrPassIncorrect",
-    "DeviceClient",
-    "Discover",
-    "HTTPError",
-    "InvalidHost",
-    "InvalidURL",
-]

python_aidot_cameras-0.11.9/tests/test_logging_caps.py

@@ -1,22 +0,0 @@
-"""Importing the library caps the vendored aiortc per-packet loggers.
-
-aiortc's RTP receiver/sender log every media packet at DEBUG. Enabling DEBUG on
-the parent ``aidot`` logger (the normal way to diagnose the integration) would
-otherwise unleash thousands of lines per second. The package init caps just those
-two loggers at INFO so DEBUG on ``aidot`` stays useful without the firehose.
-"""
-import logging
-
-import aidot  # noqa: F401 - import triggers the logger caps
-
-
-def test_vendored_aiortc_packet_loggers_capped_to_info():
-    for name in (
-        "aidot._vendor.aiortc.rtcrtpreceiver",
-        "aidot._vendor.aiortc.rtcrtpsender",
-    ):
-        lg = logging.getLogger(name)
-        assert lg.level == logging.INFO, f"{name} not capped (level={lg.level})"
-        # Even with the parent 'aidot' logger at DEBUG, the per-packet DEBUG is off.
-        logging.getLogger("aidot").setLevel(logging.DEBUG)
-        assert not lg.isEnabledFor(logging.DEBUG), f"{name} still emits DEBUG"