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

{python_aidot_cameras-0.12.6/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.6
+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.6 → 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.6 → 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.6 → python_aidot_cameras-0.12.8}/aidot_cameras/camera/sdes_open.py

@@ -38,12 +38,20 @@ _LOGGER = logging.getLogger(__name__)
 # The SDP offers both because the camera picks one per session.
 _SDP_ALTERNATE_PT = {96: 97, 97: 96, 0: 8, 8: 0}
 
-# Extra time, on top of the video payload-type wait, to characterise the audio
-# payload type before the serve launches.  Short by design: audio that has not
-# appeared by then is served on a later open (every ffmpeg restart re-runs this
-# wait, and by then the camera has been streaming for a while), which is cheaper
-# than delaying the picture for every silent camera.
-_AUDIO_PT_GRACE_S = 4.0
+# How long to wait for the FIRST media of a session before launching the serve.
+# Nothing useful can happen before then: the payload types are unknown, so the SDP
+# cannot be narrowed, and ffmpeg would bind the wrong depacketizers.  Sized to the
+# documented cold-start window for a battery camera (25-70s).  Measured: a cold
+# session started media at ~21s, which the previous 15s deadline missed entirely -
+# it launched blind with BOTH payload types still unknown, which is what left the
+# audio line advertising PCMU on a PCMA camera.
+_FIRST_MEDIA_WAIT_S = 45.0
+
+# Extra time for the audio payload type once video is known.  Measured on an
+# A001513: audio follows video by 40-70ms, because the camera answers BUNDLE and
+# both share one 5-tuple - so audio is never "late" and this only absorbs jitter.
+# Kept tight so a camera that genuinely sends no audio barely delays the picture.
+_AUDIO_PT_GRACE_S = 1.0
 
 
 def narrow_sdp_payload_types(sdp_text: str, keep_video=None, keep_audio=None) -> str:
@@ -3541,13 +3549,17 @@ class _SdesOpenMixin:
         # picture, while an unnarrowed audio line guarantees the mux never writes its
         # PAT/PMT, which loses the picture AND the audio.  Wait for both, then take
         # whatever has been observed by the deadline.
-        # Two separate budgets on purpose.  Video keeps its original 15s, because
-        # the picture is what the viewer is waiting for.  Audio gets only a short
-        # extra grace on top: sharing one deadline would make a camera that never
-        # sends audio delay the picture from a couple of seconds to the full 15,
-        # which trades the bug for a worse one.
-        _vpt_deadline = time.monotonic() + 15.0
-        while _first_video_pt[0] is None and time.monotonic() < _vpt_deadline:
+        # Wait for the session's first media, then briefly for audio.
+        #
+        # Measured on an A001513: a cold session's media starts at ~21s, and its
+        # video and audio payload types then arrive 40-70ms apart because the camera
+        # answers BUNDLE.  So audio is never "late" relative to video - the old 15s
+        # video deadline simply expired BEFORE any media at all, and the serve
+        # launched with both payload types unknown.  Waiting for first media costs
+        # no picture latency: ffmpeg cannot produce before media exists, and
+        # launching earlier only binds the wrong depacketizers.
+        _media_deadline = time.monotonic() + _FIRST_MEDIA_WAIT_S
+        while _first_video_pt[0] is None and time.monotonic() < _media_deadline:
             await asyncio.sleep(0.1)
         if _serve_audio and _first_audio_pt[0] is None:
             _apt_deadline = time.monotonic() + _AUDIO_PT_GRACE_S

{python_aidot_cameras-0.12.6 → 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.6"
+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.6 → 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.6
+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.6 → 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.6 → 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))