python-aidot-cameras 0.12.7__tar.gz → 0.12.9__tar.gz

{python_aidot_cameras-0.12.7/python_aidot_cameras.egg-info → python_aidot_cameras-0.12.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.12.7
+Version: 0.12.9
 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.12.7 → python_aidot_cameras-0.12.9}/aidot_cameras/__init__.py

@@ -12,6 +12,7 @@ import time as _time
 
 from .client import AidotClient, CameraClient
 from .device_client import CameraDeviceClient, DeviceInformation, DeviceStatusData
+from .camera.client import configure_stream_limits
 from .discover import CameraDiscover, Discover
 from .exceptions import (
     AidotAuthFailed,
@@ -147,4 +148,5 @@ __all__ = [
     "HTTPError",
     "InvalidHost",
     "InvalidURL",
+    "configure_stream_limits",
 ]

{python_aidot_cameras-0.12.7 → python_aidot_cameras-0.12.9}/aidot_cameras/camera/client.py

@@ -571,6 +571,51 @@ def _get_webrtc_open_gate() -> "asyncio.Semaphore":
 
 
 _STREAM_SLOTS: "Optional[asyncio.Semaphore]" = None
+_STREAM_SLOTS_CAP: int = 0
+
+
+def _stream_slots_default() -> int:
+    """The configured cap: an explicit env override, else the built-in default."""
+    try:
+        return max(1, int(os.environ.get("AIDOT_MAX_CONCURRENT_STREAMS", "3")))
+    except (ValueError, TypeError):
+        return 3
+
+
+def configure_stream_limits(max_streams: int) -> int:
+    """Raise the concurrent-serve cap to fit the fleet; return the cap in force.
+
+    The default cap of 3 is a host-protection guard, but it silently STARVES an
+    account with more cameras than that: a camera holds its slot for the life of
+    its serve, so on a fleet of 4 DTLS cameras the fourth waits forever while the
+    other three are kept alive - it simply never streams, with no error anywhere.
+    Confirmed live on a 4-camera fleet, where the library logged "waiting for a
+    stream slot (cap reached)" for the odd one out on every attempt.
+
+    A consumer that knows how many cameras it is about to drive (the Home
+    Assistant integration knows its camera count) should call this so the cap is
+    never below the fleet size.
+
+    ``AIDOT_MAX_CONCURRENT_STREAMS`` still wins when set: an operator who
+    deliberately capped a small host means it, and would rather have cameras take
+    turns than have the host fall over.  The cap only ever grows - shrinking it
+    would strand a camera that already holds a slot.
+    """
+    global _STREAM_SLOTS, _STREAM_SLOTS_CAP
+    if os.environ.get("AIDOT_MAX_CONCURRENT_STREAMS"):
+        _get_stream_slots()          # ensure it exists so the cap is populated
+        return _STREAM_SLOTS_CAP
+    target = max(1, int(max_streams))
+    slots = _get_stream_slots()
+    if target > _STREAM_SLOTS_CAP:
+        for _ in range(target - _STREAM_SLOTS_CAP):
+            slots.release()          # grows the semaphore's permit count
+        _LOGGER.info(
+            "concurrent-serve cap raised from %d to %d to fit the camera fleet",
+            _STREAM_SLOTS_CAP, target,
+        )
+        _STREAM_SLOTS_CAP = target
+    return _STREAM_SLOTS_CAP
 
 
 def _get_stream_slots() -> "asyncio.Semaphore":
@@ -586,13 +631,10 @@ def _get_stream_slots() -> "asyncio.Semaphore":
     -50002 SESSION_EXCEED terminal error, which we mirror separately).  This cap
     is an HA-specific resource guard: HA dashboards can request N cameras at once,
     which a phone never does.  Deliberate divergence, kept for host protection."""
-    global _STREAM_SLOTS
+    global _STREAM_SLOTS, _STREAM_SLOTS_CAP
     if _STREAM_SLOTS is None:
-        try:
-            _n = max(1, int(os.environ.get("AIDOT_MAX_CONCURRENT_STREAMS", "3")))
-        except (ValueError, TypeError):
-            _n = 3
-        _STREAM_SLOTS = asyncio.Semaphore(_n)
+        _STREAM_SLOTS_CAP = _stream_slots_default()
+        _STREAM_SLOTS = asyncio.Semaphore(_STREAM_SLOTS_CAP)
     return _STREAM_SLOTS
 
 
@@ -2720,7 +2762,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
             _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_register_with_go2rtc', exc_info=True)
         if not (self._streaming_active and self._go2rtc_url and self._keepalive_rtsp_url):
             return
-        name = f"aidot_{self.device_id[:12]}"
+        name = self._go2rtc_stream_name()
         try:
             async with aiohttp.ClientSession() as _s2:
                 url = await prefer_go2rtc(
@@ -2746,7 +2788,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
             return
         import aiohttp
         from .go2rtc import Go2rtcClient
-        name = f"aidot_{self.device_id[:12]}"
+        name = self._go2rtc_stream_name()
         try:
             async with aiohttp.ClientSession() as _s2:
                 await Go2rtcClient(_s2, base).remove_stream(name)
@@ -2861,6 +2903,41 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                 found = True
         return found if read_any else None
 
+    def _go2rtc_stream_name(self) -> str:
+        """The go2rtc stream name for this camera - one definition, so the
+        register, deregister and viewer-count paths cannot drift apart."""
+        return f"aidot_{self.device_id[:12]}"
+
+    async def _viewer_present(self, port: int) -> "Optional[bool]":
+        """Is anyone ACTUALLY watching?  True / False / None (unknown).
+
+        Ask go2rtc first when the stream is registered with it, because the serve
+        socket cannot answer this question: go2rtc attaches to the serve as its
+        producer and stays attached for as long as the stream exists, viewer or
+        no viewer.  A TCP peer is therefore always present, idle-release never
+        fires, and every camera keeps streaming indefinitely after a single view -
+        which is what "why are all my cameras streaming?" looks like from outside.
+        Confirmed live: five cameras, no viewers, still producing after 7 minutes
+        against a 5 minute idle window.
+
+        Falls back to the TCP-table check when go2rtc is not in use, and returns
+        None (never release) if neither can answer.
+        """
+        name = self._go2rtc_stream_name()
+        base = self._go2rtc_url
+        if base and name:
+            try:
+                import aiohttp
+
+                from .go2rtc import Go2rtcClient
+                async with aiohttp.ClientSession() as _s:
+                    viewers = await Go2rtcClient(_s, base).viewer_count(name)
+                if viewers is not None:
+                    return viewers > 0
+            except Exception as exc:
+                _LOGGER.debug("go2rtc viewer check failed: %s", exc)
+        return self._sdes_serve_consumer_present(port)
+
     async def _sdes_keepalive_loop(self) -> None:
         """Keep the cold-start serve relay alive around the SDES keepalive loop.
 
@@ -2977,7 +3054,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                         _stalled = True
                         break
                     if _idle_on and _serve_port is not None:
-                        _present = self._sdes_serve_consumer_present(_serve_port)
+                        _present = await self._viewer_present(_serve_port)
                         if _present:  # True -> a viewer is pulling; stay alive
                             _last_consumer = time.monotonic()
                         elif _idle_release_due(_present, _last_consumer,

{python_aidot_cameras-0.12.7 → python_aidot_cameras-0.12.9}/aidot_cameras/camera/go2rtc.py

@@ -72,6 +72,29 @@ class Go2rtcClient:
     async def has_stream(self, name: str) -> bool:
         return name in (await self.list_streams())
 
+    async def viewer_count(self, name: str) -> "Optional[int]":
+        """How many CONSUMERS go2rtc has for ``name``; None if it cannot be read.
+
+        This is the only trustworthy answer to "is anyone actually watching?".
+        The serve socket cannot answer it: go2rtc attaches to the serve as its
+        producer and stays attached, so a TCP peer is always present whether or
+        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.
+        """
+        streams = await self.list_streams()
+        entry = streams.get(name)
+        if not isinstance(entry, dict):
+            return None
+        consumers = entry.get("consumers")
+        if consumers is None:
+            return 0          # go2rtc reports null rather than [] when there are none
+        if isinstance(consumers, list):
+            return len(consumers)
+        return None
+
     async def ensure_stream(self, name: str, source: str) -> bool:
         """Register (or replace) ``name`` -> ``source``. Returns True on 200."""
         try:

{python_aidot_cameras-0.12.7 → python_aidot_cameras-0.12.9}/pyproject.toml

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

{python_aidot_cameras-0.12.7 → python_aidot_cameras-0.12.9/python_aidot_cameras.egg-info}/PKG-INFO

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

@@ -127,10 +127,12 @@ tests/test_speak.py
 tests/test_stream_cap.py
 tests/test_stream_drain_ownership.py
 tests/test_stream_idle.py
+tests/test_stream_slot_cap.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_upstream_compat.py
+tests/test_viewer_presence.py
 tests/test_wait_or_event.py

python_aidot_cameras-0.12.9/tests/test_stream_slot_cap.py

@@ -0,0 +1,80 @@
+"""The concurrent-serve cap must never sit below the camera fleet.
+
+A camera holds its slot for the life of its serve, so a cap lower than the number
+of cameras does not merely slow things down - the odd one out waits forever and
+simply never streams, with no error surfaced anywhere. Confirmed live on a fleet
+of 4 DTLS cameras against the default cap of 3: the library logged "waiting for a
+stream slot (cap reached)" for the fourth on every attempt, and that camera was
+exactly the one that would not play in Home Assistant.
+"""
+import asyncio
+
+import pytest
+
+import aidot_cameras.camera.client as cc
+
+
+@pytest.fixture(autouse=True)
+def _reset(monkeypatch):
+    monkeypatch.delenv("AIDOT_MAX_CONCURRENT_STREAMS", raising=False)
+    cc._STREAM_SLOTS = None
+    cc._STREAM_SLOTS_CAP = 0
+    yield
+    cc._STREAM_SLOTS = None
+    cc._STREAM_SLOTS_CAP = 0
+
+
+def test_default_is_the_host_protection_cap():
+    async def go():
+        assert cc._stream_slots_default() == 3
+        cc._get_stream_slots()
+        return cc._STREAM_SLOTS_CAP
+    assert asyncio.run(go()) == 3
+
+
+def test_a_bigger_fleet_raises_the_cap():
+    async def go():
+        return cc.configure_stream_limits(5)
+    assert asyncio.run(go()) == 5
+
+
+def test_every_camera_in_the_fleet_can_hold_a_slot_at_once():
+    # The actual regression: with a cap of 3 and 4 cameras, the fourth blocks.
+    async def go():
+        cc.configure_stream_limits(4)
+        slots = cc._get_stream_slots()
+        for _ in range(4):
+            await asyncio.wait_for(slots.acquire(), timeout=0.5)
+        return True
+    assert asyncio.run(go()) is True
+
+
+def test_the_cap_never_shrinks():
+    # Shrinking would strand a camera that already holds a slot.
+    async def go():
+        cc.configure_stream_limits(6)
+        return cc.configure_stream_limits(2)
+    assert asyncio.run(go()) == 6
+
+
+def test_an_explicit_operator_cap_wins(monkeypatch):
+    # Someone who capped a small host means it, and would rather cameras took
+    # turns than have the host fall over.
+    monkeypatch.setenv("AIDOT_MAX_CONCURRENT_STREAMS", "1")
+    async def go():
+        return cc.configure_stream_limits(8)
+    assert asyncio.run(go()) == 1
+
+
+def test_raising_is_idempotent():
+    async def go():
+        cc.configure_stream_limits(5)
+        cc.configure_stream_limits(5)
+        slots = cc._get_stream_slots()
+        for _ in range(5):
+            await asyncio.wait_for(slots.acquire(), timeout=0.5)
+        # A sixth must block: the cap is 5, not 10.
+        with pytest.raises(asyncio.TimeoutError):
+            await asyncio.wait_for(slots.acquire(), timeout=0.2)
+        return True
+    assert asyncio.run(go()) is True

{python_aidot_cameras-0.12.7 → python_aidot_cameras-0.12.9}/tests/test_upstream_compat.py

@@ -259,3 +259,10 @@ def test_device_state_is_upstreams_own_enum_reexported():
     assert DeviceState is _upstream
     for name in ("IDLE", "AUTHENTICATED"):
         assert hasattr(DeviceState, name), name
+
+
+def test_configure_stream_limits_is_public():
+    # The Home Assistant integration calls this to size the concurrent-serve cap
+    # to its camera count; a cap below the fleet silently starves a camera.
+    import aidot_cameras
+    assert callable(getattr(aidot_cameras, "configure_stream_limits", None))

python_aidot_cameras-0.12.9/tests/test_viewer_presence.py

@@ -0,0 +1,71 @@
+"""Idle-release must key on real viewers, not on go2rtc being attached.
+
+go2rtc attaches to the camera serve as its PRODUCER and stays attached for as long
+as the stream is registered - viewer or no viewer. So the serve socket always has
+an ESTABLISHED peer, the idle window never elapses, and every camera keeps
+streaming forever after a single view. Confirmed live: five cameras, nobody
+watching, still producing after 7 minutes against a 5 minute idle window.
+"""
+import asyncio
+
+from aidot_cameras.camera.go2rtc import Go2rtcClient
+
+
+class _Resp:
+    def __init__(self, payload, status=200):
+        self._p, self.status = payload, status
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *a):
+        return False
+
+    async def json(self):
+        return self._p
+
+
+class _Session:
+    def __init__(self, payload, status=200):
+        self._p, self._status = payload, status
+
+    def get(self, *a, **kw):
+        return _Resp(self._p, self._status)
+
+
+def _count(payload, name="aidot_abc", status=200):
+    client = Go2rtcClient(_Session(payload, status), "http://go2rtc:1984")
+    return asyncio.run(client.viewer_count(name))
+
+
+def test_no_viewers_when_consumers_is_empty():
+    # A producer attached with no consumers is exactly the idle case that was
+    # being misread as "someone is watching".
+    assert _count({"aidot_abc": {"producers": [{"url": "x"}], "consumers": []}}) == 0
+
+
+def test_no_viewers_when_go2rtc_reports_null():
+    # go2rtc returns null rather than [] for some streams; that is still nobody.
+    assert _count({"aidot_abc": {"producers": [{"url": "x"}], "consumers": None}}) == 0
+
+
+def test_counts_real_viewers():
+    assert _count({"aidot_abc": {"consumers": [{"id": 1}, {"id": 2}]}}) == 2
+
+
+def test_unknown_when_the_stream_is_absent():
+    # Unknown must stay unknown so the caller fails safe and does NOT release.
+    assert _count({"something_else": {"consumers": []}}) is None
+
+
+def test_unknown_when_go2rtc_is_unreachable():
+    assert _count({}, status=500) is None
+
+
+def test_release_policy_treats_unknown_as_do_not_release():
+    from aidot_cameras.camera.protocol import _idle_release_due
+    now = 1000.0
+    assert _idle_release_due(None, now - 9999, now, 300) is False   # unknown
+    assert _idle_release_due(True, now - 9999, now, 300) is False   # watching
+    assert _idle_release_due(False, now - 9999, now, 300) is True   # idle, elapsed
+    assert _idle_release_due(False, now - 10, now, 300) is False    # idle, too soon