python-aidot-cameras 0.5.8__tar.gz → 0.5.10__tar.gz

{python_aidot_cameras-0.5.8/src/python_aidot_cameras.egg-info → python_aidot_cameras-0.5.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.5.8
+Version: 0.5.10
 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.5.8 → python_aidot_cameras-0.5.10}/pyproject.toml

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

{python_aidot_cameras-0.5.8 → python_aidot_cameras-0.5.10}/src/aidot/device_client.py

@@ -2059,8 +2059,11 @@ def _save_sprop(devid: str, sprop: str) -> None:
         with open(tmp, "w") as fh:
             fh.write(sprop)
         os.replace(tmp, _sprop_cache_path(devid))
-    except OSError:
-        pass
+    except OSError as exc:
+        # Surface (don't swallow): if the cache dir isn't writable the whole
+        # sprop feature is silently inert.  AIDOT_SPROP_DIR can redirect it.
+        _LOGGER.warning("sprop cache write failed (%s): %s — set AIDOT_SPROP_DIR "
+                        "to a writable path", _SPROP_DIR, exc)
 
 
 def _inject_sprop(sdp: str, devid: str) -> str:
@@ -2080,6 +2083,53 @@ def _inject_sprop(sdp: str, devid: str) -> str:
     return "\r\n".join(out)
 
 
+def _sdes_serve_port(url: "Optional[str]") -> "Optional[int]":
+    """Extract the TCP port from an SDES serve URL (``http://127.0.0.1:PORT/x.ts``).
+
+    Returns None if the URL is missing/malformed.  Pure (unit-testable)."""
+    if not url:
+        return None
+    try:
+        return int(url.rsplit(":", 1)[1].split("/", 1)[0])
+    except (ValueError, IndexError):
+        return None
+
+
+def _tcp_table_has_established_on_port(table_text: str, port: int) -> bool:
+    """True if any row in a /proc/net/tcp[6] dump is ESTABLISHED on local ``port``.
+
+    /proc/net/tcp columns: ``sl local_address rem_address st ...`` where
+    local_address is ``HEXIP:HEXPORT`` (port is upper-hex, %04X) and ``st`` is the
+    connection state (``01`` == ESTABLISHED, ``0A`` == LISTEN).  A LISTEN socket
+    (ffmpeg ``-listen 1`` waiting) is NOT a consumer; only an ESTABLISHED peer is.
+    Pure function so the no-viewer policy is unit-testable without a live host."""
+    target = f"{port:04X}"
+    for line in table_text.splitlines()[1:]:  # skip header row
+        cols = line.split()
+        if len(cols) < 4:
+            continue
+        local, st = cols[1], cols[3]
+        if ":" not in local:
+            continue
+        if local.rsplit(":", 1)[1].upper() == target and st == "01":
+            return True
+    return False
+
+
+def _idle_release_due(present, last_consumer: float, now: float,
+                      idle_secs: float) -> bool:
+    """Whether a viewerless SDES keepalive should release.
+
+    ``present``: True (a TCP consumer is connected to the serve port), False
+    (none), or None (the table was unreadable - unknown).  Release ONLY when
+    we're certain there's no consumer (False) AND the idle window has elapsed;
+    True keeps it alive and None never releases (fail-safe on non-Linux).  Pure
+    so the policy is unit-testable without a live loop."""
+    if present is not False:
+        return False
+    return (now - last_consumer) > idle_secs
+
+
 def _dtls_av_mux_run(vq, aq, out_fileobj, progress, stop_flag) -> None:
     """Mux tapped video (H.264 copy) + audio (PCMA->AAC) to ``out_fileobj`` as
     RTP-timestamped MPEG-TS.  Runs in a worker thread; the serve's ffmpeg reads
@@ -4276,6 +4326,24 @@ class DeviceClient(object):
                 await session.stop()
         return True
 
+    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."""
+        read_any = False
+        found = False
+        for _path in ("/proc/net/tcp", "/proc/net/tcp6"):
+            try:
+                with open(_path, "r") as _fh:
+                    _txt = _fh.read()
+            except OSError:
+                continue
+            read_any = True
+            if _tcp_table_has_established_on_port(_txt, port):
+                found = True
+        return found if read_any else None
+
     async def _sdes_keepalive_loop(self) -> None:
         """Background task: keep SDES stream alive; push to go2rtc via RTSP."""
         _MIN_DELAY = 10.0
@@ -4312,6 +4380,20 @@ class DeviceClient(object):
             _started_at = time.monotonic()
             _done = asyncio.ensure_future(session.wait_done())
             _stalled = False
+            _idle_release = False
+            # No-viewer release.  Unlike the DTLS serve (which idle-releases when
+            # its mux pipe goes stale), an SDES keepalive otherwise reconnects
+            # FOREVER even with zero HA consumers — a battery-draining orphan that
+            # also holds a stream slot and TURN-relay bandwidth.  SDES has no mux
+            # pipe to watch, so detect "nobody is pulling" via an ESTABLISHED TCP
+            # connection on the -listen serve port and release after the same idle
+            # window as DTLS; the next view re-runs camera.stream_source().  Fail
+            # safe: unknown (non-Linux /proc) never releases.  Escape hatch:
+            # AIDOT_SDES_IDLE_RELEASE=0.
+            _idle_on = os.environ.get("AIDOT_SDES_IDLE_RELEASE", "1") != "0"
+            _idle_secs = float(os.environ.get("AIDOT_STREAM_IDLE_S", "120"))
+            _serve_port = _sdes_serve_port(self._keepalive_rtsp_url)
+            _last_consumer = _started_at  # grace: count idle from session open
             try:
                 while True:
                     _fin, _ = await asyncio.wait({_done}, timeout=5.0)
@@ -4324,6 +4406,15 @@ class DeviceClient(object):
                     ):
                         _stalled = True
                         break
+                    if _idle_on and _serve_port is not None:
+                        _present = self._sdes_serve_consumer_present(_serve_port)
+                        if _present:  # True → a viewer is pulling; stay alive
+                            _last_consumer = time.monotonic()
+                        elif _idle_release_due(_present, _last_consumer,
+                                               time.monotonic(), _idle_secs):
+                            _idle_release = True
+                            break
+                        # _present is None (unreadable table) → don't release
             except asyncio.CancelledError:
                 _done.cancel()
                 self._stream_session = None
@@ -4332,6 +4423,25 @@ class DeviceClient(object):
             finally:
                 self._stream_session = None
 
+            if _idle_release:
+                # No HA consumer for the idle window: go dormant instead of
+                # reconnecting forever.  camera.stream_source() restarts us (and
+                # the camera.py stale-stream watchdog evicts HA's cached stream
+                # once stream_rtsp_url is None) when someone opens the view again.
+                _done.cancel()
+                try:
+                    await session.stop()
+                except Exception:
+                    pass
+                self._streaming_active = False
+                self._keepalive_rtsp_url = None
+                self._serve_ready.clear()
+                _LOGGER.debug(
+                    "SDES serve: %s idle (no viewer) - released until next view",
+                    self.device_id,
+                )
+                return
+
             if _stalled:
                 _LOGGER.info(
                     "SDES %s: no media in watchdog window - restarting stream",
@@ -12098,8 +12208,13 @@ class DeviceClient(object):
                             "a=rtcp-mux\r\n"
                         )
                         try:
+                            # Re-apply the cached sprop-parameter-sets here too:
+                            # this serve-restart rewrite is the SDP the keepalive
+                            # ffmpeg actually reads on every watchdog cycle, so
+                            # without this the out-of-band SPS is lost on restart
+                            # (the failure persisted live even for cached cameras).
                             with open(sdp_path, "w") as _f2:
-                                _f2.write(_new_sdp)
+                                _f2.write(_inject_sprop(_new_sdp, self.device_id))
                         except Exception as _sdp_exc2:
                             _LOGGER.warning("could not rewrite SDP for restart: %s", _sdp_exc2)
                         proc = subprocess.Popen(

{python_aidot_cameras-0.5.8 → python_aidot_cameras-0.5.10/src/python_aidot_cameras.egg-info}/PKG-INFO

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

@@ -19,6 +19,7 @@ tests/test_alarm_event.py
 tests/test_highport_nomination.py
 tests/test_motion_poll.py
 tests/test_no_undefined_names.py
+tests/test_sdes_idle_release.py
 tests/test_sdes_sprop.py
 tests/test_sdes_talk.py
 tests/test_sdes_watchdog.py

python_aidot_cameras-0.5.10/tests/test_sdes_idle_release.py

@@ -0,0 +1,143 @@
+"""Unit tests for the SDES no-viewer idle-release policy helpers.
+
+An SDES keepalive otherwise reconnects forever even with zero HA consumers
+(a battery-draining orphan).  The loop releases when no TCP client is connected
+to the -listen serve port for the idle window.  These pure helpers decide that
+policy; no camera/network/host needed.
+
+  - _sdes_serve_port: pull the TCP port out of the serve URL.
+  - _tcp_table_has_established_on_port: is a consumer ESTABLISHED on that port?
+    (A LISTEN socket - ffmpeg waiting - must NOT count as a consumer.)
+"""
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from aidot.device_client import (
+    _sdes_serve_port,
+    _tcp_table_has_established_on_port,
+    _idle_release_due,
+)
+
+_PORT = 18981          # 0x4A25
+_HEX = f"{_PORT:04X}"   # "4A25"
+
+_HEADER = (
+    "  sl  local_address rem_address   st tx_queue rx_queue tr tm->when "
+    "retrnsmt   uid  timeout inode"
+)
+
+
+def _row(local_port_hex, st, remote="0100007F:9C40"):
+    return (
+        f"   0: 0100007F:{local_port_hex} {remote} {st} "
+        "00000000:00000000 00:00000000 00000000     0        0 99999 1"
+    )
+
+
+# ---- _sdes_serve_port ------------------------------------------------------
+
+def test_serve_port_parsed():
+    assert _sdes_serve_port("http://127.0.0.1:18981/abc.ts") == 18981
+
+
+def test_serve_port_none_url():
+    assert _sdes_serve_port(None) is None
+
+
+def test_serve_port_malformed():
+    assert _sdes_serve_port("not-a-url") is None
+    assert _sdes_serve_port("http://127.0.0.1:notaport/x.ts") is None
+
+
+# ---- _tcp_table_has_established_on_port ------------------------------------
+
+def test_established_consumer_present():
+    table = _HEADER + "\n" + _row(_HEX, "01")  # 01 == ESTABLISHED
+    assert _tcp_table_has_established_on_port(table, _PORT) is True
+
+
+def test_listen_only_is_not_a_consumer():
+    # ffmpeg -listen 1 waiting (0A == LISTEN) is not a viewer pulling.
+    table = _HEADER + "\n" + _row(_HEX, "0A")
+    assert _tcp_table_has_established_on_port(table, _PORT) is False
+
+
+def test_established_on_other_port_ignored():
+    table = _HEADER + "\n" + _row("0050", "01")  # ESTABLISHED on :80, not ours
+    assert _tcp_table_has_established_on_port(table, _PORT) is False
+
+
+def test_empty_or_header_only_table():
+    assert _tcp_table_has_established_on_port("", _PORT) is False
+    assert _tcp_table_has_established_on_port(_HEADER, _PORT) is False
+
+
+def test_tcp6_long_local_address_parses():
+    # tcp6 local_address is a 32-hex-char IPv6 + :PORT; port parse must still work.
+    table = (
+        _HEADER + "\n"
+        f"   0: 00000000000000000000000001000000:{_HEX} "
+        "00000000000000000000000000000000:0000 01 "
+        "00000000:00000000 00:00000000 00000000     0        0 12345 1"
+    )
+    assert _tcp_table_has_established_on_port(table, _PORT) is True
+
+
+def test_mixed_rows_finds_the_established_one():
+    table = "\n".join([
+        _HEADER,
+        _row(_HEX, "0A"),          # our port, LISTEN (not a consumer)
+        _row("0050", "01"),        # other port, ESTABLISHED
+        _row(_HEX, "01"),          # our port, ESTABLISHED  <-- the viewer
+    ])
+    assert _tcp_table_has_established_on_port(table, _PORT) is True
+
+
+# ---- _idle_release_due (the release decision) ------------------------------
+
+_IDLE = 120.0
+
+
+def test_consumer_present_never_releases():
+    # present=True → a viewer is pulling, even long past the idle window
+    assert _idle_release_due(True, last_consumer=0.0, now=10_000.0,
+                             idle_secs=_IDLE) is False
+
+
+def test_unknown_table_never_releases():
+    # present=None → /proc unreadable (non-Linux) → fail-safe, never release
+    assert _idle_release_due(None, last_consumer=0.0, now=10_000.0,
+                             idle_secs=_IDLE) is False
+
+
+def test_no_consumer_within_window_holds():
+    # no consumer but still inside the idle window → keep trying
+    assert _idle_release_due(False, last_consumer=1000.0, now=1090.0,
+                             idle_secs=_IDLE) is False
+
+
+def test_no_consumer_past_window_releases():
+    # no consumer for longer than the idle window → release the orphan
+    assert _idle_release_due(False, last_consumer=1000.0, now=1121.0,
+                             idle_secs=_IDLE) is True
+
+
+def test_release_boundary_is_strictly_greater():
+    assert _idle_release_due(False, 1000.0, 1120.0, _IDLE) is False  # == window
+
+
+if __name__ == "__main__":
+    import traceback
+    _fail = 0
+    for _k, _v in sorted(globals().items()):
+        if _k.startswith("test_"):
+            try:
+                _v()
+                print(f"PASS {_k}")
+            except Exception:
+                _fail += 1
+                print(f"FAIL {_k}")
+                traceback.print_exc()
+    raise SystemExit(1 if _fail else 0)