python-aidot-cameras 0.11.8__tar.gz → 0.11.10__tar.gz

{python_aidot_cameras-0.11.8/python_aidot_cameras.egg-info → python_aidot_cameras-0.11.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.11.8
+Version: 0.11.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.11.10/aidot/__init__.py

@@ -0,0 +1,54 @@
+"""AiDot camera and device library."""
+
+import logging as _logging
+
+from .client import AidotClient
+from .device_client import DeviceClient
+from .discover import Discover
+from .exceptions import (
+    AidotAuthFailed,
+    AidotAuthTokenExpired,
+    AidotCameraBusy,
+    AidotError,
+    AidotNotLogin,
+    AidotOSError,
+    AidotUserOrPassIncorrect,
+    HTTPError,
+    InvalidHost,
+    InvalidURL,
+)
+
+# Cap the per-packet loggers that flood the log at DEBUG.  When a user enables
+# DEBUG on the parent ``aidot`` logger to diagnose the integration, these emit
+# thousands of lines per second (in one capture, 99% of all lines) - and on a
+# microSD Home Assistant host that log I/O can starve the recorder.  Cap them at
+# INFO so enabling ``aidot`` DEBUG stays useful; the diagnostically valuable
+# DEBUG (DTLS, SCTP/DCEP, ICE connection state) still flows.  This covers both the
+# vendored aiortc RTP receiver/sender AND the external ``aioice`` package's
+# per-STUN/TURN-packet loggers (aioice is a real dependency, not vendored, so it
+# is not under ``aidot._vendor``).  Respect an explicit level if the user set one.
+for _chatty in (
+    "aidot._vendor.aiortc.rtcrtpreceiver",
+    "aidot._vendor.aiortc.rtcrtpsender",
+    "aioice.ice",
+    "aioice.turn",
+):
+    _lg = _logging.getLogger(_chatty)
+    if _lg.level == _logging.NOTSET:
+        _lg.setLevel(_logging.INFO)
+
+__all__ = [
+    "AidotAuthFailed",
+    "AidotAuthTokenExpired",
+    "AidotCameraBusy",
+    "AidotClient",
+    "AidotError",
+    "AidotNotLogin",
+    "AidotOSError",
+    "AidotUserOrPassIncorrect",
+    "DeviceClient",
+    "Discover",
+    "HTTPError",
+    "InvalidHost",
+    "InvalidURL",
+]

{python_aidot_cameras-0.11.8 → python_aidot_cameras-0.11.10}/aidot/camera/sdes.py

@@ -132,6 +132,29 @@ class SdesSession:
         """time.monotonic() of the last media packet forwarded, 0.0 if none yet."""
         return self._media_progress[0]
 
+    def _log_ffmpeg_stderr(self, stderr_bytes: bytes) -> None:
+        """Log ffmpeg's captured stderr at a level that matches what happened.
+
+        The common NO_MEDIA case - the camera's SRTP never arrives, so ffmpeg
+        finds no keyframe and writes an empty file - would otherwise spam a
+        WARNING on every serve retry for a camera that never delivers media.
+        Demote to debug ONLY when no media ever arrived AND the stderr is that
+        expected shape.  Anything else - media WAS flowing (a genuine mid-stream
+        error), or an unexpected ffmpeg failure with no media (malformed SDP, bad
+        SRTP key, protocol reject) - still logs at WARNING, so real problems are
+        not hidden.  Unknown ffmpeg wording degrades safely to WARNING.
+        """
+        if not stderr_bytes:
+            return
+        text = stderr_bytes.decode(errors="replace")
+        expected_no_media = self.last_media_monotonic == 0.0 and (
+            "Output file is empty" in text
+            or "Could not find codec parameters" in text
+        )
+        (_LOGGER.debug if expected_no_media else _LOGGER.warning)(
+            "ffmpeg SDES stderr:\n%s", text
+        )
+
     @staticmethod
     def is_stalled(
         last_media: float,
@@ -213,8 +236,7 @@ class SdesSession:
                 self._proc.stderr.close()
             except Exception:
                 _LOGGER.debug("swallowed exception in %s", 'stop', exc_info=True)
-        if stderr_bytes:
-            _LOGGER.warning("ffmpeg SDES stderr:\n%s", stderr_bytes.decode(errors="replace"))
+        self._log_ffmpeg_stderr(stderr_bytes)
         import os
         try:
             os.unlink(self._sdp_path)

{python_aidot_cameras-0.11.8 → python_aidot_cameras-0.11.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-aidot-cameras"
-version = "0.11.8"
+version = "0.11.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.11.8 → python_aidot_cameras-0.11.10/python_aidot_cameras.egg-info}/PKG-INFO

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

@@ -105,6 +105,7 @@ tests/test_retry_policy.py
 tests/test_sdes_adaptive.py
 tests/test_sdes_echo_wait_timeout.py
 tests/test_sdes_fast_liveplay.py
+tests/test_sdes_ffmpeg_stderr_log.py
 tests/test_sdes_idle_release.py
 tests/test_sdes_open_cleanup.py
 tests/test_sdes_serve_audio.py

python_aidot_cameras-0.11.10/tests/test_logging_caps.py

@@ -0,0 +1,31 @@
+"""Importing the library caps the chatty per-packet loggers.
+
+aiortc's RTP receiver/sender log every media packet at DEBUG, and the external
+aioice package logs every STUN/TURN packet. Enabling DEBUG on the parent ``aidot``
+logger (the normal way to diagnose the integration) would otherwise unleash
+thousands of lines per second - which on a microSD host can starve the recorder.
+The package init caps those loggers at INFO so DEBUG on ``aidot`` stays useful.
+"""
+import logging
+
+import aidot  # noqa: F401 - import triggers the logger caps
+
+CAPPED = (
+    "aidot._vendor.aiortc.rtcrtpreceiver",
+    "aidot._vendor.aiortc.rtcrtpsender",
+    "aioice.ice",
+    "aioice.turn",
+)
+
+
+def test_packet_loggers_capped_to_info():
+    for name in CAPPED:
+        lg = logging.getLogger(name)
+        assert lg.level == logging.INFO, f"{name} not capped (level={lg.level})"
+
+
+def test_aidot_debug_does_not_unleash_the_packet_firehose():
+    # Even with the parent 'aidot' logger at DEBUG, the per-packet DEBUG is off.
+    logging.getLogger("aidot").setLevel(logging.DEBUG)
+    for name in CAPPED:
+        assert not logging.getLogger(name).isEnabledFor(logging.DEBUG), f"{name} still emits DEBUG"

python_aidot_cameras-0.11.10/tests/test_sdes_ffmpeg_stderr_log.py

@@ -0,0 +1,52 @@
+"""ffmpeg SDES stderr log level: quiet the expected NO_MEDIA case, keep real errors.
+
+A camera whose SRTP never reaches us (NO_MEDIA - e.g. media not traversing the
+relay) produces the expected "could not find codec parameters / empty output"
+ffmpeg stderr on every serve retry. That must log at DEBUG (not spam WARNING).
+But a genuine ffmpeg error - whether media was flowing, or an unexpected failure
+with no media - still logs at WARNING so real problems are not hidden.
+"""
+import logging
+import types
+
+from aidot.camera.sdes import SdesSession
+
+
+def _log_fn(last_media):
+    obj = types.SimpleNamespace(last_media_monotonic=last_media)
+    return SdesSession._log_ffmpeg_stderr.__get__(obj)
+
+
+def _stderr_records(caplog):
+    return [r for r in caplog.records if "ffmpeg SDES stderr" in r.getMessage()]
+
+
+def test_no_media_expected_shape_logs_debug(caplog):
+    for msg in (b"...Output file is empty, nothing was encoded",
+                b"Could not find codec parameters for stream 1 (Video: h264, none)"):
+        caplog.clear()
+        with caplog.at_level(logging.DEBUG, logger="aidot.camera.sdes"):
+            _log_fn(0.0)(msg)
+        recs = _stderr_records(caplog)
+        assert recs and recs[0].levelno == logging.DEBUG, msg
+
+
+def test_no_media_unexpected_error_still_warns(caplog):
+    # No media, but NOT the expected empty-output shape -> a real ffmpeg failure.
+    with caplog.at_level(logging.DEBUG, logger="aidot.camera.sdes"):
+        _log_fn(0.0)(b"/tmp/x.sdp: Permission denied")
+    recs = _stderr_records(caplog)
+    assert recs and recs[0].levelno == logging.WARNING
+
+
+def test_media_flowed_logs_warning(caplog):
+    with caplog.at_level(logging.DEBUG, logger="aidot.camera.sdes"):
+        _log_fn(1234.5)(b"Could not find codec parameters for stream 1")
+    recs = _stderr_records(caplog)
+    assert recs and recs[0].levelno == logging.WARNING
+
+
+def test_empty_stderr_logs_nothing(caplog):
+    with caplog.at_level(logging.DEBUG, logger="aidot.camera.sdes"):
+        _log_fn(0.0)(b"")
+    assert _stderr_records(caplog) == []

python_aidot_cameras-0.11.8/aidot/__init__.py

@@ -1,46 +0,0 @@
-"""AiDot camera and device library."""
-
-import logging as _logging
-
-from .client import AidotClient
-from .device_client import DeviceClient
-from .discover import Discover
-from .exceptions import (
-    AidotAuthFailed,
-    AidotAuthTokenExpired,
-    AidotCameraBusy,
-    AidotError,
-    AidotNotLogin,
-    AidotOSError,
-    AidotUserOrPassIncorrect,
-    HTTPError,
-    InvalidHost,
-    InvalidURL,
-)
-
-# The vendored aiortc RTP receiver/sender log EVERY media packet at DEBUG.  When a
-# user enables DEBUG on the parent ``aidot`` logger to diagnose the integration,
-# that becomes thousands of lines per second and floods the logs (in one capture,
-# 99% of all lines).  Cap just those two per-packet loggers at INFO so enabling
-# ``aidot`` DEBUG stays useful - the diagnostically valuable aiortc DEBUG (DTLS,
-# ICE, SCTP/DCEP) still flows.  Respect an explicit level if the user set one.
-for _chatty in ("aidot._vendor.aiortc.rtcrtpreceiver", "aidot._vendor.aiortc.rtcrtpsender"):
-    _lg = _logging.getLogger(_chatty)
-    if _lg.level == _logging.NOTSET:
-        _lg.setLevel(_logging.INFO)
-
-__all__ = [
-    "AidotAuthFailed",
-    "AidotAuthTokenExpired",
-    "AidotCameraBusy",
-    "AidotClient",
-    "AidotError",
-    "AidotNotLogin",
-    "AidotOSError",
-    "AidotUserOrPassIncorrect",
-    "DeviceClient",
-    "Discover",
-    "HTTPError",
-    "InvalidHost",
-    "InvalidURL",
-]

python_aidot_cameras-0.11.8/tests/test_logging_caps.py

@@ -1,22 +0,0 @@
-"""Importing the library caps the vendored aiortc per-packet loggers.
-
-aiortc's RTP receiver/sender log every media packet at DEBUG. Enabling DEBUG on
-the parent ``aidot`` logger (the normal way to diagnose the integration) would
-otherwise unleash thousands of lines per second. The package init caps just those
-two loggers at INFO so DEBUG on ``aidot`` stays useful without the firehose.
-"""
-import logging
-
-import aidot  # noqa: F401 - import triggers the logger caps
-
-
-def test_vendored_aiortc_packet_loggers_capped_to_info():
-    for name in (
-        "aidot._vendor.aiortc.rtcrtpreceiver",
-        "aidot._vendor.aiortc.rtcrtpsender",
-    ):
-        lg = logging.getLogger(name)
-        assert lg.level == logging.INFO, f"{name} not capped (level={lg.level})"
-        # Even with the parent 'aidot' logger at DEBUG, the per-packet DEBUG is off.
-        logging.getLogger("aidot").setLevel(logging.DEBUG)
-        assert not lg.isEnabledFor(logging.DEBUG), f"{name} still emits DEBUG"