python-aidot-cameras 0.9.0__tar.gz → 0.9.2__tar.gz

{python_aidot_cameras-0.9.0/src/python_aidot_cameras.egg-info → python_aidot_cameras-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.9.0
+Version: 0.9.2
 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
@@ -11,11 +11,11 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: aiohttp
+Requires-Dist: aiohttp>=3.9
 Requires-Dist: paho-mqtt>=2.0
-Requires-Dist: cryptography
-Requires-Dist: pycryptodome
-Requires-Dist: dacite
+Requires-Dist: cryptography>=42.0
+Requires-Dist: pycryptodome>=3.20
+Requires-Dist: dacite>=1.8
 Provides-Extra: webrtc
 Requires-Dist: aiortc>=1.9.0; extra == "webrtc"
 Requires-Dist: aioice<0.12,>=0.9.0; extra == "webrtc"

{python_aidot_cameras-0.9.0 → python_aidot_cameras-0.9.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-aidot-cameras"
-version = "0.9.0"
+version = "0.9.2"
 description = "Control AiDot/Leedarson WiFi lights and cameras (WebRTC streaming, two-way audio, PTZ, controls)"
 readme = "README.md"
 license = "MIT"
@@ -15,12 +15,17 @@ classifiers = [
     "Programming Language :: Python :: 3",
     "Operating System :: OS Independent",
 ]
+# Conservative lower bounds only - no upper caps. When installed under Home
+# Assistant, HA core pins aiohttp/cryptography itself; an upper cap here would
+# fight HA's resolver on the box. Floors just exclude ancient releases while
+# leaving the consumer (or HA) free to use a newer version. Bump a floor only
+# after re-validating against it.
 dependencies = [
-    "aiohttp",
+    "aiohttp>=3.9",
     "paho-mqtt>=2.0",
-    "cryptography",
-    "pycryptodome",
-    "dacite",
+    "cryptography>=42.0",
+    "pycryptodome>=3.20",
+    "dacite>=1.8",
 ]
 
 [project.optional-dependencies]

{python_aidot_cameras-0.9.0 → python_aidot_cameras-0.9.2}/src/aidot/camera/client.py

@@ -1467,7 +1467,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
             try:
                 self.status.update_from_camera_attributes({attr: value})
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", 'async_set_device_attribute', exc_info=True)
+                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), 'async_set_device_attribute', exc_info=True)
         return ok
 
     async def async_trigger_device_action(
@@ -1542,7 +1542,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
             try:
                 await self.async_wake_camera()
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", 'async_get_camera_attributes', exc_info=True)
+                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), 'async_get_camera_attributes', exc_info=True)
 
         smarthome_auth = await self._async_get_smarthome_auth()
         mqtt_user = (smarthome_auth or {}).get("mqttUser") or str(self.user_id)
@@ -1929,7 +1929,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                 try:
                     _os.unlink(_tmp_ts)
                 except Exception:
-                    _LOGGER.debug("camera %s: swallowed exception", 'async_snapshot', exc_info=True)
+                    _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), 'async_snapshot', exc_info=True)
 
         # ── DTLS path: on_frame callback delivers frames from aiortc ─────── #
         frame_event = _asyncio.Event()
@@ -2002,21 +2002,21 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
             try:
                 await g_task
             except (asyncio.CancelledError, Exception):
-                _LOGGER.debug("camera %s: swallowed exception", 'async_stop_streaming', exc_info=True)
+                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), 'async_stop_streaming', exc_info=True)
         await self._deregister_go2rtc()
         session, self._stream_session = self._stream_session, None
         if session is not None:
             try:
                 await session.stop()
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", 'async_stop_streaming', exc_info=True)
+                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), 'async_stop_streaming', exc_info=True)
         task, self._stream_task = self._stream_task, None
         if task is not None and not task.done():
             task.cancel()
             try:
                 await task
             except (asyncio.CancelledError, Exception):
-                _LOGGER.debug("camera %s: swallowed exception", 'async_stop_streaming', exc_info=True)
+                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), 'async_stop_streaming', exc_info=True)
         # Reap a persistent-MQTT stream drain that no session stopped (e.g. an
         # open cancelled mid-handshake) so its handler is removed from the shared
         # connection and its blocked executor thread is released.
@@ -2041,13 +2041,13 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
             try:
                 outq.put_nowait(None)   # release the executor thread in outgoing_q.get
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", '_reap_stream_drain', exc_info=True)
+                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_reap_stream_drain', exc_info=True)
         if not drain.done():
             drain.cancel()
         try:
             await drain
         except (asyncio.CancelledError, Exception):
-            _LOGGER.debug("camera %s: swallowed exception", '_reap_stream_drain', exc_info=True)
+            _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_reap_stream_drain', exc_info=True)
 
     async def async_start_motion_polling(
         self, callback: Callable, interval: float = 30.0, lookback_s: int = 600,
@@ -2087,7 +2087,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
             try:
                 await task
             except (asyncio.CancelledError, Exception):
-                _LOGGER.debug("camera %s: swallowed exception", 'async_stop_motion_polling', exc_info=True)
+                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), 'async_stop_motion_polling', exc_info=True)
 
     async def _motion_poll_loop(self, lookback_s: int) -> None:
         """Background: poll the cloud event list; fire callback on newly-recorded events."""
@@ -2241,7 +2241,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
         try:
             await self.async_wait_serve_ready(timeout=40.0)
         except Exception:
-            _LOGGER.debug("camera %s: swallowed exception", '_register_with_go2rtc', exc_info=True)
+            _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]}"
@@ -2254,7 +2254,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                 _LOGGER.info(
                     "camera %s: preferring go2rtc stream -> %s", self.device_id, url)
         except Exception:
-            _LOGGER.debug("camera %s: swallowed exception", '_register_with_go2rtc', exc_info=True)
+            _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_register_with_go2rtc', exc_info=True)
 
     async def _deregister_go2rtc(self) -> None:
         """Remove this camera's stream from go2rtc (best-effort)."""
@@ -2269,7 +2269,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
             async with aiohttp.ClientSession() as _s2:
                 await Go2rtcClient(_s2, base).remove_stream(name)
         except Exception:
-            _LOGGER.debug("camera %s: swallowed exception", '_deregister_go2rtc', exc_info=True)
+            _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_deregister_go2rtc', exc_info=True)
 
     async def async_wait_serve_ready(self, timeout: float = 20.0) -> bool:
         """Wait until the DTLS serve is bound + serving (or ``timeout``).
@@ -2520,7 +2520,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                 try:
                     await session.stop()
                 except Exception:
-                    _LOGGER.debug("camera %s: swallowed exception", '_sdes_keepalive_loop', exc_info=True)
+                    _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_sdes_keepalive_loop', exc_info=True)
                 self._streaming_active = False
                 self._keepalive_rtsp_url = None
                 self._serve_ready.clear()
@@ -2540,7 +2540,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
             try:
                 await session.stop()
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", '_sdes_keepalive_loop', exc_info=True)
+                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_sdes_keepalive_loop', exc_info=True)
 
             # Adaptive bookkeeping: a fast attempt that never delivered media
             # latches the loop onto the full relay path for its remaining opens.
@@ -2651,7 +2651,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
             try:
                 await session.stop()
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", '_on_frame', exc_info=True)
+                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_on_frame', exc_info=True)
 
             if self._streaming_active:
                 # Reset backoff if this session produced frames (a normal drop
@@ -2707,7 +2707,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                         except Exception:
                             pass  # full -> drop (PLI re-arms a GOP)
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", '_tap_put', exc_info=True)
+                _LOGGER.debug("swallowed exception in %s", '_tap_put', exc_info=True)
             return _orig_put(task, *a, **k)
 
         _qd.put = _tap_put
@@ -3229,7 +3229,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                     try:
                         wfile.close()
                     except Exception:
-                        _LOGGER.debug("camera %s: swallowed exception", '_pc_dead', exc_info=True)
+                        _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_pc_dead', exc_info=True)
                     wfile = None
                     mux_thread.join(timeout=2.0)
                     mux_thread = stop_flag = None
@@ -3248,7 +3248,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                     try:
                         wfile.close()
                     except Exception:
-                        _LOGGER.debug("camera %s: swallowed exception", '_pc_dead', exc_info=True)
+                        _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_pc_dead', exc_info=True)
                 if mux_thread is not None:
                     mux_thread.join(timeout=2.0)
                 _terminate_proc(proc)  # never orphan ffmpeg on teardown
@@ -3256,7 +3256,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                 try:
                     await session.stop()
                 except Exception:
-                    _LOGGER.debug("camera %s: swallowed exception", '_pc_dead', exc_info=True)
+                    _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_pc_dead', exc_info=True)
 
             if cancelled:
                 return

{python_aidot_cameras-0.9.0 → python_aidot_cameras-0.9.2}/src/aidot/camera/models.py

@@ -102,7 +102,7 @@ class CameraStatusData(DeviceStatusData):
             try:
                 self.battery_remaining = int(v)
             except (ValueError, TypeError):
-                _LOGGER.debug("camera %s: swallowed exception", 'update', exc_info=True)
+                _LOGGER.debug("swallowed exception in %s", 'update', exc_info=True)
         if (v := attr.get("Occupancy")) is not None:
             self.occupancy = bool(int(v))
         if (v := attr.get("SDcardStatus")) is not None:
@@ -111,7 +111,7 @@ class CameraStatusData(DeviceStatusData):
             try:
                 self.wifi_rssi = int(v)
             except (ValueError, TypeError):
-                _LOGGER.debug("camera %s: swallowed exception", 'update', exc_info=True)
+                _LOGGER.debug("swallowed exception in %s", 'update', exc_info=True)
 
     # Cloud "properties" keys that belong to lights, not cameras.  A camera's
     # image "Dimming" must not be read as a light brightness (and could TypeError
@@ -163,7 +163,7 @@ class CameraDeviceInformation(DeviceInformation):
                             if isinstance(codes, list):
                                 self.ptz_directions = [int(c) for c in codes]
                         except Exception:
-                            _LOGGER.debug("camera %s: swallowed exception", '__init__', exc_info=True)
+                            _LOGGER.debug("swallowed exception in %s", '__init__', exc_info=True)
 
 
 @dataclass

{python_aidot_cameras-0.9.0 → python_aidot_cameras-0.9.2}/src/aidot/camera/playback.py

@@ -291,7 +291,7 @@ class CloudPlaybackSession:
                 self._writer.close()
                 await self._writer.wait_closed()
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", 'stop', exc_info=True)
+                _LOGGER.debug("swallowed exception in %s", 'stop', exc_info=True)
             self._writer = None
             self._reader = None
 
@@ -480,6 +480,6 @@ class LiveStreamSession:
                 self._writer.close()
                 await self._writer.wait_closed()
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", '_cleanup', exc_info=True)
+                _LOGGER.debug("swallowed exception in %s", '_cleanup', exc_info=True)
             self._writer = None
             self._reader = None

{python_aidot_cameras-0.9.0 → python_aidot_cameras-0.9.2}/src/aidot/camera/protocol.py

@@ -302,13 +302,13 @@ def _compress_sdp_for_camera(sdp: str) -> str:
                     try:
                         seen["H264/90000_pt"] = ln.split(":")[1].split(" ")[0]
                     except Exception:
-                        _LOGGER.debug("camera %s: swallowed exception", 'keep', exc_info=True)
+                        _LOGGER.debug("swallowed exception in %s", 'keep', exc_info=True)
                 elif "H265/90000" in ln and seen.get("H265/90000") is None:
                     keep(ln, "H265/90000")
                     try:
                         seen["H265/90000_pt"] = ln.split(":")[1].split(" ")[0]
                     except Exception:
-                        _LOGGER.debug("camera %s: swallowed exception", 'keep', exc_info=True)
+                        _LOGGER.debug("swallowed exception in %s", 'keep', exc_info=True)
                 elif "apt=" in ln:
                     try:
                         apt = ln.split("apt=")[1].strip()
@@ -499,7 +499,7 @@ def _terminate_proc(proc) -> None:
         if proc.returncode is None:
             proc.terminate()
     except Exception:
-        _LOGGER.debug("camera %s: swallowed exception", '_terminate_proc', exc_info=True)
+        _LOGGER.debug("swallowed exception in %s", '_terminate_proc', exc_info=True)
 
 
 _XDG_CONFIG_HOME = os.environ.get("XDG_CONFIG_HOME") or os.path.join(
@@ -897,6 +897,8 @@ def _dtls_av_mux_run(vq, aq, out_fileobj, progress, stop_flag) -> None:
         have_audio = False
     v0 = [None]
     a_pts = [0]
+    a_rtp0 = [None]      # first audio RTP timestamp (8 kHz units), for gap detection
+    a_in = [0]           # 8 kHz samples emitted to the resampler so far (incl. concealed)
     vstarted = [False]
 
     def _flush_video():
@@ -918,7 +920,7 @@ def _dtls_av_mux_run(vq, aq, out_fileobj, progress, stop_flag) -> None:
                 out.mux(pkt)
                 progress[0] = _t.monotonic()
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", '_flush_video', exc_info=True)
+                _LOGGER.debug("swallowed exception in %s", '_flush_video', exc_info=True)
 
     def _flush_audio(drain=False):
         if not have_audio:
@@ -934,7 +936,35 @@ def _dtls_av_mux_run(vq, aq, out_fileobj, progress, stop_flag) -> None:
                     data, _ts = aq.get_nowait()
                 except _q.Empty:
                     break
+                # Lock audio to its RTP clock.  The camera's PCMA RTP timestamp is
+                # an 8 kHz sample count; on packet loss it jumps ahead of the
+                # samples we've actually decoded.  Without filling that gap the
+                # audio timeline silently COMPRESSES (the lost time vanishes), so
+                # audio runs ahead of the RTP-timestamped video -> growing A/V
+                # desync and player jitter-buffer resyncs, heard as choppiness.
+                # Conceal the gap with silence (PLC) through the same stateful
+                # resampler, mirroring what the video path does with its 90 kHz
+                # timestamps.  Lossless streams have _gap == 0 (no-op).
+                if _np is not None:
+                    if a_rtp0[0] is None:
+                        a_rtp0[0] = int(_ts)
+                    _expected = (int(_ts) - a_rtp0[0]) & 0xFFFFFFFF
+                    _gap = _expected - a_in[0]
+                    if _gap < 0 or _gap > 8000 * 5:
+                        a_in[0] = _expected  # wrap / stream reset -> resync, no fill
+                    elif _gap >= 160:  # >= 20 ms missing: conceal with silence
+                        try:
+                            _sil = _np.zeros((1, int(_gap)), dtype=_np.int16)
+                            _sfr = av.AudioFrame.from_ndarray(
+                                _sil, format="s16", layout="mono")
+                            _sfr.sample_rate = 8000
+                            for _rfr in resampler.resample(_sfr):
+                                fifo.write(_rfr)
+                            a_in[0] += int(_gap)
+                        except Exception:
+                            _LOGGER.debug("swallowed exception in %s", '_flush_audio', exc_info=True)
                 for fr in adec.decode(av.Packet(data)):
+                    _ndec = fr.samples
                     fr.pts = None
                     if _np is not None:
                         try:
@@ -961,11 +991,12 @@ def _dtls_av_mux_run(vq, aq, out_fileobj, progress, stop_flag) -> None:
                             _g.sample_rate = 8000
                             fr = _g
                         except Exception:
-                            _LOGGER.debug("camera %s: swallowed exception", '_flush_audio', exc_info=True)
+                            _LOGGER.debug("swallowed exception in %s", '_flush_audio', exc_info=True)
                     for rfr in resampler.resample(fr):  # 8k PCMA -> 48k fltp
                         fifo.write(rfr)
+                    a_in[0] += _ndec
         except Exception:
-            _LOGGER.debug("camera %s: swallowed exception", '_flush_audio', exc_info=True)
+            _LOGGER.debug("swallowed exception in %s", '_flush_audio', exc_info=True)
         while True:
             fr = fifo.read(1024)   # AAC wants 1024-sample frames
             if fr is None:
@@ -1009,7 +1040,7 @@ def _dtls_av_mux_run(vq, aq, out_fileobj, progress, stop_flag) -> None:
                     out.mux(opkt)
                     progress[0] = _t.monotonic()
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", '_flush_audio', exc_info=True)
+                _LOGGER.debug("swallowed exception in %s", '_flush_audio', exc_info=True)
 
     while not stop_flag.is_set():
         _flush_video()
@@ -1022,11 +1053,11 @@ def _dtls_av_mux_run(vq, aq, out_fileobj, progress, stop_flag) -> None:
             for opkt in aenc.encode(None):  # flush
                 out.mux(opkt)
     except Exception:
-        _LOGGER.debug("camera %s: swallowed exception", '_dtls_av_mux_run', exc_info=True)
+        _LOGGER.debug("swallowed exception in %s", '_dtls_av_mux_run', exc_info=True)
     try:
         out.close()
     except Exception:
-        _LOGGER.debug("camera %s: swallowed exception", '_dtls_av_mux_run', exc_info=True)
+        _LOGGER.debug("swallowed exception in %s", '_dtls_av_mux_run', exc_info=True)
 
 
 def _h264_has_keyframe(data: bytes) -> bool:
@@ -1170,7 +1201,7 @@ def _mqtt_session_sync(
         try:
             client.disconnect()
         except Exception:
-            _LOGGER.debug("camera %s: swallowed exception", '_on_log', exc_info=True)
+            _LOGGER.debug("swallowed exception in %s", '_on_log', exc_info=True)
         return [], status
 
     if not status["connected"]:
@@ -1182,7 +1213,7 @@ def _mqtt_session_sync(
         try:
             client.disconnect()
         except Exception:
-            _LOGGER.debug("camera %s: swallowed exception", '_on_log', exc_info=True)
+            _LOGGER.debug("swallowed exception in %s", '_on_log', exc_info=True)
         return [], status
 
     _LOGGER.info("_mqtt_session: connected to %s:%d clientId=%s", hostname, port, client_id)
@@ -1199,7 +1230,7 @@ def _mqtt_session_sync(
         try:
             on_ready(status)
         except Exception:
-            _LOGGER.debug("camera %s: swallowed exception", '_on_log', exc_info=True)
+            _LOGGER.debug("swallowed exception in %s", '_on_log', exc_info=True)
 
     collected = []
     deadline  = _time.monotonic() + duration
@@ -1222,7 +1253,7 @@ def _mqtt_session_sync(
                         try:
                             client.disconnect()
                         except Exception:
-                            _LOGGER.debug("camera %s: swallowed exception", '_on_log', exc_info=True)
+                            _LOGGER.debug("swallowed exception in %s", '_on_log', exc_info=True)
                         return collected, status
                     pub_topic, pub_payload = out
                     client.publish(pub_topic, pub_payload)
@@ -1235,13 +1266,13 @@ def _mqtt_session_sync(
             try:
                 on_message(*item)
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", '_on_log', exc_info=True)
+                _LOGGER.debug("swallowed exception in %s", '_on_log', exc_info=True)
 
     client.loop_stop()
     try:
         client.disconnect()
     except Exception:
-        _LOGGER.debug("camera %s: swallowed exception", '_mqtt_session_sync', exc_info=True)
+        _LOGGER.debug("swallowed exception in %s", '_mqtt_session_sync', exc_info=True)
     return collected, status
 
 
@@ -1566,7 +1597,7 @@ async def _mqtt_get_playback_server_info(
                 pl["serverIP"] = pl.get("serverIP") or pl.get("serverIp")
                 result_holder.append(pl)
         except Exception:
-            _LOGGER.debug("camera %s: swallowed exception", '_check', exc_info=True)
+            _LOGGER.debug("swallowed exception in %s", '_check', exc_info=True)
 
     await _mqtt_session(
         mqtt_url, mqtt_user, mqtt_pwd, client_id,

{python_aidot_cameras-0.9.0 → python_aidot_cameras-0.9.2}/src/aidot/camera/sdes.py

@@ -192,7 +192,7 @@ class SdesSession:
             try:
                 await _stop_loop.run_in_executor(None, lambda: self._proc.wait(5))
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", 'stop', exc_info=True)
+                _LOGGER.debug("swallowed exception in %s", 'stop', exc_info=True)
         # Read drained stderr in the executor with a hard timeout: proc.stderr.read()
         # blocks until EOF, which never arrives if the killed process is still a
         # zombie / stuck in uninterruptible I/O - doing it inline would hang the
@@ -205,32 +205,32 @@ class SdesSession:
                 timeout=2.0,
             )
         except Exception:   # incl. asyncio.TimeoutError - never let teardown hang here
-            _LOGGER.debug("camera %s: swallowed exception", 'stop', exc_info=True)
+            _LOGGER.debug("swallowed exception in %s", 'stop', exc_info=True)
             # On timeout the executor thread is still blocked in stderr.read() on
             # a wedged ffmpeg; close the pipe so that read returns instead of
             # pinning a default-pool thread for the life of the process.
             try:
                 self._proc.stderr.close()
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", 'stop', exc_info=True)
+                _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"))
         import os
         try:
             os.unlink(self._sdp_path)
         except Exception:
-            _LOGGER.debug("camera %s: swallowed exception", 'stop', exc_info=True)
+            _LOGGER.debug("swallowed exception in %s", 'stop', exc_info=True)
         for _sock in (self._audio_sock, self._video_sock):
             if _sock is not None:
                 try:
                     _sock.close()
                 except Exception:
-                    _LOGGER.debug("camera %s: swallowed exception", 'stop', exc_info=True)
+                    _LOGGER.debug("swallowed exception in %s", 'stop', exc_info=True)
         self._outgoing_q.put_nowait(None)
         try:
             await asyncio.wait_for(self._mqtt_fut, timeout=5.0)
         except Exception:
-            _LOGGER.debug("camera %s: swallowed exception", 'stop', exc_info=True)
+            _LOGGER.debug("swallowed exception in %s", 'stop', exc_info=True)
 
 
 def _run_sdes_talk_pump(state: dict) -> None:
@@ -297,7 +297,7 @@ def _run_sdes_talk_pump(state: dict) -> None:
                     try:
                         _sock.sendto(_tx.protect(_hdr + _alaw), _src)
                     except Exception:
-                        _LOGGER.debug("camera %s: swallowed exception", '_run_sdes_talk_pump', exc_info=True)
+                        _LOGGER.debug("swallowed exception in %s", '_run_sdes_talk_pump', exc_info=True)
                     _seq = (_seq + 1) & 0xFFFF
                     _ts = (_ts + len(_alaw)) & 0xFFFFFFFF
             # Active talk: hold 20 ms pacing for the audio cadence.