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

{python_aidot_cameras-0.12.8/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.8
+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.8 → python_aidot_cameras-0.12.9}/aidot_cameras/camera/client.py

@@ -2762,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(
@@ -2788,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)
@@ -2903,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.
 
@@ -3019,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.8 → 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.8 → 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.8"
+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.8 → 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.8
+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.8 → python_aidot_cameras-0.12.9}/python_aidot_cameras.egg-info/SOURCES.txt

@@ -134,4 +134,5 @@ 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_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