ramses-rf 0.53.4__tar.gz → 0.53.6__tar.gz

{ramses_rf-0.53.4 → ramses_rf-0.53.6}/.github/workflows/check-lint.yml

@@ -1,5 +1,7 @@
 name: Linting
 
+permissions:  ## security hint
+  contents: read
 
 on:
   push:

{ramses_rf-0.53.4 → ramses_rf-0.53.6}/.github/workflows/check-test.yml

@@ -1,5 +1,7 @@
 name: Testing
 
+permissions:
+  contents: read
 
 on:
   push:

{ramses_rf-0.53.4 → ramses_rf-0.53.6}/.github/workflows/check-type.yml

@@ -1,5 +1,7 @@
 name: Typing
 
+permissions:
+  contents: read
 
 on:
   push:

{ramses_rf-0.53.4 → ramses_rf-0.53.6}/PKG-INFO

@@ -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 → ramses_rf-0.53.6}/README.md

@@ -41,11 +41,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 → ramses_rf-0.53.6}/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.4 → ramses_rf-0.53.6}/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.4 → ramses_rf-0.53.6}/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-0.53.4 → ramses_rf-0.53.6}/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.4 → ramses_rf-0.53.6}/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-0.53.4 → ramses_rf-0.53.6}/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-0.53.4 → ramses_rf-0.53.6}/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.4 → ramses_rf-0.53.6}/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.4 → ramses_rf-0.53.6}/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 → ramses_rf-0.53.6}/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.4 → ramses_rf-0.53.6}/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_rf-0.53.4 → ramses_rf-0.53.6}/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})"