ramses-rf 0.52.4__py3-none-any.whl → 0.53.0__py3-none-any.whl

ramses_rf/device/base.py

@@ -87,9 +87,10 @@ class DeviceBase(Entity):
         return self.id < other.id  # type: ignore[no-any-return]
 
     def _update_traits(self, **traits: Any) -> None:
-        """Update a device with new schema attrs.
+        """Update a device with new schema attributes.
 
-        Raise an exception if the new schema is not a superset of the existing schema.
+        :param traits: The traits to apply (e.g., alias, class, faked)
+        :raises TypeError: If the device is not fakeable but 'faked' is set.
         """
 
         traits = shrink(SCH_TRAITS(traits))
@@ -342,7 +343,17 @@ class Fakeable(DeviceBase):
         idx: IndexT = "00",
         require_ratify: bool = False,
     ) -> tuple[Packet, Packet, Packet, Packet | None]:
-        """Listen for a binding and return the Offer, or raise an exception."""
+        """Listen for a binding and return the Offer packets.
+
+        :param accept_codes: The codes allowed for this binding
+        :type accept_codes: Iterable[Code]
+        :param idx: The index to bind to, defaults to "00"
+        :type idx: IndexT
+        :param require_ratify: Whether a ratification step is required, defaults to False
+        :type require_ratify: bool
+        :return: A tuple of the four binding transaction packets
+        :rtype: tuple[Packet, Packet, Packet, Packet | None]
+        """
 
         if not self._bind_context:
             raise TypeError(f"{self}: Faking not enabled")

ramses_rf/device/heat.py

@@ -669,7 +669,7 @@ class OtbGateway(Actuator, HeatDemand):  # OTB (10): 3220 (22D9, others)
 
         # TODO(eb): cleanup
         if self._gwy.msg_db:
-            self._add_record(address=self.addr, code=Code._3220, verb="RP")
+            self._add_record(id=self.id, code=Code._3220, verb="RP")
         # adds a "sim" RP opentherm_msg to the SQLite MessageIndex with code _3220
         # causes exc when fetching ALL, when no "real" msg was added to _msgs_. We skip those.
         else:

ramses_rf/device/hvac.py

@@ -921,27 +921,30 @@ class HvacVentilator(FilterChange):  # FAN: RP/31DA, I/31D[9A], 2411
 
         :return: string describing fan mode, speed
         """
-        if self._gwy.msg_db:
-            # Use SQLite query on MessageIndex. res_rate/res_mode not exposed yet
-            sql = f"""
-                SELECT code from messages WHERE verb in (' I', 'RP')
-                AND (src = ? OR dst = ?)
-                AND (plk LIKE '%{SZ_FAN_MODE}%')
-            """
-            res_mode: list = self._msg_qry(sql)
-            # SQLite query on MessageIndex
-            _LOGGER.debug(f"{res_mode} # FAN_MODE FETCHED from MessageIndex")
-
-            sql = f"""
-                SELECT code from messages WHERE verb in (' I', 'RP')
-                AND (src = ? OR dst = ?)
-                AND (plk LIKE '%{SZ_FAN_RATE}%')
-            """
-            res_rate: list = self._msg_qry(sql)
-            # SQLite query on MessageIndex
-            _LOGGER.debug(
-                f"{res_rate} # FAN_RATE FETCHED from MessageIndex"
-            )  # DEBUG always empty?
+        # if self._gwy.msg_db:
+        # Use SQLite query on MessageIndex. res_rate/res_mode not exposed yet
+        # working fine in 0.52.4, no need to specify code, only payload key
+        # sql = f"""
+        #     SELECT code from messages WHERE verb in (' I', 'RP')
+        #     AND (src = ? OR dst = ?)
+        #     AND (plk LIKE '%{SZ_FAN_MODE}%')
+        # """
+        # res_mode: list = self._msg_qry(sql)
+        # # SQLite query on MessageIndex
+        # _LOGGER.debug(
+        #     f"# Fetched FAN_MODE for {self.id} from MessageIndex: {res_mode}"
+        # )
+
+        # sql = f"""
+        #     SELECT code from messages WHERE verb in (' I', 'RP')
+        #     AND (src = ? OR dst = ?)
+        #     AND (plk LIKE '%{SZ_FAN_RATE}%')
+        # """
+        # res_rate: list = self._msg_qry(sql)
+        # # SQLite query on MessageIndex
+        # _LOGGER.debug(
+        #     f"# Fetched FAN_RATE for {self.id} from MessageIndex: {res_rate}"
+        # )
 
         if Code._31D9 in self._msgs:
             # was a dict by Code

ramses_rf/entity_base.py

@@ -15,7 +15,7 @@ from types import ModuleType
 from typing import TYPE_CHECKING, Any, Final
 
 from ramses_rf.helpers import schedule_task
-from ramses_tx import Address, Priority, QosParams
+from ramses_tx import Priority, QosParams
 from ramses_tx.address import ALL_DEVICE_ID
 from ramses_tx.const import MsgId
 from ramses_tx.opentherm import OPENTHERM_MESSAGES
@@ -247,7 +247,7 @@ class _MessageDB(_Entity):
 
         if self._gwy.msg_db:  # central SQLite MessageIndex
             _LOGGER.debug(
-                "For %s (_z_id %s) add msg %s, src %s, dst %s to msg_db.",
+                "For %s (_z_id %s) add to msg_db: %s, src %s, dst %s",
                 self.id,
                 self._z_id,
                 msg,
@@ -324,12 +324,12 @@ class _MessageDB(_Entity):
         ]
 
     def _add_record(
-        self, address: Address, code: Code | None = None, verb: str = " I"
+        self, id: DeviceIdT, code: Code | None = None, verb: str = " I"
     ) -> None:
         """Add a (dummy) record to the central SQLite MessageIndex."""
         # used by heat.py init
         if self._gwy.msg_db:
-            self._gwy.msg_db.add_record(str(address), code=str(code), verb=verb)
+            self._gwy.msg_db.add_record(id, code=str(code), verb=verb)
         # else:
         #     _LOGGER.warning("Missing MessageIndex")
         # raise NotImplementedError
@@ -1029,7 +1029,7 @@ class _Discovery(_MessageDB):
                         sql = """
                             SELECT dtm from messages WHERE
                             code = ?
-                            AND verb = ' I'
+                            AND verb in (' I', 'RP')
                             AND ctx = 'True'
                             AND (src = ? OR dst = ?)
                         """
@@ -1045,10 +1045,12 @@ class _Discovery(_MessageDB):
                             msgs += res[0]  # expect 1 Message in returned tuple
                         else:
                             _LOGGER.debug(
-                                f"No msg found for hdr {hdr}, tesk code {task[_SZ_COMMAND].code}"
+                                f"No msg found for hdr {hdr}, task code {task[_SZ_COMMAND].code}"
                             )
                     else:  # TODO(eb) remove next Q1 2026
-                        msgs += [self.tcs._msgz[task[_SZ_COMMAND].code][I_][True]]
+                        # CRITICAL FIX: self.tcs might be None during early discovery
+                        if self.tcs:
+                            msgs += [self.tcs._msgz[task[_SZ_COMMAND].code][I_][True]]
                         # raise NotImplementedError
             except KeyError:
                 pass

ramses_rf/gateway.py

@@ -11,6 +11,7 @@ from __future__ import annotations
 
 import asyncio
 import logging
+from collections.abc import Awaitable, Callable
 from types import SimpleNamespace
 from typing import TYPE_CHECKING, Any
 
@@ -83,7 +84,12 @@ _LOGGER = logging.getLogger(__name__)
 
 
 class Gateway(Engine):
-    """The gateway class."""
+    """The gateway class.
+
+    This class serves as the primary interface for the RAMSES RF network. It manages
+    the serial connection (via ``Engine``), device discovery, schema maintenance,
+    and message dispatching.
+    """
 
     def __init__(
         self,
@@ -94,8 +100,30 @@ class Gateway(Engine):
         block_list: DeviceListT | None = None,
         known_list: DeviceListT | None = None,
         loop: asyncio.AbstractEventLoop | None = None,
+        transport_constructor: Callable[..., Awaitable[RamsesTransportT]] | None = None,
         **kwargs: Any,
     ) -> None:
+        """Initialize the Gateway instance.
+
+        :param port_name: The serial port name (e.g., '/dev/ttyUSB0') or None if using a file.
+        :type port_name: str | None
+        :param input_file: Path to a packet log file for playback, defaults to None.
+        :type input_file: str | None, optional
+        :param port_config: Configuration dictionary for the serial port, defaults to None.
+        :type port_config: PortConfigT | None, optional
+        :param packet_log: Configuration for packet logging, defaults to None.
+        :type packet_log: PktLogConfigT | None, optional
+        :param block_list: A list of device IDs to block/ignore, defaults to None.
+        :type block_list: DeviceListT | None, optional
+        :param known_list: A list of known device IDs and their traits, defaults to None.
+        :type known_list: DeviceListT | None, optional
+        :param loop: The asyncio event loop to use, defaults to None.
+        :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 kwargs: Additional configuration parameters passed to the engine and schema.
+        :type kwargs: Any
+        """
         if kwargs.pop("debug_mode", None):
             _LOGGER.setLevel(logging.DEBUG)
 
@@ -110,6 +138,7 @@ class Gateway(Engine):
             block_list=block_list,
             known_list=known_list,
             loop=loop,
+            transport_constructor=transport_constructor,
             **SCH_ENGINE_CONFIG(config),
         )
 
@@ -132,13 +161,23 @@ class Gateway(Engine):
         self.msg_db: MessageIndex | None = None
 
     def __repr__(self) -> str:
+        """Return a string representation of the Gateway.
+
+        :returns: A string describing the gateway's input source (port or file).
+        :rtype: str
+        """
         if not self.ser_name:
             return f"Gateway(input_file={self._input_file})"
         return f"Gateway(port_name={self.ser_name}, port_config={self._port_config})"
 
     @property
     def hgi(self) -> HgiGateway | None:
-        """Return the active HGI80-compatible gateway device, if known."""
+        """Return the active HGI80-compatible gateway device, if known.
+
+        :returns: The gateway device instance or None if the transport is not set up
+                  or the HGI ID is not found.
+        :rtype: HgiGateway | None
+        """
         if not self._transport:
             return None
         if device_id := self._transport.get_extra_info(SZ_ACTIVE_HGI):
@@ -152,10 +191,21 @@ class Gateway(Engine):
         start_discovery: bool = True,
         cached_packets: dict[str, str] | None = None,
     ) -> None:
-        """Start the Gateway and Initiate discovery as required."""
+        """Start the Gateway and Initiate discovery as required.
+
+        This method initializes packet logging, the SQLite index, loads the schema,
+        and optionally restores state from cached packets before starting the transport.
+
+        :param start_discovery: Whether to initiate the discovery process after start, defaults to True.
+        :type start_discovery: bool, optional
+        :param cached_packets: A dictionary of packet strings used to restore state, defaults to None.
+        :type cached_packets: dict[str, str] | None, optional
+        :returns: None
+        :rtype: None
+        """
 
         def initiate_discovery(dev_list: list[Device], sys_list: list[Evohome]) -> None:
-            _LOGGER.debug("ENGINE: Initiating/enabling discovery...")
+            _LOGGER.debug("Engine: Initiating/enabling discovery...")
 
             # [d._start_discovery_poller() for d in devs]
             for device in dev_list:
@@ -201,10 +251,21 @@ class Gateway(Engine):
             initiate_discovery(self.devices, self.systems)
 
     def create_sqlite_message_index(self) -> None:
+        """Initialize the SQLite MessageIndex.
+
+        :returns: None
+        :rtype: None
+        """
         self.msg_db = MessageIndex()  # start the index
 
     async def stop(self) -> None:
-        """Stop the Gateway and tidy up."""
+        """Stop the Gateway and tidy up.
+
+        Stops the message database and the underlying engine/transport.
+
+        :returns: None
+        :rtype: None
+        """
 
         if self.msg_db:
             self.msg_db.stop()
@@ -214,6 +275,12 @@ class Gateway(Engine):
         """Pause the (unpaused) gateway (disables sending/discovery).
 
         There is the option to save other objects, as `args`.
+
+        :param args: Additional objects/state to save during the pause.
+        :type args: Any
+        :returns: None
+        :rtype: None
+        :raises RuntimeError: If the engine fails to pause.
         """
         _LOGGER.debug("Gateway: Pausing engine...")
 
@@ -229,6 +296,9 @@ class Gateway(Engine):
         """Resume the (paused) gateway (enables sending/discovery, if applicable).
 
         Will restore other objects, as `args`.
+
+        :returns: A tuple of arguments saved during the pause.
+        :rtype: tuple[Any]
         """
         args: tuple[Any]
 
@@ -241,7 +311,13 @@ class Gateway(Engine):
     def get_state(
         self, include_expired: bool = False
     ) -> tuple[dict[str, Any], dict[str, str]]:
-        """Return the current schema & state (may include expired packets)."""
+        """Return the current schema & state (may include expired packets).
+
+        :param include_expired: If True, include expired packets in the state, defaults to False.
+        :type include_expired: bool, optional
+        :returns: A tuple containing the schema dictionary and the packet log dictionary.
+        :rtype: tuple[dict[str, Any], dict[str, str]]
+        """
 
         self._pause()
 
@@ -287,10 +363,21 @@ class Gateway(Engine):
     async def _restore_cached_packets(
         self, packets: dict[str, str], _clear_state: bool = False
     ) -> None:
-        """Restore cached packets (may include expired packets)."""
+        """Restore cached packets (may include expired packets).
+
+        This process uses a temporary transport to replay the packet history
+        into the message handler.
+
+        :param packets: A dictionary of packet strings.
+        :type packets: dict[str, str]
+        :param _clear_state: If True, reset internal state before restoration (for testing), defaults to False.
+        :type _clear_state: bool, optional
+        :returns: None
+        :rtype: None
+        """
 
         def clear_state() -> None:
-            _LOGGER.info("GATEWAY: Clearing existing schema/state...")
+            _LOGGER.info("Gateway: Clearing existing schema/state...")
 
             # self._schema = {}
 
@@ -303,7 +390,7 @@ class Gateway(Engine):
 
         tmp_transport: RamsesTransportT  # mypy hint
 
-        _LOGGER.debug("GATEWAY: Restoring a cached packet log...")
+        _LOGGER.debug("Gateway: Restoring a cached packet log...")
         self._pause()
 
         if _clear_state:  # only intended for test suite use
@@ -339,11 +426,18 @@ class Gateway(Engine):
 
         await tmp_transport.get_extra_info(SZ_READER_TASK)
 
-        _LOGGER.debug("GATEWAY: Restored, resuming")
+        _LOGGER.debug("Gateway: Restored, resuming")
         self._resume()
 
     def _add_device(self, dev: Device) -> None:  # TODO: also: _add_system()
-        """Add a device to the gateway (called by devices during instantiation)."""
+        """Add a device to the gateway (called by devices during instantiation).
+
+        :param dev: The device instance to add.
+        :type dev: Device
+        :returns: None
+        :rtype: None
+        :raises LookupError: If the device already exists in the gateway.
+        """
 
         if dev.id in self.device_by_id:
             raise LookupError(f"Device already exists: {dev.id}")
@@ -360,13 +454,25 @@ class Gateway(Engine):
         child_id: str | None = None,
         is_sensor: bool | None = None,
     ) -> Device:  # TODO: **schema/traits) -> Device:  # may: LookupError
-        """Return a device, create it if required.
-
-        First, use the traits to create/update it, then pass it any msg to handle.
-        All devices have traits, but only controllers (CTL, UFC) have a schema.
-
-        Devices are uniquely identified by a device id.
-        If a device is created, attach it to the gateway.
+        """Return a device, creating it if it does not already exist.
+
+        This method uses provided traits to create or update a device and optionally
+        passes a message for it to handle. All devices have traits, but only
+        controllers (CTL, UFC) have a schema.
+
+        :param device_id: The unique identifier for the device (e.g., '01:123456').
+        :type device_id: DeviceIdT
+        :param msg: An optional initial message for the device to process, defaults to None.
+        :type msg: Message | None, optional
+        :param parent: The parent entity of this device, if any, defaults to None.
+        :type parent: Parent | None, optional
+        :param child_id: The specific ID of the child component if applicable, defaults to None.
+        :type child_id: str | None, optional
+        :param is_sensor: Indicates if this device should be treated as a sensor, defaults to None.
+        :type is_sensor: bool | None, optional
+        :returns: The existing or newly created device instance.
+        :rtype: Device
+        :raises LookupError: If the device ID is blocked or not in the allowed known_list.
         """
 
         def check_filter_lists(dev_id: DeviceIdT) -> None:  # may: LookupError
@@ -434,7 +540,21 @@ class Gateway(Engine):
         device_id: DeviceIdT,
         create_device: bool = False,
     ) -> Device | Fakeable:
-        """Create a faked device."""
+        """Create a faked device.
+
+        Converts an existing device to a fake device, or creates a new fake device
+        if it satisfies strict criteria (valid ID, presence in known_list).
+
+        :param device_id: The ID of the device to fake.
+        :type device_id: DeviceIdT
+        :param create_device: If True, allow creation of a new device if it doesn't exist, defaults to False.
+        :type create_device: bool, optional
+        :returns: The faked device instance.
+        :rtype: Device | Fakeable
+        :raises TypeError: If the device ID is invalid or the device is not fakeable.
+        :raises LookupError: If the device does not exist and create_device is False,
+                             or if create_device is True but the ID is not in known_list.
+        """
 
         if not is_valid_dev_id(device_id):
             raise TypeError(f"The device id is not valid: {device_id}")
@@ -452,7 +572,11 @@ class Gateway(Engine):
 
     @property
     def tcs(self) -> Evohome | None:
-        """Return the primary TCS, if any."""
+        """Return the primary Temperature Control System (TCS), if any.
+
+        :returns: The primary Evohome system or None.
+        :rtype: Evohome | None
+        """
 
         if self._tcs is None and self.systems:
             self._tcs = self.systems[0]
@@ -465,6 +589,9 @@ class Gateway(Engine):
         Unlike orphans, which are always instantiated when a schema is loaded, these
         devices may/may not exist. However, if they are ever instantiated, they should
         be given these traits.
+
+        :returns: A dictionary where keys are device IDs and values are their traits.
+        :rtype: DeviceListT
         """
 
         result = self._include  # could be devices here, not (yet) in gwy.devices
@@ -479,6 +606,11 @@ class Gateway(Engine):
 
     @property
     def system_by_id(self) -> dict[DeviceIdT, Evohome]:
+        """Return a mapping of device IDs to their associated Evohome systems.
+
+        :returns: A dictionary mapping DeviceId to Evohome instances.
+        :rtype: dict[DeviceIdT, Evohome]
+        """
         return {
             d.id: d.tcs
             for d in self.devices
@@ -487,6 +619,11 @@ class Gateway(Engine):
 
     @property
     def systems(self) -> list[Evohome]:
+        """Return a list of all identified Evohome systems.
+
+        :returns: A list of Evohome system instances.
+        :rtype: list[Evohome]
+        """
         return list(self.system_by_id.values())
 
     @property
@@ -498,6 +635,9 @@ class Gateway(Engine):
          - schema (everything else)
          - known_list
          - block_list
+
+        :returns: A dictionary representing the current internal configuration state.
+        :rtype: dict[str, Any]
         """
 
         return {
@@ -519,6 +659,9 @@ class Gateway(Engine):
         Orphans are devices that 'exist' but don't yet have a place in the schema
         hierarchy (if ever): therefore, they are instantiated when the schema is loaded,
         just like the other devices in the schema.
+
+        :returns: A dictionary representing the entire system schema structure.
+        :rtype: dict[str, Any]
         """
 
         schema: dict[str, Any] = {SZ_MAIN_TCS: self.tcs.ctl.id if self.tcs else None}
@@ -546,10 +689,20 @@ class Gateway(Engine):
 
     @property
     def params(self) -> dict[str, Any]:
+        """Return the parameters for all devices.
+
+        :returns: A dictionary containing parameters for every device in the gateway.
+        :rtype: dict[str, Any]
+        """
         return {SZ_DEVICES: {d.id: d.params for d in sorted(self.devices)}}
 
     @property
     def status(self) -> dict[str, Any]:
+        """Return the status for all devices and the transport rate.
+
+        :returns: A dictionary containing device statuses and transmission rate.
+        :rtype: dict[str, Any]
+        """
         tx_rate = self._transport.get_extra_info("tx_rate") if self._transport else None
         return {
             SZ_DEVICES: {d.id: d.status for d in sorted(self.devices)},
@@ -557,7 +710,15 @@ class Gateway(Engine):
         }
 
     def _msg_handler(self, msg: Message) -> None:
-        """A callback to handle messages from the protocol stack."""
+        """A callback to handle messages from the protocol stack.
+
+        Handles message reassembly (fragmentation) and dispatches the message for processing.
+
+        :param msg: The incoming message to handle.
+        :type msg: Message
+        :returns: None
+        :rtype: None
+        """
 
         super()._msg_handler(msg)
 
@@ -585,9 +746,20 @@ class Gateway(Engine):
     ) -> asyncio.Task[Packet]:
         """Wrapper to schedule an async_send_cmd() and return the Task.
 
-        num_repeats:  0 = send once, 1 = send twice, etc.
-        gap_duration: the gap between repeats (in seconds)
-        priority:     the priority of the command
+        :param cmd: The command object to send.
+        :type cmd: Command
+        :param gap_duration: The gap between repeats (in seconds), defaults to DEFAULT_GAP_DURATION.
+        :type gap_duration: float, optional
+        :param num_repeats: Number of times to repeat the command (0 = once, 1 = twice, etc.), defaults to DEFAULT_NUM_REPEATS.
+        :type num_repeats: int, optional
+        :param priority: The priority of the command, defaults to Priority.DEFAULT.
+        :type priority: Priority, optional
+        :param timeout: Time to wait for a send to complete, defaults to DEFAULT_SEND_TIMEOUT.
+        :type timeout: float, optional
+        :param wait_for_reply: Whether to wait for a reply packet, defaults to DEFAULT_WAIT_FOR_REPLY.
+        :type wait_for_reply: bool | None, optional
+        :returns: The asyncio Task wrapping the send operation.
+        :rtype: asyncio.Task[Packet]
         """
 
         coro = self.async_send_cmd(
@@ -620,9 +792,24 @@ class Gateway(Engine):
         If wait_for_reply is True (*and* the Command has a rx_header), return the
         reply Packet. Otherwise, simply return the echo Packet.
 
-        If the expected Packet can't be returned, raise:
-            ProtocolSendFailed: tried to Tx Command, but didn't get echo/reply
-            ProtocolError:      didn't attempt to Tx Command for some reason
+        :param cmd: The command object to send.
+        :type cmd: Command
+        :param gap_duration: The gap between repeats (in seconds), defaults to DEFAULT_GAP_DURATION.
+        :type gap_duration: float, optional
+        :param num_repeats: Number of times to repeat the command, defaults to DEFAULT_NUM_REPEATS.
+        :type num_repeats: int, optional
+        :param priority: The priority of the command, defaults to Priority.DEFAULT.
+        :type priority: Priority, optional
+        :param max_retries: Maximum number of retries if sending fails, defaults to DEFAULT_MAX_RETRIES.
+        :type max_retries: int, optional
+        :param timeout: Time to wait for the command to send, defaults to DEFAULT_SEND_TIMEOUT.
+        :type timeout: float, optional
+        :param wait_for_reply: Whether to wait for a reply packet, defaults to DEFAULT_WAIT_FOR_REPLY.
+        :type wait_for_reply: bool | None, optional
+        :returns: The echo packet or reply packet depending on wait_for_reply.
+        :rtype: Packet
+        :raises ProtocolSendFailed: If the command was sent but no reply/echo was received.
+        :raises ProtocolError: If the system failed to attempt the transmission.
         """
 
         return await super().async_send_cmd(

ramses_rf/schemas.py

@@ -237,6 +237,7 @@ SCH_GLOBAL_SCHEMAS_DICT = {  # System schemas - can be 0-many Heat/HVAC schemas
     vol.Optional(SCH_DEVICE_ID_ANY): SCH_VCS,  # must be after SCH_DEVICE_ID_CTL
     vol.Optional(SZ_ORPHANS_HEAT): vol.All([SCH_DEVICE_ID_ANY], vol.Unique()),
     vol.Optional(SZ_ORPHANS_HVAC): vol.All([SCH_DEVICE_ID_ANY], vol.Unique()),
+    vol.Optional("transport_constructor"): vol.Any(callable, None),
 }
 SCH_GLOBAL_SCHEMAS = vol.Schema(SCH_GLOBAL_SCHEMAS_DICT, extra=vol.PREVENT_EXTRA)
 
@@ -285,7 +286,7 @@ SCH_GLOBAL_CONFIG = (
 #
 # 6/7: External Schemas, to be used by clients of this library
 def NormaliseRestoreCache() -> Callable[[bool | dict[str, bool]], dict[str, bool]]:
-    """Convert a short-hand restore_cache bool to a dict.
+    """Convert a shorthand restore_cache bool to a dict.
 
     restore_cache: bool ->  restore_cache:
                               restore_schema: bool

ramses_rf/system/zones.py

@@ -36,7 +36,7 @@ from ramses_rf.device import (
     TrvActuator,
     UfhController,
 )
-from ramses_rf.entity_base import Child, Entity, Parent, class_by_attr
+from ramses_rf.entity_base import _ID_SLICE, Child, Entity, Parent, class_by_attr
 from ramses_rf.helpers import shrink
 from ramses_rf.schemas import (
     SCH_TCS_DHW,
@@ -728,13 +728,33 @@ class Zone(ZoneSchedule):
         """Set the target temperature, until the next scheduled setpoint."""
 
         if value is None:
-            return self.reset_mode()
+            self.reset_mode()
 
         cmd = Command.set_zone_setpoint(self.ctl.id, self.idx, value)
         self._gwy.send_cmd(cmd, priority=Priority.HIGH)
 
     @property
     def temperature(self) -> float | None:  # 30C9
+        if self._gwy.msg_db:
+            # evohome zones only get initial temp from src + idx, so use zone sensor if newer
+            sql = f"""
+                SELECT dtm from messages WHERE verb in (' I', 'RP')
+                AND code = '30C9'
+                AND (plk LIKE '%{SZ_TEMPERATURE}%')
+                AND ((src = ? AND ctx = ?) OR src = ?)
+            """
+            sensor_id = "aa:aaaaaa"  # should not match any device_id
+            if self._sensor:
+                sensor_id = self._sensor.id
+            # custom SQLite query on MessageIndex
+            msgs = self._gwy.msg_db.qry(
+                sql, (self.id[:_ID_SLICE], self.idx, sensor_id[:_ID_SLICE])
+            )
+            if msgs and len(msgs) > 0:
+                msgs_sorted = sorted(msgs, reverse=True)
+                return msgs_sorted[0].payload.get(SZ_TEMPERATURE)  # type: ignore[no-any-return]
+            return None
+        # else: TODO Q1 2026 remove remainder
         return self._msg_value(Code._30C9, key=SZ_TEMPERATURE)  # type: ignore[no-any-return]
 
     @property

ramses_rf/version.py

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

{ramses_rf-0.52.4.dist-info → ramses_rf-0.53.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ramses_rf
-Version: 0.52.4
+Version: 0.53.0
 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