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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.12.7
+Version: 0.12.8
 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.8}/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.8}/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
 
 

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-aidot-cameras"
-version = "0.12.7"
+version = "0.12.8"
 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.8/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.8
 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.8}/python_aidot_cameras.egg-info/SOURCES.txt

@@ -127,6 +127,7 @@ 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

python_aidot_cameras-0.12.8/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.8}/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))