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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.9.0
+Version: 0.9.1
 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.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-aidot-cameras"
-version = "0.9.0"
+version = "0.9.1"
 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.1}/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.1}/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.1}/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.1}/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(
@@ -918,7 +918,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:
@@ -961,11 +961,11 @@ 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)
         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 +1009,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 +1022,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 +1170,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 +1182,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 +1199,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 +1222,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 +1235,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 +1566,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.1}/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.

{python_aidot_cameras-0.9.0 → python_aidot_cameras-0.9.1}/src/aidot/camera/sdes_open.py

@@ -151,7 +151,7 @@ class _SdesOpenMixin:
                 if len(_p) == 4 and all(x.isdigit() and 0 <= int(x) <= 255 for x in _p):
                     _public_ip = _cand_pub
         except Exception:
-            _LOGGER.debug("camera %s: swallowed exception", '_open_sdes_stream', exc_info=True)
+            _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_open_sdes_stream', exc_info=True)
 
         # Build TURN server list for _sdes_ice_server_list from ice_config if
         # available.  The camera's ICE agent uses these to gather its own relay
@@ -192,7 +192,7 @@ class _SdesOpenMixin:
                             "Password": _entry.get("credential") or "",
                         })
         except Exception:
-            _LOGGER.debug("camera %s: swallowed exception", '_open_sdes_stream', exc_info=True)
+            _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_open_sdes_stream', exc_info=True)
 
         # --- TURN relay allocation helper ------------------------------------ #
         # Defined BEFORE the offer so relay IP/port can be embedded in the
@@ -781,13 +781,13 @@ class _SdesOpenMixin:
                             try:
                                 _seen["H264/90000_pt"] = _ln.split(":")[1].split(" ")[0]
                             except Exception:
-                                _LOGGER.debug("camera %s: swallowed exception", '_k', exc_info=True)
+                                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_k', exc_info=True)
                         elif "H265/90000" in _ln and _seen.get("H265/90000") is None:
                             _k(_ln, "H265/90000")
                             try:
                                 _seen["H265/90000_pt"] = _ln.split(":")[1].split(" ")[0]
                             except Exception:
-                                _LOGGER.debug("camera %s: swallowed exception", '_k', exc_info=True)
+                                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_k', exc_info=True)
                         elif "apt=" in _ln:
                             try:
                                 _apt = _ln.split("apt=")[1].strip()
@@ -878,7 +878,7 @@ class _SdesOpenMixin:
                                 "Password": str(_e.get("Password") or ""),
                             })
                 except Exception:
-                    _LOGGER.debug("camera %s: swallowed exception", '_k', exc_info=True)
+                    _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_k', exc_info=True)
             # Allocate TURN relay if not already done before offer build.
             # When ice_config provided TURN entries, pre-allocation already ran
             # and _relay_addrs is populated - skip to avoid double-allocation.
@@ -1193,13 +1193,13 @@ class _SdesOpenMixin:
                     _hp_host = _m_hp.group(1)
                     _hp_port = int(_m_hp.group(2) or 3478)
         except Exception:
-            _LOGGER.debug("camera %s: swallowed exception", '_open_sdes_stream', exc_info=True)
+            _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_open_sdes_stream', exc_info=True)
         _hp_stun = b'\x00\x01\x00\x00\x21\x12\xa4\x42' + os.urandom(12)
         for _hp_sock in (_audio_sock, _video_sock):
             try:
                 _hp_sock.sendto(_hp_stun, (_hp_host, _hp_port))
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", '_send_sdes_ice_cand', exc_info=True)
+                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_send_sdes_ice_cand', exc_info=True)
         # Punch to TURN allocation port (5349) as well so port-restricted NAT
         # allows traffic from either TURN port (3478 STUN or 5349 allocation).
         _hp_port2 = 5349
@@ -1208,7 +1208,7 @@ class _SdesOpenMixin:
                 try:
                     _hp_sock.sendto(_hp_stun, (_hp_host, _hp_port2))
                 except Exception:
-                    _LOGGER.debug("camera %s: swallowed exception", '_send_sdes_ice_cand', exc_info=True)
+                    _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_send_sdes_ice_cand', exc_info=True)
         _status(
             f"NAT hole-punch: sent from audio={audio_port}"
             f" video={video_port} → {_hp_host}:{_hp_port}"
@@ -1260,7 +1260,7 @@ class _SdesOpenMixin:
             try:
                 _rsock.setblocking(False)
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", '_is_self_peer_ip', exc_info=True)
+                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_is_self_peer_ip', exc_info=True)
         while time.monotonic() < _stun_deadline:
             # Idle-exit: threshold depends on whether we've seen any STUN yet
             idle = time.monotonic() - _last_pkt_t
@@ -1398,7 +1398,7 @@ class _SdesOpenMixin:
                                 _sock.sendto(_resp, _src)
                             _stun_count += 1
                         except Exception:
-                            _LOGGER.debug("camera %s: swallowed exception", '_is_self_peer_ip', exc_info=True)
+                            _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_is_self_peer_ip', exc_info=True)
                 else:
                     # Non-STUN packet = SRTP arriving - ICE is done, hand off to ffmpeg now
                     _srtp_detected = True
@@ -1409,7 +1409,7 @@ class _SdesOpenMixin:
             try:
                 _rsock.setblocking(True)
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", '_is_self_peer_ip', exc_info=True)
+                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_is_self_peer_ip', exc_info=True)
         if _stun_count:
             _status(f"ICE: responded to {_stun_count} STUN binding request(s)")
         elif not _srtp_detected:
@@ -1479,7 +1479,7 @@ class _SdesOpenMixin:
                 try:
                     _hp_sock_r.sendto(_hp_stun, (_hp_host, _hp_port))
                 except Exception:
-                    _LOGGER.debug("camera %s: swallowed exception", '_is_self_peer_ip', exc_info=True)
+                    _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_is_self_peer_ip', exc_info=True)
             # Retry STUN window (8 s)
             _stun_deadline = time.monotonic() + 8.0
             _last_pkt_t = time.monotonic()
@@ -1518,7 +1518,7 @@ class _SdesOpenMixin:
                             _sk_r.sendto(_resp_r, _src_r)
                             _stun_count += 1
                         except Exception:
-                            _LOGGER.debug("camera %s: swallowed exception", '_is_self_peer_ip', exc_info=True)
+                            _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_is_self_peer_ip', exc_info=True)
                     else:
                         _srtp_detected = True
                         break
@@ -1554,7 +1554,7 @@ class _SdesOpenMixin:
                 _pre_ans = answer_fut.result()
                 _pre_launch_answer_sdp = (_pre_ans or {}).get("sdp", "")
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", '_is_self_peer_ip', exc_info=True)
+                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_is_self_peer_ip', exc_info=True)
         if _pre_launch_answer_sdp:
             _LOGGER.debug(
                 "_open_sdes_stream: camera webrtcResp answer SDP (len=%d)",
@@ -1873,7 +1873,7 @@ class _SdesOpenMixin:
             try:
                 sock.sendto(_req, cam_addr)
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", '_send_use_candidate', exc_info=True)
+                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_send_use_candidate', exc_info=True)
 
         if _cam_ice_ufrag and _cam_ice_pwd and _cam_ice_cands:
             for _c_ip, _c_port in _cam_ice_cands:
@@ -2100,14 +2100,14 @@ class _SdesOpenMixin:
                                     _talk_state["speaker_on"] = True
                                     _status("SDES talk: sent SPEAKERSTART(848) (bridge thread)")
                                 except Exception:
-                                    _LOGGER.debug("camera %s: swallowed exception", '_bridge_fn', exc_info=True)
+                                    _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_bridge_fn', exc_info=True)
                         elif _talk_state.get("speaker_on") and not _talk_state.get("want_speaker"):
                             try:
                                 _cmd_chan[0](849, b'\x00' * 8)  # SPEAKERSTOP
                                 _talk_state["speaker_on"] = False
                                 _status("SDES talk: sent SPEAKERSTOP(849) (bridge thread)")
                             except Exception:
-                                _LOGGER.debug("camera %s: swallowed exception", '_bridge_fn', exc_info=True)
+                                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_bridge_fn', exc_info=True)
 
                     # RTCP PLI (Picture Loss Indication) - forces camera to
                     # resend IDR + VPS/SPS/PPS so ffmpeg gets codec params.
@@ -2177,13 +2177,13 @@ class _SdesOpenMixin:
                             )
                             _pli_sent = True
                         except Exception:
-                            _LOGGER.debug("camera %s: swallowed exception", '_bridge_fn', exc_info=True)
+                            _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_bridge_fn', exc_info=True)
                         if not _pli_sent:
                             try:
                                 _bridge_fn._cam_srtp_sock.sendto(
                                     _pli_raw, _bridge_fn._cam_srtp_src)
                             except Exception:
-                                _LOGGER.debug("camera %s: swallowed exception", '_bridge_fn', exc_info=True)
+                                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_bridge_fn', exc_info=True)
                         _bridge_fn._last_pli_ts = _time_br.time()
                         _pli_n = getattr(_bridge_fn, '_pli_count', 0) + 1
                         _bridge_fn._pli_count = _pli_n
@@ -2245,7 +2245,7 @@ class _SdesOpenMixin:
                                             _csrc,
                                         )
                                     except Exception:
-                                        _LOGGER.debug("camera %s: swallowed exception", '_persistent_sdes_cmd', exc_info=True)
+                                        _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_persistent_sdes_cmd', exc_info=True)
 
                                 _cmd_chan[0] = _persistent_sdes_cmd
                             except Exception as _dw_e:
@@ -2275,7 +2275,7 @@ class _SdesOpenMixin:
                                 _re_key, _AES_re2.MODE_CBC, _re_iv
                             ).encrypt(_pad_re2(_re_plain, 16))
                         except Exception:
-                            _LOGGER.debug("camera %s: swallowed exception", '_bridge_fn', exc_info=True)
+                            _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_bridge_fn', exc_info=True)
                         for _rp in [_re_enc, _re_plain]:
                             if _rp is None:
                                 continue
@@ -2286,7 +2286,7 @@ class _SdesOpenMixin:
                                     _trigger_bsrc,
                                 )
                             except Exception:
-                                _LOGGER.debug("camera %s: swallowed exception", '_bridge_fn', exc_info=True)
+                                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_bridge_fn', exc_info=True)
                         _last_trigger_ts = _time_br.time()
 
                     for _bs in _rl:
@@ -2439,14 +2439,14 @@ class _SdesOpenMixin:
                                                     (_br_ci, _br_cp),
                                                 )
                                             except Exception:
-                                                _LOGGER.debug("camera %s: swallowed exception", '_bridge_fn', exc_info=True)
+                                                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_bridge_fn', exc_info=True)
                                     _status(
                                         f"bridge: late USE-CANDIDATE sent (audio+video) to"
                                         f" {len(_bridge_uc_info['cands'])} camera candidate(s)"
                                         " (answer arrived after bridge started)"
                                     )
                             except Exception:
-                                _LOGGER.debug("camera %s: swallowed exception", '_bridge_fn', exc_info=True)
+                                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_bridge_fn', exc_info=True)
                         elif len(_bpkt) >= 20 and _bpkt[4:8] == _STUN_MAGIC_BR:
                             # STUN BindingSuccess (0x0101) from camera: ICE complete.
                             # Send AES-128-CBC encrypted SESSION_MODE_REQ (AVIO LIVING).
@@ -2503,7 +2503,7 @@ class _SdesOpenMixin:
                                             f" → {_bsrc[0]}:{_bsrc[1]}"
                                         )
                                     except Exception:
-                                        _LOGGER.debug("camera %s: swallowed exception", '_persistent_sdes_cmd', exc_info=True)
+                                        _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_persistent_sdes_cmd', exc_info=True)
                                 _avio_living_sent = True
                                 _last_trigger_ts = _time_br.time()
                                 _trigger_bs   = _bs
@@ -2880,12 +2880,12 @@ class _SdesOpenMixin:
                                         _bs.sendto(_rr_sess.protect_rtcp(_rr_pkt), _bsrc)
                                         _rtcp_sent = True
                                     except Exception:
-                                        _LOGGER.debug("camera %s: swallowed exception", '_persistent_sdes_cmd', exc_info=True)
+                                        _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_persistent_sdes_cmd', exc_info=True)
                                     if not _rtcp_sent:
                                         try:
                                             _bs.sendto(_rr_pkt, _bsrc)
                                         except Exception:
-                                            _LOGGER.debug("camera %s: swallowed exception", '_enc_c8_sctp', exc_info=True)
+                                            _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_enc_c8_sctp', exc_info=True)
                                     if _bridge_fn._tutk_count == 1:
                                         _status(
                                             f"SDES: sent RTCP RR to camera"
@@ -2917,7 +2917,7 @@ class _SdesOpenMixin:
                                                     f" ({len(_pd_plain)}B PCMA)"
                                                 )
                                         except Exception:
-                                            _LOGGER.debug("camera %s: swallowed exception", '_enc_c8_sctp', exc_info=True)
+                                            _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_enc_c8_sctp', exc_info=True)
                                 continue
 
                             # Standard SRTP/SRTCP demux by RTP payload type.
@@ -2955,11 +2955,11 @@ class _SdesOpenMixin:
                                 try:
                                     _lo_a.sendto(_bpkt, ('127.0.0.1', _lo_audio_port))
                                 except Exception:
-                                    _LOGGER.debug("camera %s: swallowed exception", '_bridge_fn', exc_info=True)
+                                    _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_bridge_fn', exc_info=True)
                                 try:
                                     _lo_v.sendto(_bpkt, ('127.0.0.1', _lo_video_port))
                                 except Exception:
-                                    _LOGGER.debug("camera %s: swallowed exception", '_bridge_fn', exc_info=True)
+                                    _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_bridge_fn', exc_info=True)
                                 continue
                             _pt = _pt_byte & 0x7F
                             if _pt in (96, 97, 98):
@@ -3138,7 +3138,7 @@ class _SdesOpenMixin:
                                 )
                                 _media_progress[0] = _time_br.monotonic()
                             except Exception:
-                                _LOGGER.debug("camera %s: swallowed exception", '_bridge_fn', exc_info=True)
+                                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_bridge_fn', exc_info=True)
                     # Periodic ICE controlling check: re-send USE-CANDIDATE every 2.5 s.
                     # Keeps the camera in ICE "Completed" state and satisfies consent
                     # refresh (RFC 7675).  Also handles the case where the initial
@@ -3159,11 +3159,11 @@ class _SdesOpenMixin:
                 try:
                     _lo_a.close()
                 except Exception:
-                    _LOGGER.debug("camera %s: swallowed exception", '_bridge_fn', exc_info=True)
+                    _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_bridge_fn', exc_info=True)
                 try:
                     _lo_v.close()
                 except Exception:
-                    _LOGGER.debug("camera %s: swallowed exception", '_bridge_fn', exc_info=True)
+                    _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_bridge_fn', exc_info=True)
 
         _br_first_di_logged = False
         _br_first_srtp_logged = False
@@ -3222,11 +3222,11 @@ class _SdesOpenMixin:
                 try:
                     _rsock.close()
                 except Exception:
-                    _LOGGER.debug("camera %s: swallowed exception", '_bridge_fn', exc_info=True)
+                    _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_bridge_fn', exc_info=True)
             try:
                 os.unlink(sdp_path)
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", '_bridge_fn', exc_info=True)
+                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_bridge_fn', exc_info=True)
             outgoing_q.put_nowait(None)   # stop MQTT thread
             raise CameraMixin._SdesNoAnswerError()
         elif (_cam_echo_received
@@ -3309,7 +3309,7 @@ class _SdesOpenMixin:
                     f"SDES: narrowed ffmpeg SDP to video pt={_vpt}"
                     f" ({'H265' if int(_vpt) == 97 else 'H264'})")
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", '_open_sdes_stream', exc_info=True)
+                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_open_sdes_stream', exc_info=True)
         _LOGGER.info("SDES ffmpeg cmd: %s", " ".join(cmd))
         if _ffmpeg_path() is None:
             # ffmpeg is not installed - clean up and surface a clear error
@@ -3318,11 +3318,11 @@ class _SdesOpenMixin:
                 try:
                     _rsock.close()
                 except Exception:
-                    _LOGGER.debug("camera %s: swallowed exception", '_bridge_fn', exc_info=True)
+                    _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_bridge_fn', exc_info=True)
             try:
                 os.unlink(sdp_path)
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", '_bridge_fn', exc_info=True)
+                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_bridge_fn', exc_info=True)
             outgoing_q.put_nowait(None)   # stop MQTT thread
             raise RuntimeError(
                 "ffmpeg not found - install ffmpeg to stream SDES-SRTP cameras.\n"
@@ -3343,11 +3343,11 @@ class _SdesOpenMixin:
                 try:
                     _rsock.close()
                 except Exception:
-                    _LOGGER.debug("camera %s: swallowed exception", '_bridge_fn', exc_info=True)
+                    _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_bridge_fn', exc_info=True)
             try:
                 os.unlink(sdp_path)
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", '_bridge_fn', exc_info=True)
+                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_bridge_fn', exc_info=True)
             outgoing_q.put_nowait(None)   # stop MQTT thread
             raise RuntimeError(
                 "ffmpeg not found - install ffmpeg to stream SDES-SRTP cameras.\n"
@@ -3591,11 +3591,11 @@ class _SdesOpenMixin:
                     try:
                         _rsock.close()
                     except Exception:
-                        _LOGGER.debug("camera %s: swallowed exception", '_udp_port_bound', exc_info=True)
+                        _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_udp_port_bound', exc_info=True)
                 try:
                     os.unlink(sdp_path)
                 except Exception:
-                    _LOGGER.debug("camera %s: swallowed exception", '_udp_port_bound', exc_info=True)
+                    _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_udp_port_bound', exc_info=True)
                 outgoing_q.put_nowait(None)   # signal MQTT thread to exit
                 raise CameraMixin._SdesNoAnswerError()
             else:
@@ -3654,7 +3654,7 @@ class _SdesOpenMixin:
                                         + (" [m=app]" if _dc_answer_has_app else "")
                                     )
                         except Exception:
-                            _LOGGER.debug("camera %s: swallowed exception", '_late_second_answer_task', exc_info=True)
+                            _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_late_second_answer_task', exc_info=True)
                     _spawn_bg(_late_second_answer_task())
 
         return SdesSession(

{python_aidot_cameras-0.9.0 → python_aidot_cameras-0.9.1}/src/aidot/camera/tutk.py

@@ -249,12 +249,12 @@ class TutkStreamSession:
             try:
                 av.avClientStop(self._av_index)
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", '_recv_loop', exc_info=True)
+                _LOGGER.debug("swallowed exception in %s", '_recv_loop', exc_info=True)
         if self._sid >= 0:
             try:
                 iotc.IOTC_Session_Close(self._sid)
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", '_recv_loop', exc_info=True)
+                _LOGGER.debug("swallowed exception in %s", '_recv_loop', exc_info=True)
         _LOGGER.debug("TUTK: recv loop exited")
 
     async def stop(self) -> None:

{python_aidot_cameras-0.9.0 → python_aidot_cameras-0.9.1}/src/aidot/camera/webrtc.py

@@ -106,7 +106,7 @@ class WebRTCSession:
             if self._audio_sender is not None:
                 self._audio_sender.replaceTrack(None)
         except Exception:
-            _LOGGER.debug("camera %s: swallowed exception", 'async_stop_talk', exc_info=True)
+            _LOGGER.debug("swallowed exception in %s", 'async_stop_talk', exc_info=True)
         self._talk_holder["provider"] = None
         return True
 
@@ -185,18 +185,18 @@ class WebRTCSession:
                 self._talk_holder["was_active"] = False
                 await asyncio.sleep(0.4)   # let the DataChannel deliver SPEAKERSTOP
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", 'stop', exc_info=True)
+                _LOGGER.debug("swallowed exception in %s", 'stop', exc_info=True)
         for task in self._track_tasks:
             task.cancel()
         if self._recorder is not None:
             try:
                 await self._recorder.stop()
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", 'stop', exc_info=True)
+                _LOGGER.debug("swallowed exception in %s", 'stop', exc_info=True)
         # Send None sentinel to stop the MQTT session in its thread
         self._outgoing_q.put_nowait(None)
         await self._pc.close()
         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)

{python_aidot_cameras-0.9.0 → python_aidot_cameras-0.9.1}/src/aidot/camera/webrtc_open.py

@@ -193,7 +193,7 @@ class _WebRTCOpenMixin:
             try:
                 await self.async_wake_camera()
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", '_async_open_webrtc_stream_impl', exc_info=True)
+                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_async_open_webrtc_stream_impl', exc_info=True)
 
         if not use_sdes:
             try:
@@ -1105,7 +1105,7 @@ class _WebRTCOpenMixin:
                 except RuntimeError:
                     raise
                 except Exception:
-                    _LOGGER.debug("camera %s: swallowed exception", '_http_keepalive', exc_info=True)
+                    _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_http_keepalive', exc_info=True)
 
         # ------------------------------------------------------------------ #
         # Branch: SDES-SRTP cameras use ffmpeg; DTLS cameras use aiortc
@@ -1441,7 +1441,7 @@ class _WebRTCOpenMixin:
                 _hdr = struct.pack("<IIqII4x", _seq, 5156, _ts_ms, 0, 0)
                 _dc_ref.send(_hdr)
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", '_send_avio_heartbeat', exc_info=True)
+                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_send_avio_heartbeat', exc_info=True)
 
         def _send_avio_audiostart(_dc_ref) -> None:
             # IOTYPE_USER_IPCAM_AUDIOSTART = 768 (AVIOCTRLDEFs.java:154).
@@ -1460,7 +1460,7 @@ class _WebRTCOpenMixin:
                 _hdr = struct.pack("<IIqII4x", _seq, 768, _ts_ms, len(_payload), 0)
                 _dc_ref.send(_hdr + _payload)
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", '_send_avio_audiostart', exc_info=True)
+                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_send_avio_audiostart', exc_info=True)
 
         def _send_avio_speaker(_dc_ref, start: bool) -> None:
             # IOTYPE_USER_IPCAM_SPEAKERSTART = 848 / SPEAKERSTOP = 849
@@ -1507,7 +1507,7 @@ class _WebRTCOpenMixin:
                     else:
                         _status(f"DC[remote:{channel.label}] RX text {message!r}")
                 except Exception:
-                    _LOGGER.debug("camera %s: swallowed exception", '_on_remote_dc_message', exc_info=True)
+                    _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_on_remote_dc_message', exc_info=True)
 
         track_tasks: list = []
         _kvs_dc = None
@@ -1617,7 +1617,7 @@ class _WebRTCOpenMixin:
                     else:
                         _status(f"DC[{_dc_label}] RX text {message!r}")
                 except Exception:
-                    _LOGGER.debug("camera %s: swallowed exception", '_on_kvs_dc_message', exc_info=True)
+                    _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_on_kvs_dc_message', exc_info=True)
 
             # Periodic readyState diagnostic - last run had no "DC OPEN"
             # log line, so we want to see whether readyState ever transitions
@@ -1679,7 +1679,7 @@ class _WebRTCOpenMixin:
                         while True:
                             await track.recv()
                     except Exception:
-                        _LOGGER.debug("camera %s: swallowed exception", '_drain_audio', exc_info=True)
+                        _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_drain_audio', exc_info=True)
                 t = asyncio.ensure_future(_drain_audio())
                 track_tasks.append(t)
             elif track.kind == "video":
@@ -1767,7 +1767,7 @@ class _WebRTCOpenMixin:
                     _LOGGER.debug(
                         "highport-fix: scoped to this DTLS camera connection")
             except Exception:
-                _LOGGER.debug("camera %s: swallowed exception", '_on_track', exc_info=True)
+                _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_on_track', exc_info=True)
 
 
         _sdp = pc.localDescription.sdp
@@ -2723,7 +2723,7 @@ class _WebRTCOpenMixin:
                                     _NPFp(algorithm="sha-256", value=_real_fp)
                                 ]
                         except Exception:
-                            _LOGGER.debug("camera %s: swallowed exception", '_np_accept_cam_cert', exc_info=True)
+                            _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_np_accept_cam_cert', exc_info=True)
 
                     # Diag: log PC/ICE state at patch-application time so we
                     # can see whether DTLS handshake has *already* started by

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.9.0
+Version: 0.9.1
 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.1}/src/python_aidot_cameras.egg-info/requires.txt

@@ -1,8 +1,8 @@
-aiohttp
+aiohttp>=3.9
 paho-mqtt>=2.0
-cryptography
-pycryptodome
-dacite
+cryptography>=42.0
+pycryptodome>=3.20
+dacite>=1.8
 
 [webrtc]
 aiortc>=1.9.0