python-aidot-cameras 0.15.3__tar.gz → 0.15.5__tar.gz

{python_aidot_cameras-0.15.3/python_aidot_cameras.egg-info → python_aidot_cameras-0.15.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.15.3
+Version: 0.15.5
 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.15.3 → python_aidot_cameras-0.15.5}/aidot_cameras/__main__.py

@@ -45,9 +45,18 @@ go2rtc.yaml example (SDES camera - native RTSP push, video + audio):
     streams:
       frontdoor: exec:aidot-go2rtc 8d2521ea... {output}
 
-For a DTLS camera (A000088) there is no RTSP-push path; pass an http serve URL
-(http://127.0.0.1:PORT/name.ts) and add it to go2rtc as an http-mpegts source -
-but this process must stay running to keep that serve bound.
+A DTLS camera (A000088) has no RTSP-push path, but a stdout producer works the
+same lazy way. Pass ``-`` as the output and this process writes MPEG-TS (video
+plus AAC audio) to stdout, which go2rtc's exec: source reads directly:
+
+    streams:
+      driveway: exec:aidot-go2rtc 7c89a5c1... -
+
+go2rtc then owns the lifecycle - spawn on the first viewer, kill when idle -
+exactly as it does with ``{output}`` for an SDES camera. An
+``http://host:port/name.ts`` output still works too: the older HTTP-listen
+serve, useful for a persistent consumer that is not go2rtc, but that process
+must stay running to keep the serve bound.
 """
 
 from __future__ import annotations
@@ -225,7 +234,21 @@ async def cmd_stream(dev_id: str, output_url: str) -> int:
 
         dc = client.get_device_client(device)
 
-        if not output_url.startswith("rtsp") and dc.is_sdes_camera:
+        if output_url == "-":
+            # Stdout producer: MPEG-TS on this process's stdout, for a go2rtc
+            # exec: source.  SDES cameras already have {output} (RTSP push) and
+            # do not take this path, so say which one to use rather than
+            # producing an empty stream.
+            if dc.is_sdes_camera:
+                sys.exit(
+                    f"{dev_id} is an SDES camera - '-' (stdout) is the DTLS "
+                    "producer path. Use {output} (RTSP push) instead."
+                )
+            _LOGGER.info(
+                "DTLS stdout mode: writing MPEG-TS (video + AAC audio) to "
+                "stdout for a go2rtc exec: consumer."
+            )
+        elif not output_url.startswith("rtsp") and dc.is_sdes_camera:
             _LOGGER.warning(
                 "SDES camera but output %r is not rtsp:// - the library will "
                 "HTTP-serve (video only by default) instead of pushing audio+video. "
@@ -235,7 +258,8 @@ async def cmd_stream(dev_id: str, output_url: str) -> int:
         if output_url.startswith("rtsp") and not dc.is_sdes_camera:
             sys.exit(
                 f"{dev_id} is a DTLS camera - the library has no RTSP-push path "
-                "for it. Use an http://host:port/name.ts serve URL instead."
+                "for it. Use '-' (stdout, for a go2rtc exec: source) or an "
+                "http://host:port/name.ts serve URL instead."
             )
 
         await dc.async_login()

{python_aidot_cameras-0.15.3 → python_aidot_cameras-0.15.5}/aidot_cameras/camera/client.py

@@ -4552,16 +4552,36 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
             # AIDOT_DTLS_RETRY_GATE_S and added dead latency after healthy drops.)
 
     async def _spawn_dtls_serve_ffmpeg(self, serve_url: Optional[str], stdin_fd: int):
-        """Launch ffmpeg to serve the mux thread's MPEG-TS (read from ``stdin_fd``)
-        on an HTTP-listen socket go2rtc pulls.  The stream is already cleanly
-        timestamped + AAC-muxed (with the gain/limiter applied) by PyAV, so
-        ffmpeg just copies and serves - re-encoding here dropped the live audio
-        (mpegts PMT-timing on the real-time pipe).  Returns the process, or None."""
+        """Launch ffmpeg to serve the mux thread's MPEG-TS (read from ``stdin_fd``).
+
+        The stream is already cleanly timestamped + AAC-muxed (with the
+        gain/limiter applied) by PyAV, so ffmpeg just copies and serves -
+        re-encoding here dropped the live audio (mpegts PMT-timing on the
+        real-time pipe).  Returns the process, or None.
+
+        Two destinations:
+
+        - ``serve_url == "-"`` -> STDOUT model: write MPEG-TS to this process's
+          own stdout (``pipe:1``), so a parent that spawned us - go2rtc's
+          ``exec:`` source - consumes the camera directly and owns the process
+          lifecycle (spawn on first viewer, kill on idle).  No listen port and
+          no cold-start relay, which is the DTLS analogue of the SDES
+          ``{output}`` RTSP push.  Logging already goes to stderr, so stdout
+          carries nothing but media.
+        - anything else -> HTTP-listen model, unchanged: serve on a ``-listen``
+          socket that go2rtc pulls.
+        """
         if not serve_url:
             return None
         if _ffmpeg_path() is None:
             _LOGGER.error("DTLS serve: %s", _FFMPEG_MISSING_MSG)
             return None
+        if serve_url == "-":
+            out_args = ["-f", "mpegts", "pipe:1"]
+            out_target = 1               # this process's real stdout
+        else:
+            out_args = ["-f", "mpegts", "-listen", "1", serve_url]
+            out_target = asyncio.subprocess.DEVNULL
         cmd = [
             "ffmpeg", "-y", "-loglevel", "warning",
             # Suppress input-side buffering: the PyAV mux already writes
@@ -4572,13 +4592,13 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
             # bursty/choppy audio pattern.  Matches the SDES serve's approach.
             "-fflags", "+nobuffer",
             "-i", "pipe:0",
-            "-c", "copy", "-f", "mpegts", "-listen", "1", serve_url,
+            "-c", "copy", *out_args,
         ]
         try:
             return await asyncio.create_subprocess_exec(
                 *cmd,
                 stdin=stdin_fd,
-                stdout=asyncio.subprocess.DEVNULL,
+                stdout=out_target,
                 stderr=asyncio.subprocess.DEVNULL,
             )
         except FileNotFoundError:

{python_aidot_cameras-0.15.3 → python_aidot_cameras-0.15.5}/aidot_cameras/camera/sdes.py

@@ -38,7 +38,12 @@ class SdesSession:
         teardown_requested=None,
         first_video_pt=None,
         first_audio_pt=None,
+        device_id=None,
     ) -> None:
+        # Which camera this session belongs to, for logging only.  Optional so
+        # an existing caller that does not pass it still works; the logs then
+        # read "?" exactly as they did before.
+        self._device_id  = device_id or "?"
         self._proc       = proc
         self._sdp_path   = sdp_path
         self._outgoing_q = outgoing_q
@@ -215,7 +220,8 @@ class SdesSession:
             or "Could not find codec parameters" in text
         )
         (_LOGGER.debug if expected_no_media else _LOGGER.warning)(
-            "ffmpeg SDES stderr:\n%s", text
+            "camera %s: ffmpeg SDES stderr:\n%s",
+            getattr(self, "_device_id", "?"), text
         )
 
     @staticmethod

{python_aidot_cameras-0.15.3 → python_aidot_cameras-0.15.5}/aidot_cameras/camera/sdes_open.py

@@ -2825,23 +2825,31 @@ class _SdesOpenMixin:
                                 _br_level = _classify_ffmpeg_exit(
                                     _br_rc, _br_teardown_requested
                                 )
+                                # Name the camera.  These lines used to carry no
+                                # device id at all, and this account runs several
+                                # SDES cameras at once, so a burst of exits could
+                                # not be attributed to one of them without extra
+                                # tooling - which sent a live investigation down
+                                # the wrong path once already.
+                                _br_dev = getattr(self, "device_id", "?")
                                 _br_msg = (
-                                    "SDES bridge: ffmpeg exited with code %d"
-                                    " - stopped by teardown"
+                                    "camera %s: SDES bridge: ffmpeg exited with"
+                                    " code %d - stopped by teardown"
                                     if _br_level < _log_br.WARNING else
-                                    "SDES bridge: ffmpeg exited with code %d"
-                                    " - stream ended"
+                                    "camera %s: SDES bridge: ffmpeg exited with"
+                                    " code %d - stream ended"
                                 )
                                 _log_br.getLogger(__name__).log(
-                                    _br_level, _br_msg, _br_rc
+                                    _br_level, _br_msg, _br_dev, _br_rc
                                 )
                                 if _br_level >= _log_br.WARNING:
                                     _serr_tail = getattr(
                                         _br_proc, "_aidot_stderr_tail", None)
                                     if _serr_tail:
                                         _log_br.getLogger(__name__).warning(
-                                            "SDES serve ffmpeg stderr (last %d"
-                                            " lines):\n%s", len(_serr_tail),
+                                            "camera %s: SDES serve ffmpeg stderr"
+                                            " (last %d lines):\n%s", _br_dev,
+                                            len(_serr_tail),
                                             "\n".join(_serr_tail),
                                         )
                             if _bridge_should_break(
@@ -4909,4 +4917,5 @@ class _SdesOpenMixin:
             teardown_requested=_teardown_holder,
             first_video_pt=_first_video_pt,
             first_audio_pt=_first_audio_pt,
+            device_id=getattr(self, "device_id", None),
         )

{python_aidot_cameras-0.15.3 → python_aidot_cameras-0.15.5}/pyproject.toml

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

{python_aidot_cameras-0.15.3 → python_aidot_cameras-0.15.5/python_aidot_cameras.egg-info}/PKG-INFO

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

@@ -90,6 +90,7 @@ tests/test_dtls_serve_decode_skip.py
 tests/test_dtls_serve_open_timeout.py
 tests/test_dtls_skip_signaling_wait.py
 tests/test_dtls_slow_probe.py
+tests/test_dtls_stdout_producer.py
 tests/test_egress_guard.py
 tests/test_env_seams.py
 tests/test_go2rtc.py

python_aidot_cameras-0.15.5/tests/test_dtls_stdout_producer.py

@@ -0,0 +1,77 @@
+"""The DTLS serve can write MPEG-TS to stdout for a go2rtc ``exec:`` source.
+
+SDES cameras get a lazily-managed producer for free: go2rtc spawns the process
+per ``{output}``, the library RTSP-pushes into it, and go2rtc kills it when the
+last viewer leaves. DTLS had no equivalent - it could only serve on an
+``-listen`` socket, which has to be bound before anyone asks for it and stays
+bound afterwards.
+
+``-`` closes that gap: ffmpeg writes to this process's own stdout, so whoever
+spawned us is the consumer and owns the lifecycle. Everything else about the
+serve is untouched, which is what these tests pin - a regression here would
+either break every existing HTTP-listen serve or silently send media to
+/dev/null.
+"""
+import asyncio
+import types
+
+import aidot_cameras.camera.client as client_mod
+from aidot_cameras.camera.client import CameraMixin
+
+
+def _spawn(monkeypatch, serve_url):
+    """Run the real _spawn_dtls_serve_ffmpeg, capturing what it would exec."""
+    seen = {}
+
+    async def _fake_exec(*cmd, stdin=None, stdout=None, stderr=None):
+        seen["cmd"] = list(cmd)
+        seen["stdout"] = stdout
+        seen["stdin"] = stdin
+        return object()
+
+    monkeypatch.setattr(client_mod, "_ffmpeg_path", lambda: "/usr/bin/ffmpeg")
+    monkeypatch.setattr(asyncio, "create_subprocess_exec", _fake_exec)
+    obj = types.SimpleNamespace()
+    fn = CameraMixin._spawn_dtls_serve_ffmpeg.__get__(obj)
+    proc = asyncio.run(fn(serve_url, 7))
+    return proc, seen
+
+
+def test_stdout_mode_writes_mpegts_to_this_process_stdout(monkeypatch):
+    proc, seen = _spawn(monkeypatch, "-")
+    assert proc is not None
+    assert seen["cmd"][-3:] == ["-f", "mpegts", "pipe:1"], seen["cmd"]
+    # fd 1, not DEVNULL: the media has to reach the parent that spawned us.
+    assert seen["stdout"] == 1, (
+        "stdout mode must hand ffmpeg this process's real stdout - anything "
+        "else sends the camera to nowhere while looking healthy"
+    )
+    assert "-listen" not in seen["cmd"]
+
+
+def test_http_listen_mode_is_unchanged(monkeypatch):
+    url = "http://127.0.0.1:18981/cam.ts"
+    proc, seen = _spawn(monkeypatch, url)
+    assert proc is not None
+    assert seen["cmd"][-4:] == ["-f", "mpegts", "-listen", "1", url][-4:]
+    assert seen["cmd"][-1] == url
+    assert "-listen" in seen["cmd"]
+    assert seen["stdout"] == asyncio.subprocess.DEVNULL, (
+        "the listen serve must keep stdout discarded; writing media to our own "
+        "stdout there would corrupt whatever the parent reads"
+    )
+
+
+def test_both_modes_still_copy_from_the_mux_pipe(monkeypatch):
+    for url in ("-", "http://127.0.0.1:1/x.ts"):
+        _proc, seen = _spawn(monkeypatch, url)
+        cmd = seen["cmd"]
+        assert cmd[:2] == ["ffmpeg", "-y"]
+        assert "-i" in cmd and cmd[cmd.index("-i") + 1] == "pipe:0"
+        assert "-c" in cmd and cmd[cmd.index("-c") + 1] == "copy"
+        assert seen["stdin"] == 7
+
+
+def test_no_serve_url_still_returns_none(monkeypatch):
+    proc, seen = _spawn(monkeypatch, "")
+    assert proc is None and "cmd" not in seen

{python_aidot_cameras-0.15.3 → python_aidot_cameras-0.15.5}/tests/test_sdes_ffmpeg_stderr_log.py

@@ -12,8 +12,10 @@ import types
 from aidot_cameras.camera.sdes import SdesSession
 
 
-def _log_fn(last_media):
-    obj = types.SimpleNamespace(last_media_monotonic=last_media)
+def _log_fn(last_media, device_id="dev-abc"):
+    obj = types.SimpleNamespace(
+        last_media_monotonic=last_media, _device_id=device_id
+    )
     return SdesSession._log_ffmpeg_stderr.__get__(obj)
 
 
@@ -31,6 +33,18 @@ def test_no_media_expected_shape_logs_debug(caplog):
         assert recs and recs[0].levelno == logging.DEBUG, msg
 
 
+def test_the_log_names_the_camera(caplog):
+    """Several SDES cameras stream at once; an unattributed line is near-useless.
+
+    A burst of these lines with no device id could not be pinned to a camera
+    during a live investigation, which cost real time and one wrong conclusion.
+    """
+    with caplog.at_level(logging.DEBUG, logger="aidot_cameras.camera.sdes"):
+        _log_fn(1.0, device_id="12b144cb12da")(b"Error writing trailer")
+    recs = _stderr_records(caplog)
+    assert recs and "12b144cb12da" in recs[0].getMessage()
+
+
 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_cameras.camera.sdes"):

{python_aidot_cameras-0.15.3 → python_aidot_cameras-0.15.5}/tests/test_sdes_serve_stderr_drain.py

@@ -59,6 +59,35 @@ def test_stderr_none_is_safe() -> None:
     assert _tail(proc) == []
 
 
+def test_every_piped_spawn_installs_the_drain() -> None:
+    """A serve spawned with an un-drained ``stderr=PIPE`` is the outage itself.
+
+    There are two serve-spawn sites (cold open and key-restart), and the bug
+    shipped because a pipe was opened at one of them with nothing reading it.
+    A third site, or a drain call deleted from an existing one, reintroduces it
+    exactly - and no behavioural test can see the difference until ffmpeg has
+    written ~64KB, which is far past where a unit test looks. Pin the source.
+    """
+    import inspect
+
+    from aidot_cameras.camera import sdes_open
+
+    src = inspect.getsource(sdes_open).splitlines()
+    spawns = [i for i, line in enumerate(src) if "stderr=subprocess.PIPE" in line]
+    assert spawns, (
+        "no piped spawn found in sdes_open - if the serve stopped using a pipe "
+        "this guard is obsolete, but do not delete it without checking why"
+    )
+    for line_no in spawns:
+        window = "\n".join(src[line_no:line_no + 12])
+        assert "_start_serve_stderr_drain(" in window, (
+            f"{sdes_open.__name__}:{line_no + 1} spawns with stderr=PIPE and "
+            "nothing drains it within the next few lines. An un-drained pipe "
+            "fills at ~64KB and blocks ffmpeg on its next write, which kills "
+            "the RTSP publisher and 404s every viewer"
+        )
+
+
 class _TornDownProc:
     """A serve proc whose stderr pipe the drainer already emptied.
 

{python_aidot_cameras-0.15.3 → python_aidot_cameras-0.15.5}/tests/test_sdes_teardown_exit_log.py

@@ -61,6 +61,27 @@ def test_reap_sets_teardown_flag_before_kill():
     )
 
 
+def test_the_bridge_exit_log_names_the_camera():
+    """The exit line is emitted from a closure the tests cannot call directly.
+
+    It is still worth pinning: this account streams several SDES cameras at
+    once, and while these lines carried no device id a burst of exits could not
+    be attributed to a camera at all. Assert the format string takes one, and
+    that the session is handed the id it needs for its own stderr log.
+    """
+    src = inspect.getsource(sdes_open)
+    assert "camera %s: SDES bridge: ffmpeg exited" in src, (
+        "the bridge exit log lost its device id - a burst of these is "
+        "unattributable without it"
+    )
+    assert "camera %s: SDES serve ffmpeg stderr" in src
+    start = src.index("return SdesSession(")
+    assert "device_id=" in src[start:start + 800], (
+        "SdesSession is constructed without a device_id, so its own stderr "
+        "log cannot name the camera"
+    )
+
+
 class _FakeProc:
     def __init__(self):
         self._alive = True