ramses-rf 0.51.8__py3-none-any.whl → 0.51.9__py3-none-any.whl

ramses_rf/database.py

@@ -8,7 +8,7 @@ import logging
 import sqlite3
 from collections import OrderedDict
 from datetime import datetime as dt, timedelta as td
-from typing import NewType, TypedDict
+from typing import Any, NewType, TypedDict
 
 from ramses_tx import Message
 
@@ -24,6 +24,7 @@ class Params(TypedDict):
     code: str | None
     ctx: str | None
     hdr: str | None
+    plk: str | None
 
 
 _LOGGER = logging.getLogger(__name__)
@@ -33,50 +34,87 @@ def _setup_db_adapters() -> None:
     """Set up the database adapters and converters."""
 
     def adapt_datetime_iso(val: dt) -> str:
-        """Adapt datetime.datetime to timezone-naive ISO 8601 datetime."""
+        """Adapt datetime.datetime to timezone-naive ISO 8601 datetime to match _msgs_ dtm keys."""
         return val.isoformat(timespec="microseconds")
 
     sqlite3.register_adapter(dt, adapt_datetime_iso)
 
     def convert_datetime(val: bytes) -> dt:
-        """Convert ISO 8601 datetime to datetime.datetime object."""
+        """Convert ISO 8601 datetime to datetime.datetime object to import dtm in msg_db."""
         return dt.fromisoformat(val.decode())
 
-    sqlite3.register_converter("dtm", convert_datetime)
+    sqlite3.register_converter("DTM", convert_datetime)
+
+
+def payload_keys(parsed_payload: list[dict] | dict) -> str:  # type: ignore[type-arg]
+    """
+    Copy payload keys for fast query check.
+
+    :param parsed_payload: pre-parsed message payload dict
+    :return: string of payload keys, separated by the | char
+    """
+    _keys: str = "|"
+
+    def append_keys(ppl: dict) -> str:  # type: ignore[type-arg]
+        _ks: str = ""
+        for k, v in ppl.items():
+            if (
+                k not in _ks and k not in _keys and v is not None
+            ):  # ignore keys with None value
+                _ks += k + "|"
+        return _ks
+
+    if isinstance(parsed_payload, list):
+        for d in parsed_payload:
+            _keys += append_keys(d)
+    elif isinstance(parsed_payload, dict):
+        _keys += append_keys(parsed_payload)
+    return _keys
 
 
 class MessageIndex:
-    """A simple in-memory SQLite3 database for indexing messages."""
+    """A simple in-memory SQLite3 database for indexing RF messages.
+    Index holds the latest message to & from all devices by header
+    (example of a hdr: 000C|RP|01:223036|0208)."""
 
-    def __init__(self) -> None:
+    def __init__(self, maintain: bool = True) -> None:
         """Instantiate a message database/index."""
 
-        self._msgs: MsgDdT = OrderedDict()
+        self.maintain = maintain
+        self._msgs: MsgDdT = (
+            OrderedDict()
+        )  # stores all messages for retrieval. Filled in housekeeping loop.
 
-        self._cx = sqlite3.connect(":memory:")  # Connect to a SQLite DB in memory
+        # Connect to a SQLite DB in memory
+        self._cx = sqlite3.connect(
+            ":memory:", detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES
+        )
+        # detect_types should retain dt type on store/retrieve
         self._cu = self._cx.cursor()  # Create a cursor
 
-        _setup_db_adapters()  # dtm adapter/converter
+        _setup_db_adapters()  # DTM adapter/converter
         self._setup_db_schema()
 
-        self._lock = asyncio.Lock()
-        self._last_housekeeping: dt = None  # type: ignore[assignment]
-        self._housekeeping_task: asyncio.Task[None] = None  # type: ignore[assignment]
+        if self.maintain:
+            self._lock = asyncio.Lock()
+            self._last_housekeeping: dt = None  # type: ignore[assignment]
+            self._housekeeping_task: asyncio.Task[None] = None  # type: ignore[assignment]
 
         self.start()
 
     def __repr__(self) -> str:
-        return f"MessageIndex({len(self._msgs)} messages)"
+        return f"MessageIndex({len(self._msgs)} messages)"  # or msg_db.count()
 
     def start(self) -> None:
         """Start the housekeeper loop."""
 
-        if self._housekeeping_task and not self._housekeeping_task.done():
-            return
+        if self.maintain:
+            if self._housekeeping_task and not self._housekeeping_task.done():
+                return
 
-        self._housekeeping_task = asyncio.create_task(
-            self._housekeeping_loop(), name=f"{self.__class__.__name__}.housekeeper"
-        )
+            self._housekeeping_task = asyncio.create_task(
+                self._housekeeping_loop(), name=f"{self.__class__.__name__}.housekeeper"
+            )
 
     def stop(self) -> None:
         """Stop the housekeeper loop."""
@@ -95,27 +133,29 @@ class MessageIndex:
     def _setup_db_schema(self) -> None:
         """Set up the message database schema.
 
-        Fields:
+        messages TABLE Fields:
 
         - dtm  message timestamp
-        - verb _I, RQ etc.
+        - verb " I", "RQ" etc.
         - src  message origin address
         - dst  message destination address
         - code packet code aka command class e.g. _0005, _31DA
         - ctx  message context, created from payload as index + extra markers (Heat)
         - hdr  packet header e.g. 000C|RP|01:223036|0208 (see: src/ramses_tx/frame.py)
+        - plk the keys stored in the parsed payload, separated by the | char
         """
 
         self._cu.execute(
             """
             CREATE TABLE messages (
-                dtm    TEXT(26) NOT NULL PRIMARY KEY,
+                dtm    DTM      NOT NULL PRIMARY KEY,
                 verb   TEXT(2)  NOT NULL,
                 src    TEXT(9)  NOT NULL,
                 dst    TEXT(9)  NOT NULL,
                 code   TEXT(4)  NOT NULL,
-                ctx    TEXT     NOT NULL,
-                hdr    TEXT     NOT NULL UNIQUE
+                ctx    TEXT,
+                hdr    TEXT     NOT NULL UNIQUE,
+                plk    TEXT     NOT NULL
             )
             """
         )
@@ -130,10 +170,16 @@ class MessageIndex:
         self._cx.commit()
 
     async def _housekeeping_loop(self) -> None:
-        """Periodically remove stale messages from the index."""
+        """Periodically remove stale messages from the index,
+        unless self.maintain is False."""
 
         async def housekeeping(dt_now: dt, _cutoff: td = td(days=1)) -> None:
-            dtm = (dt_now - _cutoff).isoformat(timespec="microseconds")
+            """
+            Delete all messages from the using the MessageIndex older than a given delta.
+            :param dt_now: current timestamp
+            :param _cutoff: the oldest timestamp to retain, default is 24 hours ago
+            """
+            dtm = dt_now - _cutoff  # .isoformat(timespec="microseconds") < needed?
 
             self._cu.execute("SELECT dtm FROM messages WHERE dtm => ?", (dtm,))
             rows = self._cu.fetchall()
@@ -154,30 +200,34 @@ class MessageIndex:
         while True:
             self._last_housekeeping = dt.now()
             await asyncio.sleep(3600)
+            _LOGGER.info("Starting next MessageIndex housekeeping")
             await housekeeping(self._last_housekeeping)
 
     def add(self, msg: Message) -> Message | None:
-        """Add a single message to the index.
-
-        Returns any message that was removed because it had the same header.
-
-        Throws a warning if there is a duplicate dtm.
-        """  # TODO: eventually, may be better to use SqlAlchemy
+        """
+        Add a single message to the MessageIndex.
+        Logs a warning if there is a duplicate dtm.
+        :returns: any message that was removed because it had the same header
+        """
+        # TODO: eventually, may be better to use SqlAlchemy
 
         dup: tuple[Message, ...] = tuple()  # avoid UnboundLocalError
         old: Message | None = None  # avoid UnboundLocalError
 
-        try:  # TODO: remove, or use only when source is a packet log?
+        try:  # TODO: remove this, or apply only when source is a real packet log?
             # await self._lock.acquire()
             dup = self._delete_from(  # HACK: because of contrived pkt logs
-                dtm=msg.dtm.isoformat(timespec="microseconds")
+                dtm=msg.dtm  # stored as such with DTM formatter
             )
-            old = self._insert_into(msg)  # will delete old msg by hdr
+            old = self._insert_into(msg)  # will delete old msg by hdr (not dtm!)
 
-        except sqlite3.Error:  # UNIQUE constraint failed: ? messages.dtm (so: HACK)
+        except (
+            sqlite3.Error
+        ):  # UNIQUE constraint failed: ? messages.dtm or .hdr (so: HACK)
             self._cx.rollback()
 
         else:
+            # _msgs dict requires a timestamp reformat
             dtm: DtmStrT = msg.dtm.isoformat(timespec="microseconds")  # type: ignore[assignment]
             self._msgs[dtm] = msg
 
@@ -186,48 +236,106 @@ class MessageIndex:
 
         if dup:
             _LOGGER.warning(
-                "Overwrote dtm for %s: %s (contrived log?)", msg._pkt._hdr, dup[0]._pkt
+                "Overwrote dtm (%s) for %s: %s (contrived log?)",
+                msg.dtm,
+                msg._pkt._hdr,
+                dup[0]._pkt,
             )
+        if old is not None:
+            _LOGGER.info("Old msg replaced: %s", old)
 
         return old
 
+    def add_record(self, src: str, code: str = "", verb: str = "") -> None:
+        """
+        Add a single record to the MessageIndex with timestamp now() and no Message contents.
+        """
+        # Used by OtbGateway init, via entity_base.py
+        dtm: DtmStrT = DtmStrT(dt.strftime(dt.now(), "%Y-%m-%dT%H:%M:%S"))
+        hdr = f"{code}|{verb}|{src}|00"  # dummy record has no contents
+
+        dup = self._delete_from(hdr=hdr)
+
+        sql = """
+            INSERT INTO messages (dtm, verb, src, dst, code, ctx, hdr, plk)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        """
+        try:
+            self._cu.execute(
+                sql,
+                (
+                    dtm,
+                    verb,
+                    src,
+                    src,
+                    code,
+                    None,
+                    hdr,
+                    "|",
+                ),
+            )
+        except sqlite3.Error:
+            self._cx.rollback()
+
+        if dup:  # expected when more than one heat system in schema
+            _LOGGER.debug("Replaced record with same hdr: %s", hdr)
+
     def _insert_into(self, msg: Message) -> Message | None:
-        """Insert a message into the index (and return any message replaced by hdr)."""
+        """
+        Insert a message into the index.
+        :returns: any message replaced (by same hdr)
+        """
+        assert msg._pkt._hdr is not None, "Skipping: Packet has no hdr: {msg._pkt}"
+
+        if msg._pkt._ctx is True:
+            msg_pkt_ctx = "True"
+        elif msg._pkt._ctx is False:
+            msg_pkt_ctx = "False"
+        else:
+            msg_pkt_ctx = msg._pkt._ctx  # can be None
 
-        msgs = self._delete_from(hdr=msg._pkt._hdr)
+        _old_msgs = self._delete_from(hdr=msg._pkt._hdr)
 
         sql = """
-            INSERT INTO messages (dtm, verb, src, dst, code, ctx, hdr)
-            VALUES (?, ?, ?, ?, ?, ?, ?)
+            INSERT INTO messages (dtm, verb, src, dst, code, ctx, hdr, plk)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
         """
 
         self._cu.execute(
             sql,
             (
                 msg.dtm,
-                msg.verb,
+                str(msg.verb),
                 msg.src.id,
                 msg.dst.id,
-                msg.code,
-                msg._pkt._ctx,
+                str(msg.code),
+                msg_pkt_ctx,
                 msg._pkt._hdr,
+                payload_keys(msg.payload),
             ),
         )
+        _LOGGER.info(f"Added {msg} to gwy.msg_db")
 
-        return msgs[0] if msgs else None
+        return _old_msgs[0] if _old_msgs else None
 
     def rem(
-        self, msg: Message | None = None, **kwargs: str
+        self, msg: Message | None = None, **kwargs: str | dt
     ) -> tuple[Message, ...] | None:
         """Remove a set of message(s) from the index.
 
-        Returns any messages that were removed.
+        :returns: any messages that were removed.
         """
-
-        if bool(msg) ^ bool(kwargs):
+        # _LOGGER.debug(f"SQL REM msg={msg} bool{bool(msg)} kwargs={kwargs} bool(kwargs)")
+        # SQL REM
+        # msg=||  02:044328 | | I | heat_demand | FC || {'domain_id': 'FC', 'heat_demand': 0.74}
+        # boolTrue
+        # kwargs={}
+        # bool(kwargs)
+
+        if not bool(msg) ^ bool(kwargs):
             raise ValueError("Either a Message or kwargs should be provided, not both")
         if msg:
-            kwargs["dtm"] = msg.dtm.isoformat(timespec="microseconds")
+            kwargs["dtm"] = msg.dtm  # .isoformat(timespec="microseconds")
 
         msgs = None
         try:  # make this operation atomic, i.e. update self._msgs only on success
@@ -247,8 +355,9 @@ class MessageIndex:
 
         return msgs
 
-    def _delete_from(self, **kwargs: str) -> tuple[Message, ...]:
-        """Remove message(s) from the index (and return any messages removed)."""
+    def _delete_from(self, **kwargs: bool | dt | str) -> tuple[Message, ...]:
+        """Remove message(s) from the index.
+        :returns: any messages that were removed"""
 
         msgs = self._select_from(**kwargs)
 
@@ -259,48 +368,117 @@ class MessageIndex:
 
         return msgs
 
-    def get(self, msg: Message | None = None, **kwargs: str) -> tuple[Message, ...]:
-        """Return a set of message(s) from the index."""
+    def get(
+        self, msg: Message | None = None, **kwargs: bool | dt | str
+    ) -> tuple[Message, ...]:
+        """Get a set of message(s) from the index."""
 
         if not (bool(msg) ^ bool(kwargs)):
             raise ValueError("Either a Message or kwargs should be provided, not both")
+
         if msg:
-            kwargs["dtm"] = msg.dtm.isoformat(timespec="microseconds")
+            kwargs["dtm"] = msg.dtm  # .isoformat(timespec="microseconds")
 
         return self._select_from(**kwargs)
 
-    def _select_from(self, **kwargs: str) -> tuple[Message, ...]:
-        """Select message(s) from the index (and return any such messages)."""
+    def qry_dtms(self, **kwargs: bool | dt | str) -> list[Any]:
+        # tweak kwargs as stored in SQLite, inverse from _insert_into():
+        kw = {key: value for key, value in kwargs.items() if key != "ctx"}
+        if "ctx" in kwargs:
+            if isinstance(kwargs["ctx"], str):
+                kw["ctx"] = kwargs["ctx"]
+            elif kwargs["ctx"]:
+                kw["ctx"] = "True"
+            else:
+                kw["ctx"] = "False"
 
         sql = "SELECT dtm FROM messages WHERE "
-        sql += " AND ".join(f"{k} = ?" for k in kwargs)
+        sql += " AND ".join(f"{k} = ?" for k in kw)
 
-        self._cu.execute(sql, tuple(kwargs.values()))
+        self._cu.execute(sql, tuple(kw.values()))
+        return self._cu.fetchall()
+
+    def contains(self, **kwargs: bool | dt | str) -> bool:
+        """
+        Check if the MessageIndex contains at least 1 record that matches the provided fields.
+        :param kwargs: (exact) SQLite table field_name: required_value pairs
+        :return: True if at least one message fitting the given conditions is present, False when qry returned empty
+        """
+        # adapted from _select_from()
+
+        return len(self.qry_dtms(**kwargs)) > 0
 
-        return tuple(self._msgs[row[0]] for row in self._cu.fetchall())
+    def _select_from(self, **kwargs: bool | dt | str) -> tuple[Message, ...]:
+        """Select message(s) using the MessageIndex.
+        :param kwargs: (exact) SQLite table field_name: required_value pairs
+        :returns: a tuple of qualifying messages"""
+
+        return tuple(
+            self._msgs[row[0].isoformat(timespec="microseconds")]
+            for row in self.qry_dtms(**kwargs)
+        )
 
     def qry(self, sql: str, parameters: tuple[str, ...]) -> tuple[Message, ...]:
-        """Return a set of message(s) from the index, given sql and parameters."""
+        """Get a tuple of messages from the index, given sql and parameters."""
 
         if "SELECT" not in sql:
             raise ValueError(f"{self}: Only SELECT queries are allowed")
 
         self._cu.execute(sql, parameters)
 
-        return tuple(self._msgs[row[0]] for row in self._cu.fetchall())
+        lst: list[Message] = []
+        # stamp = list(self._msgs)[0] if len(self._msgs) > 0 else "N/A"  # for debug
+        for row in self._cu.fetchall():
+            ts: DtmStrT = row[0].isoformat(timespec="microseconds")
+            # _LOGGER.debug(
+            #     f"QRY Msg key raw: {row[0]} Reformatted: {ts} _msgs stamp format: {stamp}"
+            # )
+            # QRY Msg key raw: 2022-09-08 13:43:31.536862 Reformatted: 2022-09-08T13:43:31.536862
+            # _msgs stamp format: 2022-09-08T13:40:52.447364
+            if ts in self._msgs:
+                lst.append(self._msgs[ts])
+            else:  # happens in tests with artificial msg from heat
+                _LOGGER.warning("MessageIndex ts %s not in device messages", ts)
+        return tuple(lst)
+
+    def qry_field(
+        self, sql: str, parameters: tuple[str, ...]
+    ) -> list[tuple[dt | str, str]]:
+        """
+        Get a list of message field values from the index, given sql and parameters.
+        """
 
-    def all(self, include_expired: bool = False) -> tuple[Message, ...]:
-        """Return all messages from the index."""
+        if "SELECT" not in sql:
+            raise ValueError(f"{self}: Only SELECT queries are allowed")
 
-        # self._cu.execute("SELECT * FROM messages")
-        # return tuple(self._msgs[row[0]] for row in self._cu.fetchall())
+        self._cu.execute(sql, parameters)
 
-        return tuple(
-            m for m in self._msgs.values() if include_expired or not m._expired
-        )
+        return self._cu.fetchall()
+
+    def all(self, include_expired: bool = False) -> tuple[Message, ...]:
+        """Get all messages from the index."""
+
+        self._cu.execute("SELECT * FROM messages")
+
+        lst: list[Message] = []
+        # stamp = list(self._msgs)[0] if len(self._msgs) > 0 else "N/A"
+        for row in self._cu.fetchall():
+            ts: DtmStrT = row[0].isoformat(timespec="microseconds")
+            # _LOGGER.debug(
+            #     f"ALL Msg key raw: {row[0]} Reformatted: {ts} _msgs stamp format: {stamp}"
+            # )
+            # ALL Msg key raw: 2022-05-02 10:02:02.744905
+            # Reformatted: 2022-05-02T10:02:02.744905
+            # _msgs stamp format: 2022-05-02T10:02:02.744905
+            if ts in self._msgs:
+                # if include_expired or not self._msgs[ts].HAS_EXPIRED:  # not working
+                lst.append(self._msgs[ts])
+            else:  # happens in tests with dummy msg from heat init
+                _LOGGER.warning("MessageIndex ts %s not in device messages", ts)
+        return tuple(lst)
 
     def clr(self) -> None:
-        """Clear the message index (remove all messages)."""
+        """Clear the message index (remove indexes of all messages)."""
 
         self._cu.execute("DELETE FROM messages")
         self._cx.commit()

ramses_rf/device/hvac.py

@@ -446,6 +446,7 @@ class HvacVentilator(FilterChange):  # FAN: RP/31DA, I/31D[9A], 2411
         """
         super().__init__(*args, **kwargs)
         self._supports_2411 = False  # Flag for 2411 parameter support
+        self._params_2411: dict[str, float] = {}  # Store 2411 parameters here
         self._initialized_callback = None  # Called when device is fully initialized
         self._param_update_callback = None  # Called when 2411 parameters are updated
         self._hgi: Any | None = None  # Will be set when HGI is available
@@ -517,7 +518,7 @@ class HvacVentilator(FilterChange):  # FAN: RP/31DA, I/31D[9A], 2411
         :param param_id: The ID of the parameter that was updated
         :type param_id: str
         :param value: The new value of the parameter
-        :type value: Any
+        :type value: float
         """
         if callable(self._param_update_callback):
             try:
@@ -541,12 +542,62 @@ class HvacVentilator(FilterChange):  # FAN: RP/31DA, I/31D[9A], 2411
         The HGI device provides additional functionality for certain operations.
 
         :return: The HGI device instance, or None if not available
-        :rtype: Any | None
+        :rtype: float | None
         """
         if self._hgi is None and self._gwy and hasattr(self._gwy, "hgi"):
             self._hgi = self._gwy.hgi
         return self._hgi
 
+    def get_2411_param(self, param_id: str) -> float | None:
+        """Get a 2411 parameter value.
+
+        :param param_id: The parameter ID to retrieve.
+        :type param_id: str
+        :return: The parameter value if found, None otherwise
+        :rtype: float | None
+        """
+        return self._params_2411.get(param_id)
+
+    def set_2411_param(self, param_id: str, value: float) -> bool:
+        """Set a 2411 parameter value.
+
+        :param param_id: The parameter ID to retrieve.
+        :type param_id: str
+        :param value: The parameter value to set.
+        :type value: float
+        :return: True if the parameter was set, False otherwise
+        :rtype: bool
+        """
+        if not self._supports_2411:
+            _LOGGER.warning("Device %s doesn't support 2411 parameters", self.id)
+            return False
+
+        self._params_2411[param_id] = value
+        return True
+
+    def get_fan_param(self, param_id: str) -> Any | None:
+        """Retrieve a fan parameter value from the device's message store.
+
+        This wrapper method gets a specific parameter value for a FAN device stored in
+        _params_2411 dict. It first makes sure we use the proper param_id format
+
+        :param param_id: The parameter ID to retrieve.
+        :type param_id: str
+        :return: The parameter value if found, None otherwise
+        :rtype: float | None
+        """
+        # Ensure param_id is uppercase and strip leading zeros for consistency
+        param_id = (
+            str(param_id).upper().lstrip("0") or "0"
+        )  # Handle case where param_id is "0"
+
+        param_value = self.get_2411_param(param_id)
+        if param_value is not None:
+            return param_value
+        else:
+            _LOGGER.debug("Parameter %s not found for %s", param_id, self.id)
+            return None
+
     def _handle_2411_message(self, msg: Message) -> None:
         """Handle incoming 2411 parameter messages.
 
@@ -568,33 +619,30 @@ class HvacVentilator(FilterChange):  # FAN: RP/31DA, I/31D[9A], 2411
             _LOGGER.debug("Missing parameter ID or value in 2411 message: %s", msg)
             return
 
-        # Create a composite key for this parameter using the normalized ID
-        key = f"{Code._2411}_{param_id}"
+        # Mark that we support 2411 parameters
+        if not self._supports_2411:
+            self._supports_2411 = True
+            _LOGGER.debug("Device %s supports 2411 parameters", self.id)
 
-        # Store the message in the device's message store
-        old_value = self._msgs.get(Code._2411)
-        # Use direct assignment for Code._2411 key
-        self._msgs[Code._2411] = msg
-        # For the composite key, we need to bypass type checking
-        self._msgs[key] = msg  # type: ignore[index]
+        # Normalize the value if needed
+        if param_id == "75" and isinstance(param_value, (int, float)):
+            param_value = round(float(param_value), 1)
+        elif param_id in ("52", "95"):  # Percentage parameters
+            param_value = round(float(param_value), 3)  # Keep precision for percentages
+
+        # Store in params
+        old_value = self.get_2411_param(param_id)
+        self.set_2411_param(param_id, param_value)
 
+        # Log the update
         _LOGGER.debug(
-            "Updated 2411 parameter %s = %s (was: %s) for %s",
+            "Updated 2411 parameter %s: %s (was: %s) for %s",
             param_id,
             param_value,
-            old_value.payload if old_value else None,
+            old_value,
             self.id,
         )
 
-        # Mark that we support 2411 parameters
-        if not self._supports_2411:
-            self._supports_2411 = True
-            _LOGGER.debug("Device %s supports 2411 parameters", self.id)
-
-        # Round parameter 75 values to 1 decimal place
-        if param_id == "75" and isinstance(param_value, int | float):
-            param_value = round(float(param_value), 1)
-
         # call the 2411 parameter update callback
         self._handle_param_update(param_id, param_value)
 
@@ -749,72 +797,6 @@ class HvacVentilator(FilterChange):  # FAN: RP/31DA, I/31D[9A], 2411
         _LOGGER.debug("No bound REM or DIS devices found for FAN %s", self.id)
         return None
 
-    def get_fan_param(self, param_id: str) -> Any | None:
-        """Retrieve a fan parameter value from the device's message store.
-
-        This method attempts to fetch a specific parameter value for a FAN device from the
-        stored messages. It first looks for the parameter using a composite key (e.g., '2411_3F')
-        and falls back to checking the general 2411 message if needed.
-
-        :param param_id: The parameter ID to retrieve.
-        :type param_id: str
-        :return: The parameter value if found, None otherwise
-        :rtype: Any | None
-        """
-        # Ensure param_id is uppercase and strip leading zeros for consistency
-        param_id = (
-            str(param_id).upper().lstrip("0") or "0"
-        )  # Handle case where param_id is "0"
-        # we need some extra workarounds to please mypy
-        # Create a composite key for this parameter using the normalized ID
-        key = f"{Code._2411}_{param_id}"
-
-        # Get the message using the composite key first, fall back to just the code
-        msg = None
-
-        # First try to get the specific parameter message
-        try:
-            # Try to access the message directly using the key
-            msg = self._msgs[key]  # type: ignore[index]
-        except (KeyError, TypeError):
-            # If that fails, try to find the message by iterating through the dictionary
-            msg = next((v for k, v in self._msgs.items() if str(k) == key), None)
-
-        # If not found, try to get the general 2411 message
-        if msg is None:
-            msg = self._msgs.get(Code._2411)
-
-        if not msg or not hasattr(msg, "payload"):
-            if not self.supports_2411:
-                _LOGGER.debug(
-                    "Cannot get parameter %s from %s: 2411 parameters not supported",
-                    param_id,
-                    self.id,
-                )
-            else:
-                _LOGGER.debug(
-                    "No payload found for parameter %s on %s", param_id, self.id
-                )
-            return None
-
-        # If we have a message but not the specific parameter, try to get it from the payload
-        if param_id and hasattr(msg.payload, "get"):
-            value = msg.payload.get("value")
-            if value is not None:
-                return value
-
-        # If we get here, the parameter wasn't found in the message
-        if not self.supports_2411:
-            _LOGGER.debug(
-                "Parameter %s not found for %s: 2411 parameters not supported",
-                param_id,
-                self.id,
-            )
-        else:
-            _LOGGER.debug("Parameter %s not found in payload for %s", param_id, self.id)
-
-        return None
-
     @property
     def air_quality(self) -> float | None:
         """Return the current air quality measurement.

ramses_rf/dispatcher.py

@@ -70,12 +70,12 @@ def _create_devices_from_addrs(gwy: Gateway, this: Message) -> None:
     # Devices need to know their controller, ?and their location ('parent' domain)
     # NB: only addrs processed here, packet metadata is processed elsewhere
 
-    # Determinging bindings to a controller:
+    # Determining bindings to a controller:
     #  - configury; As per any schema                                                   # codespell:ignore configury
     #  - discovery: If in 000C pkt, or pkt *to* device where src is a controller
     #  - eavesdrop: If pkt *from* device where dst is a controller
 
-    # Determinging location in a schema (domain/DHW/zone):
+    # Determining location in a schema (domain/DHW/zone):
     #  - configury; As per any schema                                                   # codespell:ignore configury
     #  - discovery: If in 000C pkt - unable for 10: & 00: (TRVs)
     #  - discovery: from packet fingerprint, excl. payloads (only for 10:)
@@ -99,7 +99,7 @@ def _create_devices_from_addrs(gwy: Gateway, this: Message) -> None:
 def _check_msg_addrs(msg: Message) -> None:  # TODO
     """Validate the packet's address set.
 
-    Raise InvalidAddrSetError if the meta data is invalid, otherwise simply return.
+    Raise InvalidAddrSetError if the metadata is invalid, otherwise simply return.
     """
 
     # TODO: needs work: doesn't take into account device's (non-HVAC) class
@@ -218,7 +218,7 @@ def process_msg(gwy: Gateway, msg: Message) -> None:
             and msg.dst != msg.src
         ):
             # HGI80 can do what it likes
-            # receiving an I isn't currently in the schema & so can't yet be tested
+            # receiving an I_ isn't currently in the schema & so can't yet be tested
             _check_dst_slug(msg)  # ? raise exc.PacketInvalid
 
         if gwy.config.reduce_processing >= DONT_UPDATE_ENTITIES:
@@ -269,7 +269,9 @@ def process_msg(gwy: Gateway, msg: Message) -> None:
     else:
         logger_xxxx(msg)
         if gwy.msg_db:
-            gwy.msg_db.add(msg)
+            gwy.msg_db.add(
+                msg
+            )  # why add it anyway? will fail in testst comparing to _msgs
 
 
 # TODO: this needs cleaning up (e.g. handle intervening packet)

ramses_rf/version.py

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

{ramses_rf-0.51.8.dist-info → ramses_rf-0.51.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ramses_rf
-Version: 0.51.8
+Version: 0.51.9
 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.51.8.dist-info → ramses_rf-0.51.9.dist-info}/RECORD

@@ -7,49 +7,49 @@ ramses_cli/utils/convert.py,sha256=D_YiCyX5na9pgC-_NhBlW9N1dgRKUK-uLtLBfofjzZM,1
 ramses_rf/__init__.py,sha256=VG3E9GHbtC6lx6E1DMQJeFitHnydMKJyPxQBethdrzg,1193
 ramses_rf/binding_fsm.py,sha256=uZAOl3i19KCXqqlaLJWkEqMMP7NJBhVPW3xTikQD1fY,25996
 ramses_rf/const.py,sha256=L3z31CZ-xqno6oZp_h-67CB_5tDDqTwSWXsqRtsjMcs,5460
-ramses_rf/database.py,sha256=ZZZgucyuU1IHsSewGukZfDg2gu8KeNaEFriWKM0TUHs,10287
-ramses_rf/dispatcher.py,sha256=JGkqSi1o-YhQ2rj8tNkXwYLLeJIC7F061xpHoH8sSsM,11201
+ramses_rf/database.py,sha256=eaD34qyYmjg1AZ5mU78CcjwSbEbjLSVzRXlSoZLtmbI,17264
+ramses_rf/dispatcher.py,sha256=7DNJ5nLpMnaJTCXhm_BLEAnMnYWlvh1XPdkMP_ucBGg,11290
 ramses_rf/entity_base.py,sha256=Byt8mFRUKETNiKHaL0cNaMywjLcopDG3Sldiy1Q7lAo,39213
 ramses_rf/exceptions.py,sha256=mt_T7irqHSDKir6KLaf6oDglUIdrw0S40JbOrWJk5jc,3657
 ramses_rf/gateway.py,sha256=s2bhkUzR42mzL4lZ1crTBsEWMOMGI8tpuHN1UZdAB74,20564
 ramses_rf/helpers.py,sha256=TNk_QkpIOB3alOp1sqnA9LOzi4fuDCeapNlW3zTzNas,4250
 ramses_rf/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ramses_rf/schemas.py,sha256=UhvRhV4nZ3kvrLLM3wwIguQUIjIgd_AKvp2wkTSpNEA,13468
-ramses_rf/version.py,sha256=PUTZH-D81qyH8onRDdeZzxGwuCVDzMYTbItYAp9NKKI,125
+ramses_rf/version.py,sha256=NXm_d5LEm9kUTuOqMEH3o0RLs7W6Ahdv2527DIwmnJc,125
 ramses_rf/device/__init__.py,sha256=sUbH5dhbYFXSoM_TPFRutpRutBRpup7_cQ9smPtDTy8,4858
 ramses_rf/device/base.py,sha256=WGkBTUNjRUEe-phxdtdiXVCZnTi6-i1i_YT6g689UTM,17450
 ramses_rf/device/heat.py,sha256=2sCsggySVcuTzyXDmgWy76QbhlU5MQWSejy3zgI5BDE,54242
-ramses_rf/device/hvac.py,sha256=uKljqweushvpHwRTiYfR26YST6--KAIp8X9zyiRv9HI,45607
+ramses_rf/device/hvac.py,sha256=SY2FpO54k4y5E7MYWyjMMRbBDqRLWgB8Cvk9lAOFkyY,44653
 ramses_rf/system/__init__.py,sha256=uZLKio3gLlBzePa2aDQ1nxkcp1YXOGrn6iHTG8LiNIw,711
 ramses_rf/system/faultlog.py,sha256=GdGmVGT3137KsTlV_nhccgIFEmYu6DFsLTn4S-8JSok,12799
 ramses_rf/system/heat.py,sha256=3jaFEChU-HlWCRMY1y7u09s7AH4hT0pC63hnqwdmZOc,39223
 ramses_rf/system/schedule.py,sha256=Ts6tdZPTQLV5NkgwA73tPa5QUsnZNIIuYoKC-8VsXDk,18808
 ramses_rf/system/zones.py,sha256=9AH7ooN5QfiqvWuor2P1Dn8aILjQb2RWL9rWqDH1IjA,36075
 ramses_tx/__init__.py,sha256=qNMTe8hBkIuecvtCiekUB0pKdD8atb0SjWxVNVe3yhE,3538
-ramses_tx/address.py,sha256=5swDr_SvOs1CxBmT-iJpldf8R00mOb7gKPMiEnxLz84,8452
+ramses_tx/address.py,sha256=F5ZE-EbPNNom1fW9XXUILvD7DYSMBxNJvsHVliT5gjw,8452
 ramses_tx/command.py,sha256=r9dNaofjjOQXZSUrZjsNpvEukNn4rSGy0OLr2Dyd2TI,125129
-ramses_tx/const.py,sha256=QmwSS4BIN3ZFrLUiiFScP1RCUHuJ782V3ycRPQTtB_c,30297
+ramses_tx/const.py,sha256=pnxq5upXvLUizv9Ye_I1llD9rAa3wddHgsSkc91AIUc,30300
 ramses_tx/exceptions.py,sha256=FJSU9YkvpKjs3yeTqUJX1o3TPFSe_B01gRGIh9b3PNc,2632
 ramses_tx/fingerprints.py,sha256=nfftA1E62HQnb-eLt2EqjEi_la0DAoT0wt-PtTMie0s,11974
-ramses_tx/frame.py,sha256=9lUVh8gAMXNRAolfFw2WuWANjn24AWkmscuM9Tm5imE,22036
-ramses_tx/gateway.py,sha256=TXLYwT6tFpmSokD29Qyj1ze7UGCxKidooeyP557Jfoo,11266
+ramses_tx/frame.py,sha256=GzNsXr15YLeidJYGtk_xPqsZQh4ehDDlUCtT6rTDhT8,22046
+ramses_tx/gateway.py,sha256=Z2TLysmTsi6wc2LEvbF-mL141aesdcWEFRCm0zheR0I,11267
 ramses_tx/helpers.py,sha256=J4OCRckp3JshGQTvvqEskFjB1hPS7uA_opVsuIqmZds,32915
 ramses_tx/logger.py,sha256=qYbUoNPnPaFWKVsYvLG6uTVuPTdZ8HsMzBbGx0DpBqc,10177
-ramses_tx/message.py,sha256=hl_gLfwrF79ftUNnsgNt3XGsIhM2Pts0MtZZuGjfaxk,13169
+ramses_tx/message.py,sha256=LnzLVMmdV1oNHbdoldCAFW3lESgOqzPWWDsHed5K7iI,13391
 ramses_tx/opentherm.py,sha256=58PXz9l5x8Ou6Fm3y-R_UnGHCYahoi2RKIDdYStUMzk,42378
-ramses_tx/packet.py,sha256=NGunaGCkEjhTp9t4mARK5e7kbqT-Z_JKCH7ibMYMJXU,7357
-ramses_tx/parsers.py,sha256=c6D3NB79vZfOGpVmrHc-EhSh4_N4tKljBp1J3HFfkXw,109950
+ramses_tx/packet.py,sha256=_qHiPFWpQpKueZOgf1jJ93Y09iZjo3LZWStLglVkXg4,7370
+ramses_tx/parsers.py,sha256=g0vKu1vDXjjp_kV_iipeGL5M8XYi67AE3c97IZX00Qk,110888
 ramses_tx/protocol.py,sha256=9R3aCzuiWEyXmugmB5tyR_RhBlgfnpUXj7AsMP9BzzU,28867
 ramses_tx/protocol_fsm.py,sha256=ZKtehCr_4TaDdfdlfidFLJaOVTYtaEq5h4tLqNIhb9s,26827
 ramses_tx/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ramses_tx/ramses.py,sha256=DujcZe4WelHvPNKYfoz9YWmXNoCayV5UsAkiu8Y6vms,53432
 ramses_tx/schemas.py,sha256=18IPRdoCWXpcRg4v8Z1ehTnRronQPYGrf4AvRL-1OD0,12932
-ramses_tx/transport.py,sha256=MwPnkQ0L-2qJt4mIJy3-C9XmHwBDjT7Kg-1LthPByVw,58331
+ramses_tx/transport.py,sha256=bGprlfuuwBgQ1bmBRSrcicuk7s-jVqyuKpZCfQ-sSpw,58469
 ramses_tx/typed_dicts.py,sha256=w-0V5t2Q3GiNUOrRAWiW9GtSwbta_7luME6GfIb1zhI,10869
 ramses_tx/typing.py,sha256=eF2SlPWhNhEFQj6WX2AhTXiyRQVXYnFutiepllYl2rI,5042
-ramses_tx/version.py,sha256=kLXw7G-2GHtLEZnlOm_5jj8TGeibQYmH_NZ9F7FVHAU,123
-ramses_rf-0.51.8.dist-info/METADATA,sha256=JmxHDvvXI3gRkt2zHELxS9G3ZaMyOn8bOvaraq5_0Ro,4000
-ramses_rf-0.51.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ramses_rf-0.51.8.dist-info/entry_points.txt,sha256=NnyK29baOCNg8DinPYiZ368h7MTH7bgTW26z2A1NeIE,50
-ramses_rf-0.51.8.dist-info/licenses/LICENSE,sha256=-Kc35W7l1UkdiQ4314_yVWv7vDDrg7IrJfMLUiq6Nfs,1074
-ramses_rf-0.51.8.dist-info/RECORD,,
+ramses_tx/version.py,sha256=F7K6xGXIUnJDASKlhAoABr7EZ8WnHdqeUfJqZuvdczY,123
+ramses_rf-0.51.9.dist-info/METADATA,sha256=ITVv4OBf_zE3S2iCQ9Eqci8EuceqtCIfr9oyK5lE_Sw,4000
+ramses_rf-0.51.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ramses_rf-0.51.9.dist-info/entry_points.txt,sha256=NnyK29baOCNg8DinPYiZ368h7MTH7bgTW26z2A1NeIE,50
+ramses_rf-0.51.9.dist-info/licenses/LICENSE,sha256=-Kc35W7l1UkdiQ4314_yVWv7vDDrg7IrJfMLUiq6Nfs,1074
+ramses_rf-0.51.9.dist-info/RECORD,,

ramses_tx/address.py

@@ -195,7 +195,7 @@ def pkt_addrs(addr_fragment: str) -> tuple[Address, Address, Address, Address, A
 
     returns: src_addr, dst_addr, addr_0, addr_1, addr_2
 
-    Will raise an InvalidAddrSetError is the address fields are not valid.
+    Will raise an InvalidAddrSetError if the address fields are not valid.
     """
     # for debug: print(pkt_addrs.cache_info())
 

ramses_tx/const.py

@@ -788,7 +788,7 @@ class MsgId(StrEnum):
     _7F = "7F"
 
 
-# StrEnum is intended include all known codes, see: test suite, code schema in ramses.py
+# StrEnum is intended to include all known codes, see: test suite, code schema in ramses.py
 @verify(EnumCheck.UNIQUE)
 class Code(StrEnum):
     _0001 = "0001"

ramses_tx/frame.py

@@ -65,7 +65,7 @@ class Frame:
     def __init__(self, frame: str) -> None:
         """Create a frame from a string.
 
-        Will raise InvalidPacketError if it is invalid.
+        :raises InvalidPacketError: if provided string is invalid.
         """
 
         self._frame: str = frame
@@ -123,7 +123,7 @@ class Frame:
         if not strict_checking:
             return
 
-        try:  # Strict checking: helps users avoid to constructing bad commands
+        try:  # Strict checking: helps users avoid constructing bad commands
             if addrs[0] == NON_DEV_ADDR:
                 assert self.verb == I_, "wrong verb or dst addr should be present"
             elif addrs[2] == NON_DEV_ADDR:
@@ -138,7 +138,7 @@ class Frame:
             raise exc.PacketInvalid(f"Bad frame: Invalid address set: {err}") from err
 
     def __repr__(self) -> str:
-        """Return a unambiguous string representation of this object."""
+        """Return an unambiguous string representation of this object."""
 
         if self._repr is None:
             self._repr = " ".join(  # type: ignore[unreachable]
@@ -387,7 +387,7 @@ class Frame:
 
     @property
     def _hdr(self) -> HeaderT:  # incl. self._ctx
-        """Return the QoS header (fingerprint) of this packet (i.e. device_id/code/hdr).
+        """Return the QoS header (fingerprint) of this packet (i.e. device_id|code|verb).
 
         Used for QoS (timeouts, retries), callbacks, etc.
         """

ramses_tx/gateway.py

@@ -91,7 +91,7 @@ class Engine:
         if input_file:
             self._disable_sending = True
         elif not port_name:
-            raise TypeError("Either a port_name or a input_file must be specified")
+            raise TypeError("Either a port_name or an input_file must be specified")
 
         self.ser_name = port_name
         self._input_file = input_file

ramses_tx/message.py

@@ -54,7 +54,7 @@ class MessageBase:
     def __init__(self, pkt: Packet) -> None:
         """Create a message from a valid packet.
 
-        Will raise InvalidPacketError if it is invalid.
+        :raises InvalidPacketError if message payload is invalid.
         """
 
         self._pkt = pkt
@@ -66,11 +66,15 @@ class MessageBase:
         self.dtm: dt = pkt.dtm
 
         self.verb: VerbT = pkt.verb
-        self.seqn: str = pkt.seqn
+        self.seqn: str = (
+            pkt.seqn
+        )  # the msg is part of a set for 1 Code, received in order
         self.code: Code = pkt.code
         self.len: int = pkt._len
 
-        self._payload = self._validate(self._pkt.payload)  # ? raise InvalidPacketError
+        self._payload = self._validate(
+            self._pkt.payload
+        )  # ? may raise InvalidPacketError
 
         self._str: str = None  # type: ignore[assignment]
 
@@ -92,7 +96,7 @@ class MessageBase:
 
         if self.src.id == self._addrs[0].id:  # type: ignore[unreachable]
             name_0 = self._name(self.src)
-            name_1 = "" if self.dst is self.src else self._name(self.dst)
+            name_1 = "" if self.dst == self.src else self._name(self.dst)
         else:
             name_0 = ""
             name_1 = self._name(self.src)
@@ -139,16 +143,18 @@ class MessageBase:
 
     @property
     def _has_array(self) -> bool:
-        """Return True if the message's raw payload is an array."""
+        """
+        :return: True if the message's raw payload is an array.
+        """
 
         return bool(self._pkt._has_array)
 
     @property
     def _idx(self) -> dict[str, str]:
-        """Return the domain_id/zone_idx/other_idx of a message payload, if any.
+        """Get the domain_id/zone_idx/other_idx of a message payload, if any.
+        Used to identify the zone/domain that a message applies to.
 
-        Used to identify the zone/domain that a message applies to. Returns an empty
-        dict if there is none such, or None if undetermined.
+        :return: an empty dict if there is none such, or None if undetermined.
         """
 
         # .I --- 01:145038 --:------ 01:145038 3B00 002 FCC8
@@ -229,7 +235,7 @@ class MessageBase:
             assert isinstance(self._pkt._idx, str)  # mypy hint
             return {IDX_NAMES[Code._22C9]: self._pkt._idx}
 
-        assert isinstance(self._pkt._idx, str)  # mypy check
+        assert isinstance(self._pkt._idx, str)  # mypy hint
         idx_name = SZ_DOMAIN_ID if self._pkt._idx[:1] == "F" else SZ_ZONE_IDX
         index_name = IDX_NAMES.get(self.code, idx_name)
 
@@ -237,9 +243,10 @@ class MessageBase:
 
     # TODO: needs work...
     def _validate(self, raw_payload: str) -> dict | list[dict]:  # type: ignore[type-arg]
-        """Validate the message, and parse the payload if so.
+        """Validate a message packet payload, and parse it if valid.
 
-        Raise an exception (InvalidPacketError) if it is not valid.
+        :return: a dict containing key: value pairs, or a list of those created from the payload
+        :raises an InvalidPacketError exception if it is not valid.
         """
 
         try:  # parse the payload
@@ -249,10 +256,9 @@ class MessageBase:
             if not self._has_payload and (
                 self.verb == RQ and self.code not in RQ_IDX_COMPLEX
             ):
-                # _LOGGER.error("%s", msg)
                 return {}
 
-            result = parse_payload(self)
+            result = parse_payload(self)  # invoke the code parsers
 
             if isinstance(result, list):
                 return result
@@ -353,7 +359,7 @@ def re_compile_re_match(regex: str, string: str) -> bool:  # Optional[Match[Any]
 def _check_msg_payload(msg: MessageBase, payload: str) -> None:
     """Validate the packet's payload against its verb/code pair.
 
-    Raise an InvalidPayloadError if the payload is seen as invalid. Such payloads may
+    :raises InvalidPayloadError if the payload is seen as invalid. Such payloads may
     actually be valid, in which case the rules (likely the regex) will need updating.
     """
 

ramses_tx/packet.py

@@ -104,7 +104,7 @@ class Packet(Frame):
         return f"{dtm} ... {self}{hdr}"
 
     def __str__(self) -> str:
-        """Return a brief readable string representation of this object."""
+        """Return a brief readable string representation of this object aka 'header'."""
         # e.g.: 000A|RQ|01:145038|08
         return super().__repr__()  # TODO: self._hdr
 

ramses_tx/parsers.py

@@ -1912,42 +1912,57 @@ def parser_2411(payload: str, msg: Message) -> dict[str, Any]:
         "92": (4, hex_to_temp),  # 75 (0-30) (C)
     }  # TODO: _2411_TYPES.get(payload[8:10], (8, no_op))
 
-    assert payload[4:6] in _2411_TABLE, (
-        f"param {payload[4:6]} is unknown"
-    )  # _INFORM_DEV_MSG
-    description = _2411_TABLE.get(payload[4:6], "Unknown")
+    # Handle unknown parameters gracefully instead of asserting
+    param_id = payload[4:6]
+    try:
+        description = _2411_TABLE.get(param_id, "Unknown")
+        if param_id not in _2411_TABLE:
+            _LOGGER.warning(
+                f"2411 message received with unknown parameter ID: {param_id}. "
+                f"This parameter is not in the known parameter schema. "
+                f"Message: {msg!r}"
+            )
+    except Exception as err:
+        _LOGGER.warning(f"Error looking up 2411 parameter {param_id}: {err}")
+        description = "Unknown"
 
     result = {
-        "parameter": payload[4:6],
+        "parameter": param_id,
         "description": description,
     }
 
     if msg.verb == RQ:
         return result
 
-    assert payload[8:10] in _2411_DATA_TYPES, (
-        f"param {payload[4:6]} has unknown data_type: {payload[8:10]}"
-    )  # _INFORM_DEV_MSG
-    length, parser = _2411_DATA_TYPES.get(payload[8:10], (8, lambda x: x))
+    try:
+        assert payload[8:10] in _2411_DATA_TYPES, (
+            f"param {param_id} has unknown data_type: {payload[8:10]}"
+        )  # _INFORM_DEV_MSG
+        length, parser = _2411_DATA_TYPES.get(payload[8:10], (8, lambda x: x))
+
+        result |= {
+            "value": parser(payload[10:18][-length:]),  # type: ignore[operator]
+            "_value_06": payload[6:10],
+        }
 
-    result |= {
-        "value": parser(payload[10:18][-length:]),  # type: ignore[operator]
-        "_value_06": payload[6:10],
-    }
+        if msg.len == 9:
+            return result
 
-    if msg.len == 9:
+        return (
+            result
+            | {
+                "min_value": parser(payload[18:26][-length:]),  # type: ignore[operator]
+                "max_value": parser(payload[26:34][-length:]),  # type: ignore[operator]
+                "precision": parser(payload[34:42][-length:]),  # type: ignore[operator]
+                "_value_42": payload[42:],
+            }
+        )
+    except AssertionError as err:
+        _LOGGER.warning(f"{msg!r} < {_INFORM_DEV_MSG} ({err})")
+        # Return partial result for unknown parameters
+        result["value"] = ""
         return result
 
-    return (
-        result
-        | {
-            "min_value": parser(payload[18:26][-length:]),  # type: ignore[operator]
-            "max_value": parser(payload[26:34][-length:]),  # type: ignore[operator]
-            "precision": parser(payload[34:42][-length:]),  # type: ignore[operator]
-            "_value_42": payload[42:],
-        }
-    )
-
 
 # unknown_2420, from OTB
 def parser_2420(payload: str, msg: Message) -> dict[str, Any]:
@@ -2347,7 +2362,7 @@ def parser_3210(payload: str, msg: Message) -> PayDictT._3210:
     return {SZ_TEMPERATURE: hex_to_temp(payload[2:])}
 
 
-# opentherm_msg, from OTB (and some RND)
+# opentherm_msg, from OTB (and OT_RND)
 def parser_3220(payload: str, msg: Message) -> dict[str, Any]:
     try:
         ot_type, ot_id, ot_value, ot_schema = decode_frame(payload[2:10])
@@ -2971,8 +2986,12 @@ _PAYLOAD_PARSERS = {
 
 
 def parse_payload(msg: Message) -> dict | list[dict]:
+    """
+    Apply the appropriate parser defined in this module to the message.
+    :param msg: a Message object containing packet data and extra attributes
+    :return: a dict of key: value pairs or a list of such dicts, e.g. {'temperature': 21.5}
+    """
     result: dict | list[dict]
-
     result = _PAYLOAD_PARSERS.get(msg.code, parser_unknown)(msg._pkt.payload, msg)
     if isinstance(result, dict) and msg.seqn.isnumeric():  # e.g. 22F1/3
         result["seqx_num"] = msg.seqn

ramses_tx/transport.py

@@ -44,7 +44,7 @@ import sys
 from collections import deque
 from collections.abc import Awaitable, Callable, Iterable
 from datetime import datetime as dt, timedelta as td
-from functools import wraps
+from functools import partial, wraps
 from io import TextIOWrapper
 from string import printable
 from time import perf_counter
@@ -142,8 +142,7 @@ else:  # is linux
 
     def list_links(devices: set[str]) -> list[str]:
         """Search for symlinks to ports already listed in devices."""
-
-        links = []
+        links: list[str] = []
         for device in glob.glob("/dev/*") + glob.glob("/dev/serial/by-id/*"):
             if os.path.islink(device) and os.path.realpath(device) in devices:
                 links.append(device)
@@ -174,7 +173,7 @@ else:  # is linux
         return result
 
 
-def is_hgi80(serial_port: SerPortNameT) -> bool | None:
+async def is_hgi80(serial_port: SerPortNameT) -> bool | None:
     """Return True/False if the device attached to the port has the attrs of an HGI80.
 
     Return None if it's not possible to tell (falsy should assume is evofw3).
@@ -209,7 +208,10 @@ def is_hgi80(serial_port: SerPortNameT) -> bool | None:
 
     # otherwise, we can look at device attrs via comports()...
     try:
-        komports = comports(include_links=True)
+        loop = asyncio.get_running_loop()
+        komports = await loop.run_in_executor(
+            None, partial(comports, include_links=True)
+        )
     except ImportError as err:
         raise exc.TransportSerialError(f"Unable to find {serial_port}: {err}") from err
 
@@ -841,8 +843,6 @@ class PortTransport(_RegHackMixin, _FullTransport, _PortTransportAbstractor):  #
             self._leak_sem(), name="PortTransport._leak_sem()"
         )
 
-        self._is_hgi80 = is_hgi80(self.serial.name)
-
         self._loop.create_task(
             self._create_connection(), name="PortTransport._create_connection()"
         )
@@ -855,6 +855,8 @@ class PortTransport(_RegHackMixin, _FullTransport, _PortTransportAbstractor):  #
 
         # signature also serves to discover the HGI's device_id (& for pkt log, if any)
 
+        self._is_hgi80 = await is_hgi80(self.serial.name)
+
         async def connect_sans_signature() -> None:
             """Call connection_made() without sending/waiting for a signature."""
 

ramses_tx/version.py

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