python-aidot-cameras 1.0.0rc45__tar.gz → 1.0.0rc46__tar.gz

{python_aidot_cameras-1.0.0rc45/python_aidot_cameras.egg-info → python_aidot_cameras-1.0.0rc46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 1.0.0rc45
+Version: 1.0.0rc46
 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-1.0.0rc45 → python_aidot_cameras-1.0.0rc46}/aidot_cameras/camera/client.py

@@ -97,6 +97,7 @@ from .protocol import (  # noqa: F401 - used here and/or by the webrtc_open mixi
     _grab_free_port,
     _tcp_table_has_established_on_port,
     _idle_release_due,
+    _battery_cap_spans_sessions_due,
     _battery_unknown_release_s,
     _stream_startup_grace_s,
     _DirectTsServer,
@@ -4834,8 +4835,10 @@ class CameraMixin(
     def _sdes_serve_consumer_present(self, port: int) -> "Optional[bool]":
         """True if a TCP client is connected to the SDES serve ``port`` (a viewer
         is pulling), False if none, None if the TCP table can't be read (non-Linux
-        / sandboxed host).  The caller MUST treat None as 'unknown' and NOT release
-        - failing safe to the current always-reconnect behaviour."""
+        / sandboxed host).  None is 'unknown': a mains camera is not released on
+        it, and since 1.0.0rc45 a battery camera is, once
+        AIDOT_BATTERY_UNKNOWN_VIEWER_RELEASE_S has passed without a known viewer
+        (protocol._idle_release_due)."""
         read_any = False
         found = False
         for _path in ("/proc/net/tcp", "/proc/net/tcp6"):
@@ -5095,6 +5098,13 @@ class CameraMixin(
         # burst stays on ONE peerid: a fresh peerid registers another camera-side
         # session, which is what wedged the L2 in the first place (0.12.16).
         _not_ready_burst = 0
+        # The battery unknown-viewer cap counts from the last viewer KNOWN
+        # present in any session of this keepalive, not from each session's
+        # open: a loop of sessions that end on their own (a refused publish
+        # ends the serve in seconds) re-anchored every 35-60 s and never
+        # reached it, re-waking a battery camera for as long as the cause
+        # lasted. See _battery_cap_spans_sessions_due.
+        _last_known_viewer = time.monotonic()
 
         while self._streaming_active:
             if self._serve_relay is not None:
@@ -5328,10 +5338,14 @@ class CameraMixin(
                         _present = await self._viewer_present(_serve_port)
                         if _present:  # True -> a viewer is pulling; stay alive
                             _last_consumer = time.monotonic()
+                            _last_known_viewer = _last_consumer
                             _viewer_seen = True
                         elif _idle_release_due(
                             _present,
-                            _last_consumer,
+                            # Unknown counts across reopens; a known absence
+                            # keeps its per-session window, so a viewer
+                            # re-attaching after a camera-side drop is not cut.
+                            _last_known_viewer if _present is None else _last_consumer,
                             time.monotonic(),
                             _idle_secs,
                             battery=_battery,
@@ -5344,7 +5358,7 @@ class CameraMixin(
                                     "SDES serve: %s released - viewer state "
                                     "unknown for %.0f s on a battery camera",
                                     self.device_id,
-                                    time.monotonic() - _last_consumer,
+                                    time.monotonic() - _last_known_viewer,
                                 )
                             _idle_release = True
                             break
@@ -5358,6 +5372,17 @@ class CameraMixin(
             finally:
                 self._stream_session = None
 
+            if not _idle_release and _battery_cap_spans_sessions_due(
+                _battery, _unknown_cap, _last_known_viewer, time.monotonic()
+            ):
+                _LOGGER.info(
+                    "SDES serve: %s released - no viewer known for %.0f s across"
+                    " sessions that ended on their own, on a battery camera",
+                    self.device_id,
+                    time.monotonic() - _last_known_viewer,
+                )
+                _idle_release = True
+
             if _idle_release:
                 # No HA consumer for the idle window: go dormant instead of
                 # reconnecting forever.  camera.stream_source() restarts us (and

{python_aidot_cameras-1.0.0rc45 → python_aidot_cameras-1.0.0rc46}/aidot_cameras/camera/go2rtc.py

@@ -108,8 +108,10 @@ class Go2rtcClient:
         not a viewer exists.  Idle-release keyed on the socket therefore never
         fires and every camera streams forever after a single view.
 
-        None means unknown (go2rtc unreachable or the stream absent), and callers
-        must fail safe by not releasing on it.
+        None means unknown (go2rtc unreachable or the stream absent). A mains
+        camera is not released on it; since 1.0.0rc45 a battery camera is, after
+        AIDOT_BATTERY_UNKNOWN_VIEWER_RELEASE_S without a known viewer
+        (protocol._idle_release_due).
         """
         streams = await self.list_streams()
         entry = streams.get(name)

{python_aidot_cameras-1.0.0rc45 → python_aidot_cameras-1.0.0rc46}/aidot_cameras/camera/protocol.py

@@ -1656,6 +1656,29 @@ def _idle_release_due(
     return (now - last_consumer) > _window
 
 
+def _battery_cap_spans_sessions_due(
+    battery: bool,
+    unknown_cap_s: "Optional[float]",
+    last_known_viewer: float,
+    now: float,
+) -> bool:
+    """Whether a battery keepalive should stop instead of opening another session.
+
+    Checked when an SDES session has ended on its own. ``last_known_viewer`` is
+    the last time a viewer was KNOWN present in any session of this keepalive
+    (or the keepalive's start), so it is not reset by a reopen. The per-session
+    checks cannot see a loop of sessions that end before their first viewer
+    check - a publish the target refuses ends the serve in seconds, and a fresh
+    session opens 10 s later - so without this a battery camera was re-woken
+    every 35-60 s for as long as the cause lasted. A camera being watched keeps
+    ``last_known_viewer`` fresh from each session's checks and is not stopped.
+    Uses the same cap as the unknown-viewer release; <= 0 disables it.
+    """
+    if not battery or not unknown_cap_s or unknown_cap_s <= 0:
+        return False
+    return (now - last_known_viewer) > unknown_cap_s
+
+
 #: Default for ``AIDOT_BATTERY_UNKNOWN_VIEWER_RELEASE_S``.
 _BATTERY_UNKNOWN_RELEASE_S = 300.0
 

{python_aidot_cameras-1.0.0rc45 → python_aidot_cameras-1.0.0rc46}/pyproject.toml

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

{python_aidot_cameras-1.0.0rc45 → python_aidot_cameras-1.0.0rc46/python_aidot_cameras.egg-info}/PKG-INFO

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

@@ -101,6 +101,7 @@ tests/test_avio_request.py
 tests/test_avio_response_parse.py
 tests/test_avio_response_router.py
 tests/test_backoff.py
+tests/test_battery_cap_spans_sessions.py
 tests/test_battery_detection.py
 tests/test_battery_evidence_corroboration.py
 tests/test_battery_stale_offer_is_abandoned_early.py

python_aidot_cameras-1.0.0rc46/tests/test_battery_cap_spans_sessions.py

@@ -0,0 +1,67 @@
+"""The battery unknown-viewer cap must survive a reopened SDES session.
+
+Found by the 2026-10-11 review: the cap, the idle window and the start-up grace
+were all measured from each session's open. A publish the target refuses ends
+the serve before the first viewer check, a fresh session opens 10 s later, and
+the anchors reset, so a battery camera was re-woken every 35-60 s for as long as
+the cause lasted (reproduced against integration 2.37.2 on a bundled-only
+install, and an add-on outage does the same).
+"""
+
+import inspect
+
+import aidot_cameras.camera.client as cc
+from aidot_cameras.camera.protocol import _battery_cap_spans_sessions_due as due
+
+
+def test_a_battery_keepalive_with_no_known_viewer_past_the_cap_stops():
+    assert due(True, 300.0, last_known_viewer=0.0, now=301.0) is True
+
+
+def test_inside_the_cap_it_reopens():
+    assert due(True, 300.0, last_known_viewer=0.0, now=299.0) is False
+
+
+def test_a_mains_camera_is_never_stopped_this_way():
+    assert due(False, 300.0, last_known_viewer=0.0, now=10_000.0) is False
+
+
+def test_a_cap_of_zero_or_none_disables_it():
+    assert due(True, 0.0, last_known_viewer=0.0, now=10_000.0) is False
+    assert due(True, None, last_known_viewer=0.0, now=10_000.0) is False
+
+
+def _src():
+    return inspect.getsource(cc.CameraMixin._sdes_keepalive_loop_inner)
+
+
+def test_the_anchor_is_set_once_per_keepalive_not_per_session():
+    src = _src()
+    loop = src.index("while self._streaming_active:")
+    first = src.index("_last_known_viewer = time.monotonic()")
+    assert first < loop, "the keepalive-wide anchor must sit above the session loop"
+    assert src.count("_last_known_viewer = time.monotonic()") == 1
+
+
+def test_a_known_viewer_refreshes_the_keepalive_anchor():
+    src = _src()
+    seen = src.index("_viewer_seen = True")
+    assert (
+        "_last_known_viewer = _last_consumer"
+        in src[src.rindex("if _present:", 0, seen) : seen]
+    )
+
+
+def test_unknown_uses_the_keepalive_anchor_and_absence_the_session_one():
+    src = _src()
+    call = src[src.index("_idle_release_due(") :]
+    call = call[: call.index("_idle_release = True")]
+    assert "_last_known_viewer if _present is None else _last_consumer" in call
+
+
+def test_a_session_that_ended_on_its_own_is_checked_before_reopening():
+    src = _src()
+    check = src.index("_battery_cap_spans_sessions_due(")
+    release = src.index("if _idle_release:", check)
+    assert check < release
+    assert "_battery, _unknown_cap, _last_known_viewer" in src[check:release]