ramses-rf 0.53.3__tar.gz → 0.53.5__tar.gz

{ramses_rf-0.53.3 → ramses_rf-0.53.5}/.github/workflows/check-cov.yml

@@ -89,7 +89,7 @@ jobs:
           hide_complexity: true
           indicators: true
           output: both
-          thresholds: '80 90'
+          thresholds: '80 95'
 
       - name: Add Coverage PR Comment
         # from: https://github.com/marketplace/actions/comment-pull-request

{ramses_rf-0.53.3 → ramses_rf-0.53.5}/.pre-commit-config.yaml

@@ -14,7 +14,7 @@ repos:
       # Run `python-typing-update` hook manually from time to time
       # to update python typing syntax.
       # Will require manual work, before submitting changes!
-      # pre-commit run --hook-stage manual python-typing-update --all-files
+      # prek run --hook-stage manual python-typing-update --all-files
       - id: python-typing-update
         stages: [manual]
         args:
@@ -39,6 +39,10 @@ repos:
     hooks:
       - id: check-executables-have-shebangs
       # id: check-json  # don't enable this one
+      # - id: no-commit-to-branch
+      #   args:
+      #     - --branch=master
+      #     - --branch=stable
       - id: check-toml
       - id: check-yaml
       - id: debug-statements

{ramses_rf-0.53.3 → ramses_rf-0.53.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ramses_rf
-Version: 0.53.3
+Version: 0.53.5
 Summary: A stateful RAMSES-II protocol decoder & analyser.
 Project-URL: Homepage, https://github.com/ramses-rf/ramses_rf
 Project-URL: Bug Tracker, https://github.com/ramses-rf/ramses_rf/issues

{ramses_rf-0.53.3 → ramses_rf-0.53.5}/docs/source/ramses_rf.rst

@@ -99,6 +99,14 @@ ramses\_rf.schemas module
    :show-inheritance:
    :undoc-members:
 
+ramses\_rf.storage module
+-------------------------
+
+.. automodule:: ramses_rf.storage
+   :members:
+   :show-inheritance:
+   :undoc-members:
+
 ramses\_rf.version module
 -------------------------
 

{ramses_rf-0.53.3 → ramses_rf-0.53.5}/pyproject.toml

@@ -116,7 +116,7 @@
     "raise NotImplementedError",
   ]
   format = "text"
-  fail_under = 75
+  fail_under = 80  # total cov now 83%
   ignore_errors = true
 
 [tool.coverage.html]

{ramses_rf-0.53.3 → ramses_rf-0.53.5}/ramses_cli/client.py

@@ -471,13 +471,8 @@ def print_results(gwy: Gateway, **kwargs: Any) -> None:
         system_id, _ = kwargs[GET_SCHED]
 
 
-def _save_state(gwy: Gateway) -> None:
-    """Save the gateway state to files.
-
-    :param gwy: The gateway instance.
-    """
-    schema, msgs = gwy.get_state()
-
+def _write_state(schema: dict[str, Any], msgs: dict[str, str]) -> None:
+    """Write the state to the file system (blocking)."""
     with open("state_msgs.log", "w") as f:
         [f.write(f"{dtm} {pkt}\r\n") for dtm, pkt in msgs.items()]  # if not m._expired
 
@@ -485,13 +480,22 @@ def _save_state(gwy: Gateway) -> None:
         f.write(json.dumps(schema, indent=4))
 
 
-def _print_engine_state(gwy: Gateway, **kwargs: Any) -> None:
+async def _save_state(gwy: Gateway) -> None:
+    """Save the gateway state to files.
+
+    :param gwy: The gateway instance.
+    """
+    schema, msgs = await gwy.get_state()
+    await asyncio.to_thread(_write_state, schema, msgs)
+
+
+async def _print_engine_state(gwy: Gateway, **kwargs: Any) -> None:
     """Print the current engine state (schema and packets).
 
     :param gwy: The gateway instance.
     :param kwargs: Command arguments to determine verbosity.
     """
-    (schema, packets) = gwy.get_state(include_expired=True)
+    (schema, packets) = await gwy.get_state(include_expired=True)
 
     if kwargs["print_state"] > 0:
         print(f"schema: {json.dumps(schema, indent=4)}\r\n")
@@ -671,10 +675,10 @@ async def async_main(command: str, lib_kwargs: dict[str, Any], **kwargs: Any) ->
     print(f"\r\nclient.py: Engine stopped: {msg}")
 
     # if kwargs["save_state"]:
-    #    _save_state(gwy)
+    #    await _save_state(gwy)
 
     if kwargs["print_state"]:
-        _print_engine_state(gwy, **kwargs)
+        await _print_engine_state(gwy, **kwargs)
 
     elif command == EXECUTE:
         print_results(gwy, **kwargs)

{ramses_rf-0.53.3 → ramses_rf-0.53.5}/ramses_rf/database.py

@@ -35,7 +35,7 @@ from typing import TYPE_CHECKING, Any, NewType
 
 from ramses_tx import CODES_SCHEMA, RQ, Code, Message, Packet
 
-from .storage import StorageWorker
+from .storage import PacketLogEntry, StorageWorker
 
 if TYPE_CHECKING:
     DtmStrT = NewType("DtmStrT", str)
@@ -241,28 +241,30 @@ class MessageIndex:
             :param dt_now: current timestamp
             :param _cutoff: the oldest timestamp to retain, default is 24 hours ago
             """
-            msgs = None
             dtm = dt_now - _cutoff
 
-            self._cu.execute("SELECT dtm FROM messages WHERE dtm >= ?", (dtm,))
-            rows = self._cu.fetchall()  # fetch dtm of current messages to retain
+            # Submit prune request to worker (Non-blocking I/O)
+            self._worker.submit_prune(dtm)
+
+            # Prune in-memory cache synchronously (Fast CPU-bound op)
+            dtm_iso = dtm.isoformat(timespec="microseconds")
 
             try:  # make this operation atomic, i.e. update self._msgs only on success
                 await self._lock.acquire()
-                self._cu.execute("DELETE FROM messages WHERE dtm < ?", (dtm,))
-                msgs = OrderedDict({row[0]: self._msgs[row[0]] for row in rows})
-                self._cx.commit()
+                # Rebuild dict keeping only newer items
+                self._msgs = OrderedDict(
+                    (k, v) for k, v in self._msgs.items() if k >= dtm_iso
+                )
 
-            except sqlite3.Error:  # need to tighten?
-                self._cx.rollback()
+            except Exception as err:
+                _LOGGER.warning("MessageIndex housekeeping error: %s", err)
             else:
-                self._msgs = msgs
+                _LOGGER.debug(
+                    "MessageIndex housekeeping completed, retained messages >= %s",
+                    dtm_iso,
+                )
             finally:
                 self._lock.release()
-                if msgs:
-                    _LOGGER.debug(
-                        "MessageIndex size was: %d, now: %d", len(rows), len(msgs)
-                    )
 
         while True:
             self._last_housekeeping = dt.now()
@@ -345,15 +347,15 @@ class MessageIndex:
         # Avoid blocking read; worker handles REPLACE on unique constraint collision
 
         # Prepare data tuple for worker
-        data = (
-            _now,
-            verb,
-            src,
-            src,
-            code,
-            None,
-            hdr,
-            "|",
+        data = PacketLogEntry(
+            dtm=_now,
+            verb=verb,
+            src=src,
+            dst=src,
+            code=code,
+            ctx=None,
+            hdr=hdr,
+            plk="|",
         )
 
         self._worker.submit_packet(data)
@@ -390,15 +392,15 @@ class MessageIndex:
         # _old_msgs = self._delete_from(hdr=msg._pkt._hdr)
         # Refactor: Worker uses INSERT OR REPLACE to handle collision
 
-        data = (
-            msg.dtm,
-            str(msg.verb),
-            msg.src.id,
-            msg.dst.id,
-            str(msg.code),
-            msg_pkt_ctx,
-            msg._pkt._hdr,
-            payload_keys(msg.payload),
+        data = PacketLogEntry(
+            dtm=msg.dtm,
+            verb=str(msg.verb),
+            src=msg.src.id,
+            dst=msg.dst.id,
+            code=str(msg.code),
+            ctx=msg_pkt_ctx,
+            hdr=msg._pkt._hdr,
+            plk=payload_keys(msg.payload),
         )
 
         self._worker.submit_packet(data)

{ramses_rf-0.53.3 → ramses_rf-0.53.5}/ramses_rf/entity_base.py

@@ -913,7 +913,9 @@ class _Discovery(_MessageDB):
                 sql, (self.id[:_ID_SLICE], self.id[:_ID_SLICE])
             ):
                 _LOGGER.debug("Fetched OT ctx from index: %s", rec[0])
-                res.append(rec[0])
+                # SQLite can return int, expected str (hex)
+                val = f"{rec[0]:02X}" if isinstance(rec[0], int) else rec[0]
+                res.append(val)
         else:  # TODO(eb): remove next Q1 2026
             res_dict: dict[bool | str | None, Message] | list[Any] = self._msgz[
                 Code._3220

{ramses_rf-0.53.3 → ramses_rf-0.53.5}/ramses_rf/gateway.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 import asyncio
 import logging
 from collections.abc import Awaitable, Callable
+from logging.handlers import QueueListener
 from types import SimpleNamespace
 from typing import TYPE_CHECKING, Any
 
@@ -101,6 +102,7 @@ class Gateway(Engine):
         known_list: DeviceListT | None = None,
         loop: asyncio.AbstractEventLoop | None = None,
         transport_constructor: Callable[..., Awaitable[RamsesTransportT]] | None = None,
+        hgi_id: str | None = None,
         **kwargs: Any,
     ) -> None:
         """Initialize the Gateway instance.
@@ -121,6 +123,8 @@ class Gateway(Engine):
         :type loop: asyncio.AbstractEventLoop | None, optional
         :param transport_constructor: A factory for creating the transport layer, defaults to None.
         :type transport_constructor: Callable[..., Awaitable[RamsesTransportT]] | None, optional
+        :param hgi_id: The Device ID to use for the HGI (gateway), overriding defaults.
+        :type hgi_id: str | None, optional
         :param kwargs: Additional configuration parameters passed to the engine and schema.
         :type kwargs: Any
         """
@@ -138,6 +142,7 @@ class Gateway(Engine):
             block_list=block_list,
             known_list=known_list,
             loop=loop,
+            hgi_id=hgi_id,
             transport_constructor=transport_constructor,
             **SCH_ENGINE_CONFIG(config),
         )
@@ -159,6 +164,7 @@ class Gateway(Engine):
         self.device_by_id: dict[DeviceIdT, Device] = {}
 
         self.msg_db: MessageIndex | None = None
+        self._pkt_log_listener: QueueListener | None = None
 
     def __repr__(self) -> str:
         """Return a string representation of the Gateway.
@@ -218,10 +224,12 @@ class Gateway(Engine):
                 if system.dhw:
                     system.dhw._start_discovery_poller()
 
-        await set_pkt_logging_config(  # type: ignore[arg-type]
+        _, self._pkt_log_listener = await set_pkt_logging_config(  # type: ignore[arg-type]
             cc_console=self.config.reduce_processing >= DONT_CREATE_MESSAGES,
             **self._packet_log,
         )
+        if self._pkt_log_listener:
+            self._pkt_log_listener.start()
 
         # initialize SQLite index, set in _tx/Engine
         if self._sqlite_index:  # TODO(eb): default to True in Q1 2026
@@ -267,12 +275,21 @@ class Gateway(Engine):
         :returns: None
         :rtype: None
         """
+        # Stop the Engine first to ensure no tasks/callbacks try to write
+        # to the DB while we are closing it.
+        await super().stop()
+
+        if self._pkt_log_listener:
+            self._pkt_log_listener.stop()
+            # Close handlers to ensure files are flushed/closed
+            for handler in self._pkt_log_listener.handlers:
+                handler.close()
+            self._pkt_log_listener = None
 
         if self.msg_db:
             self.msg_db.stop()
-        await super().stop()
 
-    def _pause(self, *args: Any) -> None:
+    async def _pause(self, *args: Any) -> None:
         """Pause the (unpaused) gateway (disables sending/discovery).
 
         There is the option to save other objects, as `args`.
@@ -288,12 +305,12 @@ class Gateway(Engine):
         self.config.disable_discovery, disc_flag = True, self.config.disable_discovery
 
         try:
-            super()._pause(disc_flag, *args)
+            await super()._pause(disc_flag, *args)
         except RuntimeError:
             self.config.disable_discovery = disc_flag
             raise
 
-    def _resume(self) -> tuple[Any]:
+    async def _resume(self) -> tuple[Any]:
         """Resume the (paused) gateway (enables sending/discovery, if applicable).
 
         Will restore other objects, as `args`.
@@ -305,11 +322,13 @@ class Gateway(Engine):
 
         _LOGGER.debug("Gateway: Resuming engine...")
 
-        self.config.disable_discovery, *args = super()._resume()  # type: ignore[assignment]
+        # args_tuple = await super()._resume()
+        # self.config.disable_discovery, *args = args_tuple  # type: ignore[assignment]
+        self.config.disable_discovery, *args = await super()._resume()  # type: ignore[assignment]
 
         return args
 
-    def get_state(
+    async def get_state(
         self, include_expired: bool = False
     ) -> tuple[dict[str, Any], dict[str, str]]:
         """Return the current schema & state (may include expired packets).
@@ -320,7 +339,7 @@ class Gateway(Engine):
         :rtype: tuple[dict[str, Any], dict[str, str]]
         """
 
-        self._pause()
+        await self._pause()
 
         def wanted_msg(msg: Message, include_expired: bool = False) -> bool:
             if msg.code == Code._313F:
@@ -357,7 +376,7 @@ class Gateway(Engine):
             }
             # _LOGGER.warning("Missing MessageIndex")
 
-        self._resume()
+        await self._resume()
 
         return self.schema, dict(sorted(pkts.items()))
 
@@ -392,7 +411,7 @@ class Gateway(Engine):
         tmp_transport: RamsesTransportT  # mypy hint
 
         _LOGGER.debug("Gateway: Restoring a cached packet log...")
-        self._pause()
+        await self._pause()
 
         if _clear_state:  # only intended for test suite use
             clear_state()
@@ -428,7 +447,7 @@ class Gateway(Engine):
         await tmp_transport.get_extra_info(SZ_READER_TASK)
 
         _LOGGER.debug("Gateway: Restored, resuming")
-        self._resume()
+        await self._resume()
 
     def _add_device(self, dev: Device) -> None:  # TODO: also: _add_system()
         """Add a device to the gateway (called by devices during instantiation).

{ramses_rf-0.53.3 → ramses_rf-0.53.5}/ramses_rf/storage.py

@@ -7,24 +7,46 @@ import logging
 import queue
 import sqlite3
 import threading
-from typing import Any
+from typing import Any, NamedTuple
 
 _LOGGER = logging.getLogger(__name__)
 
 
+class PacketLogEntry(NamedTuple):
+    """Represents a packet to be written to the database."""
+
+    dtm: Any
+    verb: str
+    src: str
+    dst: str
+    code: str
+    ctx: str | None
+    hdr: str
+    plk: str
+
+
+class PruneRequest(NamedTuple):
+    """Represents a request to prune old records."""
+
+    dtm_limit: Any
+
+
+QueueItem = PacketLogEntry | PruneRequest | tuple[str, Any] | None
+
+
 class StorageWorker:
     """A background worker thread to handle blocking storage I/O asynchronously."""
 
-    def __init__(self, db_path: str = ":memory:"):
+    def __init__(self, db_path: str = ":memory:") -> None:
         """Initialize the storage worker thread."""
         self._db_path = db_path
-        self._queue: queue.SimpleQueue[tuple[str, Any] | None] = queue.SimpleQueue()
+        self._queue: queue.SimpleQueue[QueueItem] = queue.SimpleQueue()
         self._ready_event = threading.Event()
 
         self._thread = threading.Thread(
             target=self._run,
             name="RamsesStorage",
-            daemon=True,  # FIX: Set to True so the process can exit even if stop() is missed
+            daemon=True,  # Allows process exit even if stop() is missed
         )
         self._thread.start()
 
@@ -32,16 +54,16 @@ class StorageWorker:
         """Wait until the database is initialized and ready."""
         return self._ready_event.wait(timeout)
 
-    def submit_packet(self, packet_data: tuple[Any, ...]) -> None:
+    def submit_packet(self, packet: PacketLogEntry) -> None:
         """Submit a packet tuple for SQL insertion (Non-blocking)."""
-        self._queue.put(("SQL", packet_data))
+        self._queue.put(packet)
+
+    def submit_prune(self, dtm_limit: Any) -> None:
+        """Submit a prune request for SQL deletion (Non-blocking)."""
+        self._queue.put(PruneRequest(dtm_limit))
 
     def flush(self, timeout: float = 10.0) -> None:
         """Block until all currently pending tasks are processed."""
-        # REMOVED: if self._queue.empty(): return
-        # This check caused a race condition where flush() returned before
-        # the worker finished committing the last item it just popped.
-
         # We inject a special marker into the queue
         sentinel = threading.Event()
         self._queue.put(("MARKER", sentinel))
@@ -89,7 +111,7 @@ class StorageWorker:
                 detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES,
                 check_same_thread=False,
                 uri=True,
-                timeout=10.0,  # Increased timeout for locking
+                timeout=10.0,
             )
 
             # Enable Write-Ahead Logging for concurrency
@@ -116,16 +138,9 @@ class StorageWorker:
                 if item is None:  # Shutdown signal
                     break
 
-                task_type, data = item
-
-                if task_type == "MARKER":
-                    # Flush requested
-                    data.set()
-                    continue
-
-                if task_type == "SQL":
+                if isinstance(item, PacketLogEntry):
                     # Optimization: Batch processing
-                    batch = [data]
+                    batch = [item]
                     # Drain queue of pending SQL tasks to bulk insert
                     while not self._queue.empty():
                         try:
@@ -135,22 +150,19 @@ class StorageWorker:
                                 self._queue.put(None)  # Re-queue poison pill
                                 break
 
-                            next_type, next_data = next_item
-                            if next_type == "SQL":
-                                batch.append(next_data)
-                            elif next_type == "MARKER":
-                                # Handle marker after this batch
-                                self._queue.put(next_item)  # Re-queue marker
-                                break
+                            if isinstance(next_item, PacketLogEntry):
+                                batch.append(next_item)
                             else:
-                                pass
+                                # Handle other types after this batch
+                                self._queue.put(next_item)  # Re-queue
+                                break
                         except queue.Empty:
                             break
 
                     try:
                         conn.executemany(
                             """
-                            INSERT OR REPLACE INTO messages 
+                            INSERT OR REPLACE INTO messages
                             (dtm, verb, src, dst, code, ctx, hdr, plk)
                             VALUES (?, ?, ?, ?, ?, ?, ?, ?)
                             """,
@@ -160,6 +172,20 @@ class StorageWorker:
                     except sqlite3.Error as err:
                         _LOGGER.error("SQL Write Failed: %s", err)
 
+                elif isinstance(item, PruneRequest):
+                    try:
+                        conn.execute(
+                            "DELETE FROM messages WHERE dtm < ?", (item.dtm_limit,)
+                        )
+                        conn.commit()
+                        _LOGGER.debug("Pruned records older than %s", item.dtm_limit)
+                    except sqlite3.Error as err:
+                        _LOGGER.error("SQL Prune Failed: %s", err)
+
+                elif isinstance(item, tuple) and item[0] == "MARKER":
+                    # Flush requested
+                    item[1].set()
+
             except Exception as err:
                 _LOGGER.exception("StorageWorker encountered an error: %s", err)
 

{ramses_rf-0.53.3 → ramses_rf-0.53.5}/ramses_rf/system/heat.py

@@ -137,7 +137,7 @@ class SystemBase(Parent, Entity):  # 3B00 (multi-relay)
         self._child_id = FF  # NOTE: domain_id
 
         self._app_cntrl: BdrSwitch | OtbGateway | None = None
-        self._heat_demand = None
+        self._heat_demand: dict[str, Any] | None = None
 
     def __repr__(self) -> str:
         return f"{self.ctl.id} ({self._SLUG})"
@@ -217,17 +217,33 @@ class SystemBase(Parent, Entity):  # 3B00 (multi-relay)
         super()._handle_msg(msg)
 
         if msg.code == Code._000C:
-            if msg.payload[SZ_ZONE_TYPE] == DEV_ROLE_MAP.APP and msg.payload.get(
-                SZ_DEVICES
-            ):
-                self._gwy.get_device(
-                    msg.payload[SZ_DEVICES][0], parent=self, child_id=FC
-                )  # sets self._app_cntrl
+            if isinstance(msg.payload, dict):
+                if msg.payload[SZ_ZONE_TYPE] == DEV_ROLE_MAP.APP and msg.payload.get(
+                    SZ_DEVICES
+                ):
+                    self._gwy.get_device(
+                        msg.payload[SZ_DEVICES][0], parent=self, child_id=FC
+                    )  # sets self._app_cntrl
+            else:
+                _LOGGER.warning(
+                    f"{msg!r} < Unexpected payload type for {msg.code}: {type(msg.payload)} (expected dict)"
+                )
             return
 
-        if msg.code == Code._3150:
-            if msg.payload.get(SZ_DOMAIN_ID) == FC and msg.verb in (I_, RP):
-                self._heat_demand = msg.payload
+        if msg.code == Code._3150 and msg.verb in (I_, RP):
+            # 3150 payload can be a dict (old) or list (new, multi-zone)
+            if isinstance(msg.payload, list):
+                if payload := next(
+                    (d for d in msg.payload if d.get(SZ_DOMAIN_ID) == FC), None
+                ):
+                    self._heat_demand = payload
+            elif isinstance(msg.payload, dict):
+                if msg.payload.get(SZ_DOMAIN_ID) == FC:
+                    self._heat_demand = msg.payload
+            else:
+                _LOGGER.warning(
+                    f"{msg!r} < Unexpected payload type for {msg.code}: {type(msg.payload)} (expected list/dict)"
+                )
 
         if self._gwy.config.enable_eavesdrop and not self.appliance_control:
             eavesdrop_appliance_control(msg)
@@ -588,7 +604,12 @@ class ScheduleSync(SystemBase):  # 0006 (+/- 0404?)
         super()._handle_msg(msg)
 
         if msg.code == Code._0006:
-            self._msg_0006 = msg
+            if isinstance(msg.payload, dict):
+                self._msg_0006 = msg
+            else:
+                _LOGGER.warning(
+                    f"{msg!r} < Unexpected payload type for {msg.code}: {type(msg.payload)} (expected dict)"
+                )
 
     async def _schedule_version(self, *, force_io: bool = False) -> tuple[int, bool]:
         """Return the global schedule version number, and an indication if I/O was done.
@@ -706,7 +727,12 @@ class Logbook(SystemBase):  # 0418
         super()._handle_msg(msg)
 
         if msg.code == Code._0418:  # and msg.verb in (I_, RP):
-            self._faultlog.handle_msg(msg)
+            if isinstance(msg.payload, dict):
+                self._faultlog.handle_msg(msg)
+            else:
+                _LOGGER.warning(
+                    f"{msg!r} < Unexpected payload type for {msg.code}: {type(msg.payload)} (expected dict)"
+                )
 
     async def get_faultlog(
         self,

{ramses_rf-0.53.3 → ramses_rf-0.53.5}/ramses_rf/version.py

@@ -1,4 +1,4 @@
 """RAMSES RF - a RAMSES-II protocol decoder & analyser (application layer)."""
 
-__version__ = "0.53.3"
+__version__ = "0.53.5"
 VERSION = __version__

{ramses_rf-0.53.3 → ramses_rf-0.53.5}/ramses_tx/__init__.py

@@ -7,6 +7,7 @@ from __future__ import annotations
 
 import asyncio
 from functools import partial
+from logging.handlers import QueueListener
 from typing import TYPE_CHECKING, Any
 
 from .address import (
@@ -156,17 +157,19 @@ if TYPE_CHECKING:
     from logging import Logger
 
 
-async def set_pkt_logging_config(**config: Any) -> Logger:
+async def set_pkt_logging_config(**config: Any) -> tuple[Logger, QueueListener | None]:
     """
     Set up ramses packet logging to a file or port.
-    Must run async in executor to prevent HA blocking call opening packet log file (issue #200)
+    Must run async in executor to prevent HA blocking call opening packet log file.
 
     :param config: if file_name is included, opens packet_log file
-    :return: a logging.Logger
+    :return: a tuple (logging.Logger, QueueListener)
     """
     loop = asyncio.get_running_loop()
-    await loop.run_in_executor(None, partial(set_pkt_logging, PKT_LOGGER, **config))
-    return PKT_LOGGER
+    listener = await loop.run_in_executor(
+        None, partial(set_pkt_logging, PKT_LOGGER, **config)
+    )
+    return PKT_LOGGER, listener
 
 
 def extract_known_hgi_id(

{ramses_rf-0.53.3 → ramses_rf-0.53.5}/ramses_tx/const.py

@@ -20,10 +20,12 @@ DEFAULT_DISABLE_QOS: Final[bool | None] = None
 DEFAULT_WAIT_FOR_REPLY: Final[bool | None] = None
 
 #: Waiting for echo pkt after cmd sent (seconds)
-DEFAULT_ECHO_TIMEOUT: Final[float] = 0.50
+# NOTE: Increased to 3.0s to support high-latency transports (e.g., MQTT)
+DEFAULT_ECHO_TIMEOUT: Final[float] = 3.00
 
 #: Waiting for reply pkt after echo pkt rcvd (seconds)
-DEFAULT_RPLY_TIMEOUT: Final[float] = 0.50
+# NOTE: Increased to 3.0s to support high-latency transports (e.g., MQTT)
+DEFAULT_RPLY_TIMEOUT: Final[float] = 3.00
 DEFAULT_BUFFER_SIZE: Final[int] = 32
 
 #: Total waiting for successful send (seconds)