ramses-rf 0.53.4__py3-none-any.whl → 0.53.6__py3-none-any.whl

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/dispatcher.py

@@ -270,7 +270,11 @@ def process_msg(gwy: Gateway, msg: Message) -> None:
         )
 
     except (AttributeError, LookupError, TypeError, ValueError) as err:
-        _LOGGER.exception("%s < %s(%s)", msg._pkt, err.__class__.__name__, err)
+        if getattr(gwy.config, "enforce_strict_handling", False):
+            raise
+        _LOGGER.warning(
+            "%s < %s(%s)", msg._pkt, err.__class__.__name__, err, exc_info=True
+        )
 
     else:
         logger_xxxx(msg)

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
@@ -271,6 +279,13 @@ class Gateway(Engine):
         # 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()
 

ramses_rf/schemas.py

@@ -245,6 +245,7 @@ SCH_GLOBAL_SCHEMAS = vol.Schema(SCH_GLOBAL_SCHEMAS_DICT, extra=vol.PREVENT_EXTRA
 # 4/7: Gateway (parser/state) configuration
 SZ_DISABLE_DISCOVERY: Final = "disable_discovery"
 SZ_ENABLE_EAVESDROP: Final = "enable_eavesdrop"
+SZ_ENFORCE_STRICT_HANDLING: Final = "enforce_strict_handling"
 SZ_MAX_ZONES: Final = "max_zones"  # TODO: move to TCS-attr from GWY-layer
 SZ_REDUCE_PROCESSING: Final = "reduce_processing"
 SZ_USE_ALIASES: Final = "use_aliases"  # use friendly device names from known_list
@@ -253,6 +254,7 @@ SZ_USE_NATIVE_OT: Final = "use_native_ot"  # favour OT (3220s) over RAMSES
 SCH_GATEWAY_DICT = {
     vol.Optional(SZ_DISABLE_DISCOVERY, default=False): bool,
     vol.Optional(SZ_ENABLE_EAVESDROP, default=False): bool,
+    vol.Optional(SZ_ENFORCE_STRICT_HANDLING, default=False): bool,
     vol.Optional(SZ_MAX_ZONES, default=DEFAULT_MAX_ZONES): vol.All(
         int, vol.Range(min=1, max=16)
     ),  # NOTE: no default

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.4"
+__version__ = "0.53.6"
 VERSION = __version__

{ramses_rf-0.53.4.dist-info → ramses_rf-0.53.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ramses_rf
-Version: 0.53.4
+Version: 0.53.6
 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
@@ -62,11 +62,11 @@ To install the `ramses_rf` command line client:
 ```
 git clone https://github.com/ramses-rf/ramses_rf
 cd ramses_rf
-pip install -r requirements.txt
+pip install -r requirements/requirements.txt
 pip install -e .
 ```
 
-The CLI is called ``client.py`` and is included in the code root.
+The CLI is called `client.py` and is included in the code root.
 It has options to monitor and parse Ramses-II traffic to screen or a log file, and to parse a file containing Ramses-II messages to the screen.
 See the [client.py CLI wiki page](https://github.com/ramses-rf/ramses_rf/wiki/2.-The-client.py-command-line) for instructions.
 

{ramses_rf-0.53.4.dist-info → ramses_rf-0.53.6.dist-info}/RECORD

@@ -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/dispatcher.py,sha256=YjEU-QrBLo9IfoEhJo2ikg_FxOaMYoWvzelr9Vi-JZ8,11398
-ramses_rf/entity_base.py,sha256=L47P_6CRz3tLDzOzII9AgmueKDb-Bp7Ot3vVsr8jo10,59121
+ramses_rf/database.py,sha256=eARZ8F5lcITK6d_MfvozmMxSGNkiy1kbtAh0NOIHMoc,24066
+ramses_rf/dispatcher.py,sha256=pHNrXOLeAp6i9TUZEPNOB1AevlKkQyUfX2dkr-EzrDw,11517
+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=3rnKm-OunN-O_T0eS9ZayEvg49WMVe7GF4pJhyGx3Io,30409
+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=4QvpG_-UTxyow-YNsbbOguS-J5cqoyPKHelB0WfKMkA,125
+ramses_rf/schemas.py,sha256=k0IN2OvIgNGZ9lGkFMuM81jcjUqWvdGNfaccDBwfh_8,13672
+ramses_rf/storage.py,sha256=ZFUhvgsWRCVS1_r6LL032XFEJwZVp1RAK8Nfba8nf7o,7052
+ramses_rf/version.py,sha256=Qfhbwe6tvYg3scyTH0mknbjnE0tb-XQ19FcHCCdu8CM,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=kJv3jRI66Ii-kxZO6ItbPODW2oJf-e46ou2JdQt0yTY,11498
+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/protocol_fsm.py,sha256=o9vLvlXor3LkPgsY1zii5P1R01GzYLf_PECDdoxtC24,27520
+ramses_tx/parsers.py,sha256=ALUoi21ewd_GZHvxq4051AcVwETOTgVr5feWaY7zdls,148659
+ramses_tx/protocol.py,sha256=E62vWb8qY7_SB5tb_NcywAED4d9NJJJ-1NgMaK3HG5s,33198
+ramses_tx/protocol_fsm.py,sha256=uT0jLuTsz_6zUJSvdMG200xbYQIFgqfzJ0t3l5bTTTc,27741
 ramses_tx/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ramses_tx/ramses.py,sha256=V4LqD6IaohU7TTZp-_f1K2SOCJwzRY0v8_-INESh2cU,53986
-ramses_tx/schemas.py,sha256=Hrmf_q9bAZtkKJzGu6GtUO0QV_-K9i4L99EzGWR13eE,13408
-ramses_tx/transport.py,sha256=RIrcNrJwiKB_xmJLgG4Z--V2d83PLsJnLXZK-WFFgsA,76568
+ramses_tx/ramses.py,sha256=89EFL91zwnArefVcEVw3KoyqF92d3r3aBoJapMNAT0I,54389
+ramses_tx/schemas.py,sha256=Bh877L2lmsrtq86ygQEnlbalcyRSEvfsjRnub-9P6X4,13495
+ramses_tx/transport.py,sha256=W2y6em3PQytTYnREZsm2b2-FQeZQCciY2UprBa8-PM8,77057
 ramses_tx/typed_dicts.py,sha256=w-0V5t2Q3GiNUOrRAWiW9GtSwbta_7luME6GfIb1zhI,10869
 ramses_tx/typing.py,sha256=eF2SlPWhNhEFQj6WX2AhTXiyRQVXYnFutiepllYl2rI,5042
-ramses_tx/version.py,sha256=hutrhdcMJOwR4LO2siGwJHfwUmCNdXAWpBV8-SaqUVo,123
-ramses_rf-0.53.4.dist-info/METADATA,sha256=GNBabuxJgwv1H80fzFeCO31BSn0yI76V0cTeMKp2HjE,4179
-ramses_rf-0.53.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-ramses_rf-0.53.4.dist-info/entry_points.txt,sha256=NnyK29baOCNg8DinPYiZ368h7MTH7bgTW26z2A1NeIE,50
-ramses_rf-0.53.4.dist-info/licenses/LICENSE,sha256=ptVutrtSMr7X-ek6LduiD8Cce4JsNn_8sR8MYlm-fvo,1086
-ramses_rf-0.53.4.dist-info/RECORD,,
+ramses_tx/version.py,sha256=wG4Me_pyFvCD82_aAFqAut5OXMh7AJllw7_gB6uBe5M,123
+ramses_rf-0.53.6.dist-info/METADATA,sha256=RDKvYo4RMR13qU0XyXjxv9HumiHUaZeXfaWQc4SlLNs,4190
+ramses_rf-0.53.6.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+ramses_rf-0.53.6.dist-info/entry_points.txt,sha256=NnyK29baOCNg8DinPYiZ368h7MTH7bgTW26z2A1NeIE,50
+ramses_rf-0.53.6.dist-info/licenses/LICENSE,sha256=ptVutrtSMr7X-ek6LduiD8Cce4JsNn_8sR8MYlm-fvo,1086
+ramses_rf-0.53.6.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

@@ -79,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:
@@ -119,6 +120,10 @@ class Engine:
         self._log_all_mqtt = kwargs.pop(SZ_LOG_ALL_MQTT, False)
         self._kwargs: dict[str, Any] = kwargs  # HACK
 
+        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
@@ -135,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})"
 

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/protocol_fsm.py

@@ -145,13 +145,20 @@ class ProtocolContext:
             # nope, was not successful, so multiplier should be incremented...
             self._multiplier = min(3, old_val + 1)
 
+            if self._cmd_tx_count < 3:
+                level = logging.DEBUG
+            elif self._cmd_tx_count == 3:
+                level = logging.INFO
+            else:
+                level = logging.WARNING
+
             if isinstance(self._state, WantEcho):
-                _LOGGER.warning(
-                    f"Timeout expired waiting for echo: {self} (delay={delay})"
+                _LOGGER.log(
+                    level, f"Timeout expired waiting for echo: {self} (delay={delay})"
                 )
             else:  # isinstance(self._state, WantRply):
-                _LOGGER.warning(
-                    f"Timeout expired waiting for reply: {self} (delay={delay})"
+                _LOGGER.log(
+                    level, f"Timeout expired waiting for reply: {self} (delay={delay})"
                 )
 
             assert isinstance(self.is_sending, bool), (

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/schemas.py

@@ -407,6 +407,7 @@ def select_device_filter_mode(
 # 5/5: Gateway (engine) configuration
 
 SZ_DISABLE_SENDING: Final = "disable_sending"
+SZ_AUTOSTART: Final = "autostart"
 SZ_DISABLE_QOS: Final = "disable_qos"
 SZ_ENFORCE_KNOWN_LIST: Final[str] = f"enforce_{SZ_KNOWN_LIST}"
 SZ_EVOFW_FLAG: Final = "evofw_flag"
@@ -418,6 +419,7 @@ SZ_USE_REGEX: Final = "use_regex"
 
 SCH_ENGINE_DICT = {
     vol.Optional(SZ_DISABLE_SENDING, default=False): bool,
+    vol.Optional(SZ_AUTOSTART, default=False): bool,
     vol.Optional(SZ_DISABLE_QOS, default=None): vol.Any(
         None,  # None is selective QoS (e.g. QoS only for bindings, schedule, etc.)
         bool,

ramses_tx/transport.py

@@ -1278,8 +1278,9 @@ class PortTransport(_RegHackMixin, _FullTransport, _PortTransportAbstractor):  #
 
         super()._close(exc)
 
-        if self._init_task:
-            self._init_task.cancel()
+        # Use getattr because _init_task may not be set if initialization failed
+        if init_task := getattr(self, "_init_task", None):
+            init_task.cancel()
 
         if self._leaker_task:
             self._leaker_task.cancel()
@@ -1810,6 +1811,7 @@ class CallbackTransport(_FullTransport, _CallbackTransportAbstractor):
         protocol: RamsesProtocolT,
         io_writer: Callable[[str], Awaitable[None]],
         disable_sending: bool = False,
+        autostart: bool = False,
         **kwargs: Any,
     ) -> None:
         """Initialize the callback transport.
@@ -1820,6 +1822,8 @@ class CallbackTransport(_FullTransport, _CallbackTransportAbstractor):
         :type io_writer: Callable[[str], Awaitable[None]]
         :param disable_sending: Whether to disable sending, defaults to False.
         :type disable_sending: bool, optional
+        :param autostart: Whether to start reading immediately, defaults to False.
+        :type autostart: bool, optional
         """
         # Pass kwargs up the chain. _ReadTransport will extract 'loop' if present.
         # _BaseTransport will pass 'loop' to _CallbackTransportAbstractor, which consumes it.
@@ -1834,9 +1838,11 @@ class CallbackTransport(_FullTransport, _CallbackTransportAbstractor):
         # Section 6.1: Object Lifecycle Logging
         _LOGGER.info(f"CallbackTransport created with io_writer={io_writer}")
 
-        # NOTE: connection_made is NOT called here. It must be triggered
-        # externally (e.g. by the Bridge) via the protocol methods once
-        # the external connection is ready.
+        # Handshake: Notify protocol immediately (Safe: idempotent)
+        self._protocol.connection_made(self, ramses=True)
+
+        if autostart:
+            self.resume_reading()
 
     async def write_frame(self, frame: str, disable_tx_limits: bool = False) -> None:
         """Process a frame for transmission by passing it to the external writer.
@@ -1879,19 +1885,19 @@ class CallbackTransport(_FullTransport, _CallbackTransportAbstractor):
         :type dtm: str | None, optional
         """
         _LOGGER.debug(
-            f"Received frame from external source: frame='{frame}', timestamp={dtm}"
+            f"Received frame from external source: frame={repr(frame)}, timestamp={dtm}"
         )
 
-        # Section 4.2: Circuit Breaker implementation (Packet gating)
+        # Circuit Breaker implementation (Packet gating)
         if not self._reading:
             _LOGGER.debug(f"Dropping received frame (transport paused): {repr(frame)}")
             return
 
         dtm = dtm or dt_now().isoformat()
 
-        # Section 6.1: Boundary Logging (Incoming)
+        # Boundary Logging (Incoming)
         _LOGGER.debug(
-            f"Ingesting frame into transport: frame='{frame}', timestamp={dtm}"
+            f"Ingesting frame into transport: frame={repr(frame)}, timestamp={dtm}"
         )
 
         # Pass to the standard processing pipeline
@@ -1949,7 +1955,7 @@ async def transport_factory(
     extra: dict[str, Any] | None = None,
     loop: asyncio.AbstractEventLoop | None = None,
     log_all: bool = False,
-    **kwargs: Any,  # HACK: odd/misc params
+    **kwargs: Any,  # HACK: odd/misc params, inc. autostart
 ) -> RamsesTransportT:
     """Create and return a Ramses-specific async packet Transport.
 
@@ -1980,11 +1986,18 @@ async def transport_factory(
     :raises exc.TransportSourceInvalid: If the packet source is invalid or multiple sources are specified.
     """
 
+    # Extract autostart (default to False if missing), used in transport_constructor only
+    autostart = kwargs.pop("autostart", False)
+
     # If a constructor is provided, delegate entirely to it.
     if transport_constructor:
         _LOGGER.debug("transport_factory: Delegating to external transport_constructor")
         return await transport_constructor(
-            protocol, disable_sending=disable_sending, extra=extra, **kwargs
+            protocol,
+            disable_sending=disable_sending,
+            extra=extra,
+            autostart=autostart,  # <--- Pass it explicitly
+            **kwargs,
         )
 
     # kwargs are specific to a transport. The above transports have:

ramses_tx/version.py

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