ramses-rf 0.53.3__py3-none-any.whl → 0.53.5__py3-none-any.whl

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/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/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/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/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/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/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.dist-info → ramses_rf-0.53.5.dist-info}/METADATA

@@ -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.dist-info → ramses_rf-0.53.5.dist-info}/RECORD

@@ -1,5 +1,5 @@
 ramses_cli/__init__.py,sha256=d_3uIFkK8JnWOxknrBloKCe6-vI9Ouo_KGqR4kfBQW8,417
-ramses_cli/client.py,sha256=Fd6hXGBvI-i89Xu8QbBU9NW-dWlQjSer-_LYAtvJPW4,25055
+ramses_cli/client.py,sha256=w95Xv2_kVlYelI5XnGt6D2QVLG3guiSMqo_MO1Ni-dc,25277
 ramses_cli/debug.py,sha256=PLcz-3PjUiMVqtD_p6VqTA92eHUM58lOBFXh_qgQ_wA,576
 ramses_cli/discovery.py,sha256=WTcoFH5hNhQ1AeOZtpdZIVYwdUfmUKlq2iBpa-KcgoI,12512
 ramses_cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -8,50 +8,50 @@ ramses_cli/utils/convert.py,sha256=N3LxGe3_0pclijtmYW-ChqCuPTzbkoJA4XNAnoSnBk0,1
 ramses_rf/__init__.py,sha256=AXsCK1Eh9FWeAI9D_zY_2KB0dqrTb9a5TNY1NvyQaDM,1271
 ramses_rf/binding_fsm.py,sha256=fuqvcc9YW-wr8SPH8zadpPqrHAvzl_eeWF-IBtlLppY,26632
 ramses_rf/const.py,sha256=L3z31CZ-xqno6oZp_h-67CB_5tDDqTwSWXsqRtsjMcs,5460
-ramses_rf/database.py,sha256=Fv3Xv6S_7qOf6-biHHKZvntkB8ps_SJvjPlKX0pzGfg,23919
+ramses_rf/database.py,sha256=eARZ8F5lcITK6d_MfvozmMxSGNkiy1kbtAh0NOIHMoc,24066
 ramses_rf/dispatcher.py,sha256=YjEU-QrBLo9IfoEhJo2ikg_FxOaMYoWvzelr9Vi-JZ8,11398
-ramses_rf/entity_base.py,sha256=L47P_6CRz3tLDzOzII9AgmueKDb-Bp7Ot3vVsr8jo10,59121
+ramses_rf/entity_base.py,sha256=Lv4N3dyIRfsz_5Ztgcu4bc49UE-N4c1VuN732_HQp-g,59255
 ramses_rf/exceptions.py,sha256=mt_T7irqHSDKir6KLaf6oDglUIdrw0S40JbOrWJk5jc,3657
-ramses_rf/gateway.py,sha256=hHsXbpeZ2Fetpu3jzv8UeUwlNf4rsxOD7eOHuLY83Xk,30101
+ramses_rf/gateway.py,sha256=BsS3gyFcSOCLuzQ_OxgyqHTcn2wAVsEJaV6B5PbYre0,31087
 ramses_rf/helpers.py,sha256=TNk_QkpIOB3alOp1sqnA9LOzi4fuDCeapNlW3zTzNas,4250
 ramses_rf/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ramses_rf/schemas.py,sha256=X1GAK3kttuLMiSCUDY2s-85fgBxPeU8xiDa6gJ1I5mY,13543
-ramses_rf/storage.py,sha256=lGKUgQzXBUwksmEeHMLoVoKPCMPAWWuzwCXM8G2CKmg,6452
-ramses_rf/version.py,sha256=2TZdwRJV5RSMyoyplQPOveNyPUW-VUGwr0W9X-R6arE,125
+ramses_rf/storage.py,sha256=ZFUhvgsWRCVS1_r6LL032XFEJwZVp1RAK8Nfba8nf7o,7052
+ramses_rf/version.py,sha256=HfkMfk1rLOZbqMvqEgE1o6j48RTa0l-dHJ-_7nrquYM,125
 ramses_rf/device/__init__.py,sha256=sUbH5dhbYFXSoM_TPFRutpRutBRpup7_cQ9smPtDTy8,4858
 ramses_rf/device/base.py,sha256=Tu5I8Lj7KplfRsIBQAYjilS6YPgTyjpU8qgKugMR2Jk,18281
 ramses_rf/device/heat.py,sha256=CU6GlIgjuYD21braJ_RJlS56zP47TGXNxXnZeavfEMY,54654
 ramses_rf/device/hvac.py,sha256=vdgiPiLtCAGr7CVsGhQl6XuAFkyYdQSE_2AEdCmRl2I,48502
 ramses_rf/system/__init__.py,sha256=uZLKio3gLlBzePa2aDQ1nxkcp1YXOGrn6iHTG8LiNIw,711
 ramses_rf/system/faultlog.py,sha256=GdGmVGT3137KsTlV_nhccgIFEmYu6DFsLTn4S-8JSok,12799
-ramses_rf/system/heat.py,sha256=qQmzgmyHy2x87gHAstn0ee7ZVVOq-GJIfDxCrC-6gFU,39254
+ramses_rf/system/heat.py,sha256=31vCAgazc3x27XdMbz6UWH_nt2y-W483Ud0kA7-qpEI,40522
 ramses_rf/system/schedule.py,sha256=Ts6tdZPTQLV5NkgwA73tPa5QUsnZNIIuYoKC-8VsXDk,18808
 ramses_rf/system/zones.py,sha256=6VbPsOuNbGwBUuiRu8w9D1Q18SHKkuZa2YtKTE5nqlo,37110
-ramses_tx/__init__.py,sha256=sqnjM7pUGJDmec6igTtKViSB8FLX49B5gwhAmcY9ERY,3596
+ramses_tx/__init__.py,sha256=2Ouc5CQJ3O0W4P8BAm5ThST6NbErhrTCp_jxVn816AM,3714
 ramses_tx/address.py,sha256=IuwUwZxykn3fP1UCRcv4D-zbTICBe2FJjDAFX5X6VoI,9108
 ramses_tx/command.py,sha256=drxmpdM4YgyPg4h0QIr1ouxK9QjfeLVgnFpDRox0CCY,125652
-ramses_tx/const.py,sha256=jiE2UaGBJ5agr68EMrcEHWtVz2KMidU7c7rRYCIiaoM,33010
+ramses_tx/const.py,sha256=bkIP8NNGKY2dH37LRFYBdOKM23UZ35kgcsqmS28Kbf0,33158
 ramses_tx/exceptions.py,sha256=FJSU9YkvpKjs3yeTqUJX1o3TPFSe_B01gRGIh9b3PNc,2632
 ramses_tx/fingerprints.py,sha256=nfftA1E62HQnb-eLt2EqjEi_la0DAoT0wt-PtTMie0s,11974
 ramses_tx/frame.py,sha256=GzNsXr15YLeidJYGtk_xPqsZQh4ehDDlUCtT6rTDhT8,22046
-ramses_tx/gateway.py,sha256=H4JtIkp7JFMyZZ76sij67rTbjc1i3iWaIf6tuxIpHAg,11529
+ramses_tx/gateway.py,sha256=tJVyuKjftkcAVVCJTxQ4vZZKiI0KwYwIXA1t8QYclh4,11725
 ramses_tx/helpers.py,sha256=96OvSOWYuMcr89_c-3dRnqHZaMOctCO94uo1hETh3bc,33613
-ramses_tx/logger.py,sha256=1iKRHKUaqHqGd76CkE_6mCVR0sYODtxshRRwfY61fTk,10426
+ramses_tx/logger.py,sha256=EizcFiuDPMf0eVbkfyo_ka2DHz1MsrbzdrYSZoQY5KU,10981
 ramses_tx/message.py,sha256=zsyDQztSUYeqj3-P598LSmy9ODQY2BUCzWxSoZds6bM,13953
 ramses_tx/opentherm.py,sha256=58PXz9l5x8Ou6Fm3y-R_UnGHCYahoi2RKIDdYStUMzk,42378
 ramses_tx/packet.py,sha256=_nzuInS_WhdOI26SYvgsdDqIaDvVNguc2YDwdPOVCbU,7661
-ramses_tx/parsers.py,sha256=CJKdLF1F5KR7MwYxwkwSvrusTONh5FGecj7_eeBWu7A,148609
-ramses_tx/protocol.py,sha256=nBPKCD1tcGp_FiX0qhsY0XoGO_h87w5cYywBjSpum4w,33048
+ramses_tx/parsers.py,sha256=ALUoi21ewd_GZHvxq4051AcVwETOTgVr5feWaY7zdls,148659
+ramses_tx/protocol.py,sha256=E62vWb8qY7_SB5tb_NcywAED4d9NJJJ-1NgMaK3HG5s,33198
 ramses_tx/protocol_fsm.py,sha256=o9vLvlXor3LkPgsY1zii5P1R01GzYLf_PECDdoxtC24,27520
 ramses_tx/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ramses_tx/ramses.py,sha256=V4LqD6IaohU7TTZp-_f1K2SOCJwzRY0v8_-INESh2cU,53986
+ramses_tx/ramses.py,sha256=89EFL91zwnArefVcEVw3KoyqF92d3r3aBoJapMNAT0I,54389
 ramses_tx/schemas.py,sha256=Hrmf_q9bAZtkKJzGu6GtUO0QV_-K9i4L99EzGWR13eE,13408
-ramses_tx/transport.py,sha256=U24yITMh8M2yZKxnSyBe4yoIZfsFt4v9PhFvGDR_CuM,75926
+ramses_tx/transport.py,sha256=RIrcNrJwiKB_xmJLgG4Z--V2d83PLsJnLXZK-WFFgsA,76568
 ramses_tx/typed_dicts.py,sha256=w-0V5t2Q3GiNUOrRAWiW9GtSwbta_7luME6GfIb1zhI,10869
 ramses_tx/typing.py,sha256=eF2SlPWhNhEFQj6WX2AhTXiyRQVXYnFutiepllYl2rI,5042
-ramses_tx/version.py,sha256=ps1zXjSlXEAn8-2HGlN4BfRIbiT1QSZo11KlMSwFdDY,123
-ramses_rf-0.53.3.dist-info/METADATA,sha256=EcLR1rL-xgkSjD0N3idYeMyGF1ptxyKjjNU1wsYFjSI,4179
-ramses_rf-0.53.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-ramses_rf-0.53.3.dist-info/entry_points.txt,sha256=NnyK29baOCNg8DinPYiZ368h7MTH7bgTW26z2A1NeIE,50
-ramses_rf-0.53.3.dist-info/licenses/LICENSE,sha256=ptVutrtSMr7X-ek6LduiD8Cce4JsNn_8sR8MYlm-fvo,1086
-ramses_rf-0.53.3.dist-info/RECORD,,
+ramses_tx/version.py,sha256=j6vK_nd2r1udUd4SmgheUwwD64f35BfwQoHsuHcFaYs,123
+ramses_rf-0.53.5.dist-info/METADATA,sha256=m53OVOic5uCyW6ScGRSjARqKekXiTbJ4T2KLIMDe3LE,4179
+ramses_rf-0.53.5.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+ramses_rf-0.53.5.dist-info/entry_points.txt,sha256=NnyK29baOCNg8DinPYiZ368h7MTH7bgTW26z2A1NeIE,50
+ramses_rf-0.53.5.dist-info/licenses/LICENSE,sha256=ptVutrtSMr7X-ek6LduiD8Cce4JsNn_8sR8MYlm-fvo,1086
+ramses_rf-0.53.5.dist-info/RECORD,,

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_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)

ramses_tx/gateway.py

@@ -12,7 +12,6 @@ import asyncio
 import logging
 from collections.abc import Callable
 from datetime import datetime as dt
-from threading import Lock
 from typing import TYPE_CHECKING, Any, Never
 
 from .address import ALL_DEV_ADDR, HGI_DEV_ADDR, NON_DEV_ADDR
@@ -80,6 +79,7 @@ class Engine:
         packet_log: PktLogConfigT | None = None,
         block_list: DeviceListT | None = None,
         known_list: DeviceListT | None = None,
+        hgi_id: str | None = None,
         loop: asyncio.AbstractEventLoop | None = None,
         **kwargs: Any,
     ) -> None:
@@ -120,7 +120,11 @@ class Engine:
         self._log_all_mqtt = kwargs.pop(SZ_LOG_ALL_MQTT, False)
         self._kwargs: dict[str, Any] = kwargs  # HACK
 
-        self._engine_lock = Lock()  # FIXME: threading lock, or asyncio lock?
+        self._hgi_id = hgi_id
+        if self._hgi_id:
+            self._kwargs[SZ_ACTIVE_HGI] = self._hgi_id
+
+        self._engine_lock = asyncio.Lock()
         self._engine_state: (
             tuple[_MsgHandlerT | None, bool | None, *tuple[Any, ...]] | None
         ) = None
@@ -136,6 +140,9 @@ class Engine:
         self._set_msg_handler(self._msg_handler)  # sets self._protocol
 
     def __str__(self) -> str:
+        if self._hgi_id:
+            return f"{self._hgi_id} ({self.ser_name})"
+
         if not self._transport:
             return f"{HGI_DEV_ADDR.id} ({self.ser_name})"
 
@@ -217,15 +224,13 @@ class Engine:
     async def stop(self) -> None:
         """Close the transport (will stop the protocol)."""
 
-        async def cancel_all_tasks() -> None:  # TODO: needs a lock?
-            _ = [t.cancel() for t in self._tasks if not t.done()]
-            try:  # FIXME: this is broken
-                if tasks := (t for t in self._tasks if not t.done()):
-                    await asyncio.gather(*tasks)
-            except asyncio.CancelledError:
-                pass
+        # Shutdown Safety - wait for tasks to clean up
+        tasks = [t for t in self._tasks if not t.done()]
+        for t in tasks:
+            t.cancel()
 
-        await cancel_all_tasks()
+        if tasks:
+            await asyncio.wait(tasks)
 
         if self._transport:
             self._transport.close()
@@ -233,12 +238,14 @@ class Engine:
 
         return None
 
-    def _pause(self, *args: Any) -> None:
+    async def _pause(self, *args: Any) -> None:
         """Pause the (active) engine or raise a RuntimeError."""
-
-        if not self._engine_lock.acquire(blocking=False):
+        # Async lock handling
+        if self._engine_lock.locked():
             raise RuntimeError("Unable to pause engine, failed to acquire lock")
 
+        await self._engine_lock.acquire()
+
         if self._engine_state is not None:
             self._engine_lock.release()
             raise RuntimeError("Unable to pause engine, it is already paused")
@@ -255,13 +262,18 @@ class Engine:
 
         self._engine_state = (handler, read_only, *args)
 
-    def _resume(self) -> tuple[Any]:  # FIXME: not atomic
+    async def _resume(self) -> tuple[Any]:  # FIXME: not atomic
         """Resume the (paused) engine or raise a RuntimeError."""
 
         args: tuple[Any]  # mypy
 
-        if not self._engine_lock.acquire(timeout=0.1):
-            raise RuntimeError("Unable to resume engine, failed to acquire lock")
+        # Async lock with timeout
+        try:
+            await asyncio.wait_for(self._engine_lock.acquire(), timeout=0.1)
+        except TimeoutError as err:
+            raise RuntimeError(
+                "Unable to resume engine, failed to acquire lock"
+            ) from err
 
         if self._engine_state is None:
             self._engine_lock.release()

ramses_tx/logger.py

@@ -12,7 +12,12 @@ import shutil
 import sys
 from collections.abc import Callable, Mapping
 from datetime import datetime as dt
-from logging.handlers import TimedRotatingFileHandler as _TimedRotatingFileHandler
+from logging.handlers import (
+    QueueHandler,
+    QueueListener,
+    TimedRotatingFileHandler as _TimedRotatingFileHandler,
+)
+from queue import Queue
 from typing import Any
 
 from .version import VERSION
@@ -239,7 +244,7 @@ def set_pkt_logging(
     file_name: str | None = None,
     rotate_backups: int = 0,
     rotate_bytes: int | None = None,
-) -> None:
+) -> QueueListener | None:
     """Create/configure handlers, formatters, etc.
 
     Parameters:
@@ -255,6 +260,8 @@ def set_pkt_logging(
     for handler in logger.handlers:  # dont use logger.hasHandlers() as not propagating
         logger.removeHandler(handler)
 
+    handlers: list[logging.Handler] = []
+
     if file_name:  # note: this opens the packet_log file IO and may block
         if rotate_bytes:
             rotate_backups = rotate_backups or 2
@@ -273,14 +280,15 @@ def set_pkt_logging(
         handler.setFormatter(logfile_fmt)
         handler.setLevel(logging.INFO)  # .INFO (usually), or .DEBUG
         handler.addFilter(PktLogFilter())  # record.levelno in (.INFO, .WARNING)
-        logger.addHandler(handler)
+        handlers.append(handler)
 
     elif cc_console:
-        logger.addHandler(logging.NullHandler())
+        # logger.addHandler(logging.NullHandler())  # Not needed with QueueHandler
+        pass
 
-    else:
+    elif not cc_console:
         logger.setLevel(logging.CRITICAL)
-        return
+        return None
 
     if cc_console:  # CC: output to stdout/stderr
         console_fmt: ColoredFormatter | Formatter
@@ -297,13 +305,22 @@ def set_pkt_logging(
         handler.setFormatter(console_fmt)
         handler.setLevel(logging.WARNING)  # musr be .WARNING or less
         handler.addFilter(StdErrFilter())  # record.levelno >= .WARNING
-        logger.addHandler(handler)
+        handlers.append(handler)
 
         handler = logging.StreamHandler(stream=sys.stdout)
         handler.setFormatter(console_fmt)
         handler.setLevel(logging.DEBUG)  # must be .INFO or less
         handler.addFilter(StdOutFilter())  # record.levelno < .WARNING
-        logger.addHandler(handler)
+        handlers.append(handler)
+
+    # Use QueueHandler to decouple logging I/O from the main loop (see Issue #397)
+    if handlers:
+        log_queue: Queue[Any] = Queue(-1)
+        listener = QueueListener(log_queue, *handlers, respect_handler_level=True)
+        queue_handler = QueueHandler(log_queue)
+        logger.addHandler(queue_handler)
+    else:
+        return None
 
     extras = {
         "_frame": "",
@@ -311,3 +328,5 @@ def set_pkt_logging(
         "comment": f"ramses_tx {VERSION}",
     }
     logger.warning("", extra=extras)  # initial log line
+
+    return listener

ramses_tx/parsers.py

@@ -1898,6 +1898,7 @@ def parser_2210(payload: str, msg: Message) -> dict[str, Any]:
         assert payload[80:82] in (
             "01",
             "08",
+            "0C",  # seen on Orcon HCR-400 EcoMax
         ), f"expected byte 40 (01|08), not {payload[80:82]}"
         assert payload[82:] in (
             "00",

ramses_tx/protocol.py

@@ -215,6 +215,41 @@ class _BaseProtocol(asyncio.Protocol):
         """Allow the Protocol to send an impersonation alert (stub)."""
         return
 
+    def _patch_cmd_if_needed(self, cmd: Command) -> Command:
+        """Patch the command with the actual HGI ID if it uses the default placeholder.
+
+        Legacy HGI80s (TI 3410) require the default ID (18:000730), or they will
+        silent-fail. However, evofw3 devices prefer the real ID.
+        """
+        # NOTE: accessing private member cmd._addrs to safely patch the source address
+
+        if (
+            self.hgi_id
+            and self._is_evofw3  # Only patch if using evofw3 (not HGI80)
+            and cmd._addrs[0].id == HGI_DEV_ADDR.id
+            and self.hgi_id != HGI_DEV_ADDR.id
+        ):
+            _LOGGER.debug(
+                f"Patching command with active HGI ID: swapped {HGI_DEV_ADDR.id} "
+                f"-> {self.hgi_id} for {cmd._hdr}"
+            )
+
+            # Get current addresses as strings
+            new_addrs = [a.id for a in cmd._addrs]
+
+            # ONLY patch the Source Address (Index 0).
+            # Leave Dest (Index 1/2) alone to avoid breaking tests that expect 18:000730.
+            new_addrs[0] = self.hgi_id
+
+            # Reconstruct the command string with the correct address
+            new_frame = (
+                f"{cmd.verb} {cmd.seqn} {new_addrs[0]} {new_addrs[1]} {new_addrs[2]} "
+                f"{cmd.code} {int(cmd.len_):03d} {cmd.payload}"
+            )
+            return Command(new_frame)
+
+        return cmd
+
     async def send_cmd(
         self,
         cmd: Command,
@@ -249,35 +284,8 @@ class _BaseProtocol(asyncio.Protocol):
         assert gap_duration == DEFAULT_GAP_DURATION
         assert 0 <= num_repeats <= 3  # if QoS, only Tx x1, with no repeats
 
-        # FIX: Patch command with actual HGI ID if it uses the default placeholder
-        # NOTE: HGI80s (TI 3410) require the default ID (18:000730), or they will silent-fail
-
-        if (
-            self.hgi_id
-            and self._is_evofw3  # Only patch if using evofw3 (not HGI80)
-            and cmd._addrs[0].id == HGI_DEV_ADDR.id
-            and self.hgi_id != HGI_DEV_ADDR.id
-        ):
-            # The command uses the default 18:000730, but we know the real ID.
-            # Reconstruct the command string with the correct address.
-
-            _LOGGER.debug(
-                f"Patching command with active HGI ID: swapped {HGI_DEV_ADDR.id} -> {self.hgi_id} for {cmd._hdr}"
-            )
-
-            # Get current addresses as strings
-            # The command uses the default 18:000730, but we know the real ID.
-            # Reconstruct the command string with the correct address.
-
-            # Get current addresses as strings
-            new_addrs = [a.id for a in cmd._addrs]
-
-            # ONLY patch the Source Address (Index 0).
-            # Leave Dest (Index 1/2) alone to avoid breaking tests that expect 18:000730 there.
-            new_addrs[0] = self.hgi_id
-
-            new_frame = f"{cmd.verb} {cmd.seqn} {new_addrs[0]} {new_addrs[1]} {new_addrs[2]} {cmd.code} {int(cmd.len_):03d} {cmd.payload}"
-            cmd = Command(new_frame)
+        # Patch command with actual HGI ID if it uses the default placeholder
+        cmd = self._patch_cmd_if_needed(cmd)
 
         if qos and not self._context:
             _LOGGER.warning(f"{cmd} < QoS is currently disabled by this Protocol")

ramses_tx/ramses.py

@@ -1,5 +1,14 @@
 #!/usr/bin/env python3
-"""RAMSES RF - a RAMSES-II protocol decoder & analyser."""
+"""RAMSES RF - a RAMSES-II protocol decoder & analyser.
+
+Contains e.g.:
+:term:`CODES_SCHEMA` the master list of all known Ramses-II Code signatures
+for both HEAT and HVAC.
+:term:`_DEV_KLASSES_HEAT` defining Codes expected for each HEAT device class (SLUG).
+:term:`_DEV_KLASSES_HVAC` defining Codes expected for each HVAC device class (SLUG).
+:term:`_22F1_MODE_XXX` dicts defining valid fan commands.
+:term:`_2411_PARAMS_SCHEMA` defining HVAC fan parameters.
+"""
 
 # TODO: code a lifespan for most packets
 

ramses_tx/transport.py

@@ -49,7 +49,6 @@ import logging
 import os
 import re
 import sys
-import time
 from collections import deque
 from collections.abc import Awaitable, Callable, Iterable
 from datetime import datetime as dt, timedelta as td
@@ -979,18 +978,21 @@ class FileTransport(_ReadTransport, _FileTransportAbstractor):
         if bool(disable_sending) is False:
             raise exc.TransportSourceInvalid("This Transport cannot send packets")
 
+        self._evt_reading = asyncio.Event()
+
         self._extra[SZ_READER_TASK] = self._reader_task = self._loop.create_task(
             self._start_reader(), name="FileTransport._start_reader()"
         )
 
         self._make_connection(None)
 
-    async def _start_reader(self) -> None:  # TODO
+    async def _start_reader(self) -> None:
         """Start the reader task."""
         self._reading = True
+        self._evt_reading.set()  # Start in reading state
+
         try:
-            # await self._reader()
-            await self.loop.run_in_executor(None, self._blocking_reader)
+            await self._producer_loop()
         except Exception as err:
             self.loop.call_soon_threadsafe(
                 functools.partial(self._protocol.connection_lost, err)  # type: ignore[arg-type]
@@ -1000,47 +1002,59 @@ class FileTransport(_ReadTransport, _FileTransportAbstractor):
                 functools.partial(self._protocol.connection_lost, None)
             )
 
-    def _blocking_reader(self) -> None:
+    def pause_reading(self) -> None:
+        """Pause the receiving end (no data to protocol.pkt_received())."""
+        self._reading = False
+        self._evt_reading.clear()  # Puts the loop to sleep efficiently
+
+    def resume_reading(self) -> None:
+        """Resume the receiving end."""
+        self._reading = True
+        self._evt_reading.set()  # Wakes the loop immediately
+
+    async def _producer_loop(self) -> None:
         """Loop through the packet source for Frames and process them."""
+        # NOTE: fileinput interaction remains synchronous-blocking for simplicity,
+        # but the PAUSE mechanism is now async-non-blocking.
 
         if isinstance(self._pkt_source, dict):
             for dtm_str, pkt_line in self._pkt_source.items():  # assume dtm_str is OK
-                self._process_line(dtm_str, pkt_line)
+                await self._process_line(dtm_str, pkt_line)
 
         elif isinstance(self._pkt_source, str):  # file_name, used in client parse
             # open file file_name before reading
             try:
                 with fileinput.input(files=self._pkt_source, encoding="utf-8") as file:
                     for dtm_pkt_line in file:  # self._pkt_source:
-                        self._process_line_from_raw(dtm_pkt_line)
+                        await self._process_line_from_raw(dtm_pkt_line)
             except FileNotFoundError as err:
                 _LOGGER.warning(f"Correct the packet file name; {err}")
 
         elif isinstance(self._pkt_source, TextIOWrapper):  # used by client monitor
             for dtm_pkt_line in self._pkt_source:  # should check dtm_str is OK
-                self._process_line_from_raw(dtm_pkt_line)
+                await self._process_line_from_raw(dtm_pkt_line)
 
         else:
             raise exc.TransportSourceInvalid(
                 f"Packet source is not dict, TextIOWrapper or str: {self._pkt_source:!r}"
             )
 
-    def _process_line_from_raw(self, line: str) -> None:
+    async def _process_line_from_raw(self, line: str) -> None:
         """Helper to process raw lines."""
         # there may be blank lines in annotated log files
         if (line := line.strip()) and line[:1] != "#":
-            self._process_line(line[:26], line[27:])
+            await self._process_line(line[:26], line[27:])
             # this is where the parsing magic happens!
 
-    def _process_line(self, dtm_str: str, frame: str) -> None:
+    async def _process_line(self, dtm_str: str, frame: str) -> None:
         """Push frame to protocol in a thread-safe way."""
-        while not self._reading:
-            time.sleep(0.001)
+        # Efficient wait - 0% CPU usage while paused
+        await self._evt_reading.wait()
 
         self._frame_read(dtm_str, frame)
 
-        # NOTE: instable without, big performance penalty if delay >0
-        time.sleep(0)
+        # Yield control to the event loop to prevent starvation during large file reads
+        await asyncio.sleep(0)
 
     def _close(self, exc: exc.RamsesException | None = None) -> None:
         """Close the transport (cancel any outstanding tasks).

ramses_tx/version.py

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