ramses-rf 0.22.40__py3-none-any.whl → 0.51.2__py3-none-any.whl

ramses_rf/system/zones.py

@@ -1,18 +1,16 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-#
 """RAMSES RF - The evohome-compatible zones."""
+
 from __future__ import annotations
 
+import asyncio
 import logging
 import math
-from asyncio import Future
-from datetime import datetime as dt
-from datetime import timedelta as td
-from typing import Any, TypeVar
+from datetime import datetime as dt, timedelta as td
+from typing import TYPE_CHECKING, Any, TypeVar
 
-from ..const import (
-    DEV_ROLE,
+from ramses_rf import exceptions as exc
+from ramses_rf.const import (
     DEV_ROLE_MAP,
     DEV_TYPE_MAP,
     SZ_DOMAIN_ID,
@@ -26,11 +24,11 @@ from ..const import (
     SZ_ZONE_IDX,
     SZ_ZONE_TYPE,
     ZON_MODE_MAP,
-    ZON_ROLE,
     ZON_ROLE_MAP,
-    __dev_mode__,
+    DevRole,
+    ZoneRole,
 )
-from ..device import (
+from ramses_rf.device import (
     BdrSwitch,
     Controller,
     Device,
@@ -38,12 +36,9 @@ from ..device import (
     TrvActuator,
     UfhController,
 )
-from ..entity_base import Child, Entity, Parent, class_by_attr
-from ..helpers import shrink
-from ..protocol import Address, Command, CorruptStateError, Message
-from ..protocol.command import _mk_cmd
-from ..protocol.const import SZ_PAYLOAD
-from ..schemas import (
+from ramses_rf.entity_base import Child, Entity, Parent, class_by_attr
+from ramses_rf.helpers import shrink
+from ramses_rf.schemas import (
     SCH_TCS_DHW,
     SCH_TCS_ZONES_ZON,
     SZ_ACTUATORS,
@@ -53,98 +48,114 @@ from ..schemas import (
     SZ_HTG_VALVE,
     SZ_SENSOR,
 )
-from .schedule import Schedule
+from ramses_tx import Address, Command, Message, Priority
+
+from .schedule import InnerScheduleT, OuterScheduleT, Schedule
+
+if TYPE_CHECKING:
+    from ramses_tx import Packet
+    from ramses_tx.schemas import DeviceIdT, DevIndexT
+    from ramses_tx.typed_dicts import PayDictT
+
+    from .heat import Evohome, _MultiZoneT, _StoredHwT
+
 
 # Kudos & many thanks to:
 # - @dbmandrake: valve_position -> heat_demand transform
 
-# TODO: add optional eavesdrop of zone_type
 
+from ramses_rf.const import (  # noqa: F401, isort: skip, pylint: disable=unused-import
+    F9,
+    FA,
+    FC,
+    FF,
+)
 
-# skipcq: PY-W2000
-from ..protocol import (  # noqa: F401, isort: skip, pylint: disable=unused-import
+from ramses_rf.const import (  # noqa: F401, isort: skip, pylint: disable=unused-import
     I_,
     RP,
     RQ,
     W_,
-    F9,
-    FA,
-    FC,
-    FF,
     Code,
 )
 
-
-DEV_MODE = __dev_mode__
-
 _LOGGER = logging.getLogger(__name__)
-if DEV_MODE:
-    _LOGGER.setLevel(logging.DEBUG)
-
-
-_ZoneT = TypeVar("_ZoneT", bound="ZoneBase")
 
 
 class ZoneBase(Child, Parent, Entity):
     """The Zone/DHW base class."""
 
-    _SLUG: str = None  # type: ignore[assignment]
-    _ROLE_ACTUATORS: str = None  # type: ignore[assignment]
-    _ROLE_SENSORS: str = None  # type: ignore[assignment]
+    _SLUG: str = None
+
+    _ROLE_ACTUATORS: str = None
+    _ROLE_SENSORS: str = None
 
-    def __init__(self, tcs, zone_idx: str) -> None:
+    def __init__(self, tcs: _MultiZoneT | _StoredHwT, zone_idx: str) -> None:
         super().__init__(tcs._gwy)
 
+        # FIXME: ZZZ entities must know their parent device ID and their own idx
+        self._z_id = tcs.id  # the responsible device is the controller
+        self._z_idx: DevIndexT = zone_idx  # the zone idx (ctx), 00-0B (or 0F), HW (FA)
+
         self.id: str = f"{tcs.id}_{zone_idx}"
 
-        self.tcs = tcs
+        self.tcs: Evohome = tcs
         self.ctl: Controller = tcs.ctl
-        self._child_id = zone_idx
+        self._child_id: str = zone_idx
 
         self._name = None  # param attr
 
+    # Should be a private method
     @classmethod
-    def create_from_schema(cls, tcs, zone_idx: str, **schema):
+    def create_from_schema(
+        cls, tcs: _MultiZoneT, zone_idx: str, **schema: Any
+    ) -> ZoneBase:
         """Create a CH/DHW zone for a TCS and set its schema attrs.
 
         The appropriate Zone class should have been determined by a factory.
         Can be a heating zone (of a klass), or the DHW subsystem (idx must be 'HW').
         """
 
-        zon = cls(tcs, zone_idx)
+        zon = cls(tcs, zone_idx)  # type: ignore[arg-type]
         zon._update_schema(**schema)
         return zon
 
-    def _update_schema(self, **schema):
+    def _update_schema(self, **schema: Any) -> None:
         raise NotImplementedError
 
     def __repr__(self) -> str:
         return f"{self.id} ({self._SLUG})"
 
-    def __lt__(self, other) -> bool:
+    def __lt__(self, other: object) -> bool:
         if not isinstance(other, ZoneBase):
             return NotImplemented
         return self.idx < other.idx
 
-    def _make_cmd(self, code, **kwargs) -> None:  # skipcq: PYL-W0221
-        payload = kwargs.pop(SZ_PAYLOAD, f"{self.idx}00")
-        super()._make_cmd(code, self.ctl.id, payload=payload, **kwargs)
+    @property
+    def idx(self) -> str:
+        return self._child_id
 
     @property
-    def heating_type(self) -> str:
-        """Return the type of the zone/DHW (e.g. electric_zone, stored_dhw)."""
-        return ZON_ROLE_MAP[self._SLUG]
+    def schema(self) -> dict[str, Any]:
+        """Return the schema (can't change without destroying/re-creating entity)."""
+        return {}
 
     @property
-    def idx(self) -> str:
-        return self._child_id
+    def params(self) -> dict[str, Any]:
+        """Return configuration (can be changed by user)."""
+        return {}
+
+    @property
+    def status(self) -> dict[str, Any]:
+        """Return the current state."""
+        return {}
 
 
-class ZoneSchedule:  # 0404
-    def __init__(self, *args, **kwargs) -> None:
+class ZoneSchedule(ZoneBase):  # 0404
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
 
-        self._schedule = Schedule(self)  # ? add to discovery
+        self._schedule = Schedule(self)  # type: ignore[arg-type]
 
     def _handle_msg(self, msg: Message) -> None:
         super()._handle_msg(msg)
@@ -152,21 +163,24 @@ class ZoneSchedule:  # 0404
         if msg.code in (Code._0006, Code._0404):
             self._schedule._handle_msg(msg)
 
-    async def get_schedule(self, *, force_io=None) -> None | dict:
+    async def get_schedule(self, *, force_io: bool = False) -> InnerScheduleT | None:
         await self._schedule.get_schedule(force_io=force_io)
         return self.schedule
 
-    async def set_schedule(self, schedule) -> None | dict:
-        await self._schedule.set_schedule(schedule)
+    async def set_schedule(self, schedule: OuterScheduleT) -> InnerScheduleT | None:
+        await self._schedule.set_schedule(schedule)  # type: ignore[arg-type]
         return self.schedule
 
     @property
-    def schedule(self) -> None | dict:
-        """Return the latest retreived schedule (not guaranteed to be up to date)."""
+    def schedule(self) -> InnerScheduleT | None:
+        """Return the latest retrieved schedule (not guaranteed to be up to date)."""
+        # inner: [{"day_of_week": 0, "switchpoints": [...], {"day_of_week": 1, ...
+        # outer: {"zone_idx": "01", "schedule": <inner>
+
         return self._schedule.schedule
 
     @property
-    def schedule_version(self) -> None | int:
+    def schedule_version(self) -> int | None:  # TODO: make int
         """Return the version number associated with the latest retrieved schedule."""
         return self._schedule.version
 
@@ -178,12 +192,12 @@ class ZoneSchedule:  # 0404
         }
 
 
-class DhwZone(ZoneSchedule, ZoneBase):  # CS92A  # TODO: add Schedule
+class DhwZone(ZoneSchedule):  # CS92A
     """The DHW class."""
 
-    _SLUG: str = ZON_ROLE.DHW
+    _SLUG: str = ZoneRole.DHW
 
-    def __init__(self, tcs, zone_idx: str = "HW") -> None:
+    def __init__(self, tcs: _StoredHwT, zone_idx: str = "HW") -> None:
         _LOGGER.debug("Creating a DHW for TCS: %s_HW (%s)", tcs.id, self.__class__)
 
         if tcs.dhw:
@@ -193,20 +207,21 @@ class DhwZone(ZoneSchedule, ZoneBase):  # CS92A  # TODO: add Schedule
 
         super().__init__(tcs, "HW")
 
-        self._dhw_sensor: DhwSensor = None  # type: ignore[assignment]
-        self._dhw_valve: BdrSwitch = None  # type: ignore[assignment]
-        self._htg_valve: BdrSwitch = None  # type: ignore[assignment]
+        # DhwZones have a sensor, but actuators are optional, depending on schema
+        self._dhw_sensor: DhwSensor | None = None
+        self._dhw_valve: BdrSwitch | None = None
+        self._htg_valve: BdrSwitch | None = None
 
     def _setup_discovery_cmds(self) -> None:
         # super()._setup_discovery_cmds()
 
         for payload in (
-            f"00{DEV_ROLE_MAP.DHW}",
-            f"00{DEV_ROLE_MAP.HTG}",
-            f"01{DEV_ROLE_MAP.HTG}",
+            f"00{DEV_ROLE_MAP.DHW}",  # sensor
+            f"00{DEV_ROLE_MAP.HTG}",  # hotwater_valve
+            f"01{DEV_ROLE_MAP.HTG}",  # heating_valve
         ):
             self._add_discovery_cmd(
-                _mk_cmd(RQ, Code._000C, payload, self.ctl.id), 60 * 60 * 24
+                Command.from_attrs(RQ, self.ctl.id, Code._000C, payload), 60 * 60 * 24
             )
 
         self._add_discovery_cmd(Command.get_dhw_params(self.ctl.id), 60 * 60 * 6)
@@ -215,40 +230,40 @@ class DhwZone(ZoneSchedule, ZoneBase):  # CS92A  # TODO: add Schedule
         self._add_discovery_cmd(Command.get_dhw_temp(self.ctl.id), 60 * 15)
 
     def _handle_msg(self, msg: Message) -> None:
-        def eavesdrop_dhw_sensor(this, *, prev=None) -> None:
-            """Eavesdrop packets, or pairs of packets, to maintain the system state.
+        # def eavesdrop_dhw_sensor(this: Message, *, prev: Message | None = None) -> None:
+        # """Eavesdrop packets, or pairs of packets, to maintain the system state.
 
-            There are only 2 ways to to find a controller's DHW sensor:
-            1. The 10A0 RQ/RP *from/to a 07:* (1x/4h) - reliable
-            2. Use sensor temp matching - non-deterministic
+        # There are only 2 ways to to find a controller's DHW sensor:
+        # 1. The 10A0 RQ/RP *from/to a 07:* (1x/4h) - reliable
+        # 2. Use sensor temp matching - non-deterministic
 
-            Data from the CTL is considered more authorative. The RQ is initiated by the
-            DHW, so is not authorative. The I/1260 is not to/from a controller, so is
-            not useful.
-            """
+        # Data from the CTL is considered more authoritative. The RQ is initiated by the
+        # DHW, so is not authoritative. The I/1260 is not to/from a controller, so is
+        # not useful.
+        # """
 
-            # 10A0: RQ/07/01, RP/01/07: can get both parent controller & DHW sensor
-            # 047 RQ --- 07:030741 01:102458 --:------ 10A0 006 00181F0003E4
-            # 062 RP --- 01:102458 07:030741 --:------ 10A0 006 0018380003E8
+        # # 10A0: RQ/07/01, RP/01/07: can get both parent controller & DHW sensor
+        # # 047 RQ --- 07:030741 01:102458 --:------ 10A0 006 00181F0003E4
+        # # 062 RP --- 01:102458 07:030741 --:------ 10A0 006 0018380003E8
 
-            # 1260: I/07: can't get which parent controller - would need to match temps
-            # 045  I --- 07:045960 --:------ 07:045960 1260 003 000911
+        # # 1260: I/07: can't get which parent controller - would need to match temps
+        # # 045  I --- 07:045960 --:------ 07:045960 1260 003 000911
 
-            # 1F41: I/01: get parent controller, but not DHW sensor
-            # 045  I --- 01:145038 --:------ 01:145038 1F41 012 000004FFFFFF1E060E0507E4
-            # 045  I --- 01:145038 --:------ 01:145038 1F41 006 000002FFFFFF
+        # # 1F41: I/01: get parent controller, but not DHW sensor
+        # # 045  I --- 01:145038 --:------ 01:145038 1F41 012 000004FFFFFF1E060E0507E4
+        # # 045  I --- 01:145038 --:------ 01:145038 1F41 006 000002FFFFFF
 
-            assert self._gwy.config.enable_eavesdrop, "Coding error"
+        # assert self._gwy.config.enable_eavesdrop, "Coding error"
 
-            if all(
-                (
-                    this.code == Code._10A0,
-                    this.verb == RP,
-                    this.src is self.ctl,
-                    isinstance(this.dst, DhwSensor),
-                )
-            ):
-                self._get_dhw(sensor=this.dst)
+        # if all(
+        #     (
+        #         this.code == Code._10A0,
+        #         this.verb == RP,
+        #         this.src is self.ctl,
+        #         isinstance(this.dst, DhwSensor),
+        #     )
+        # ):
+        #     self._get_dhw(sensor=this.dst)
 
         assert (
             msg.src is self.ctl
@@ -280,7 +295,7 @@ class DhwZone(ZoneSchedule, ZoneBase):  # CS92A  # TODO: add Schedule
         # if self._gwy.config.enable_eavesdrop and not self.dhw_sensor:
         #     eavesdrop_dhw_sensor(msg)
 
-    def _update_schema(self, **schema):
+    def _update_schema(self, **schema: Any) -> None:
         """Update a DHW zone with new schema attrs.
 
         Raise an exception if the new schema is not a superset of the existing schema.
@@ -290,38 +305,44 @@ class DhwZone(ZoneSchedule, ZoneBase):  # CS92A  # TODO: add Schedule
         """Set the heating valve relay for this DHW zone (13: only)."""
         """Set the hotwater valve relay for this DHW zone (13: only).
 
-        Check and _VerbT the DHW sensor (07:) of this system/CTL (if there is one).
+        Check and ??? the DHW sensor (07:) of this system/CTL (if there is one).
 
         There is only 1 way to eavesdrop a controller's DHW sensor:
         1.  The 10A0 RQ/RP *from/to a 07:* (1x/4h)
 
-        The RQ is initiated by the DHW, so is not authorative (the CTL will RP any RQ).
+        The RQ is initiated by the DHW, so is not authoritative (the CTL will RP any RQ).
         The I/1260 is not to/from a controller, so is not useful.
-        """  # noqa: D402
+        """
 
         schema = shrink(SCH_TCS_DHW(schema))
 
         if dev_id := schema.get(SZ_SENSOR):
-            self._dhw_sensor = self._gwy.get_device(
+            dhw_sensor = self._gwy.get_device(
                 dev_id, parent=self, child_id=FA, is_sensor=True
             )
+            assert isinstance(dhw_sensor, DhwSensor)  # mypy
+            self._dhw_sensor = dhw_sensor
 
-        if dev_id := schema.get(DEV_ROLE_MAP[DEV_ROLE.HTG]):
-            self._dhw_valve = self._gwy.get_device(dev_id, parent=self, child_id=FA)
+        if dev_id := schema.get(DEV_ROLE_MAP[DevRole.HTG]):
+            dhw_valve = self._gwy.get_device(dev_id, parent=self, child_id=FA)
+            assert isinstance(dhw_valve, BdrSwitch)  # mypy
+            self._dhw_valve = dhw_valve
 
-        if dev_id := schema.get(DEV_ROLE_MAP[DEV_ROLE.HT1]):
-            self._htg_valve = self._gwy.get_device(dev_id, parent=self, child_id=F9)
+        if dev_id := schema.get(DEV_ROLE_MAP[DevRole.HT1]):
+            htg_valve = self._gwy.get_device(dev_id, parent=self, child_id=F9)
+            assert isinstance(htg_valve, BdrSwitch)  # mypy
+            self._htg_valve = htg_valve
 
     @property
-    def sensor(self) -> DhwSensor:  # self._dhw_sensor
+    def sensor(self) -> DhwSensor | None:  # self._dhw_sensor
         return self._dhw_sensor
 
     @property
-    def hotwater_valve(self) -> BdrSwitch:  # self._dhw_valve
+    def hotwater_valve(self) -> BdrSwitch | None:  # self._dhw_valve
         return self._dhw_valve
 
     @property
-    def heating_valve(self) -> BdrSwitch:  # self._htg_valve
+    def heating_valve(self) -> BdrSwitch | None:  # self._htg_valve
         return self._htg_valve
 
     @property
@@ -329,44 +350,50 @@ class DhwZone(ZoneSchedule, ZoneBase):  # CS92A  # TODO: add Schedule
         return "Stored HW"
 
     @property
-    def config(self) -> None | dict:  # 10A0
-        return self._msg_value(Code._10A0)
+    def config(self) -> dict[str, Any] | None:  # 10A0
+        return self._msg_value(Code._10A0)  # type: ignore[return-value]
 
     @property
-    def mode(self) -> None | dict:  # 1F41
-        return self._msg_value(Code._1F41)
+    def mode(self) -> dict[str, Any] | None:  # 1F41
+        return self._msg_value(Code._1F41)  # type: ignore[return-value]
 
     @property
-    def setpoint(self) -> None | float:  # 10A0
-        return self._msg_value(Code._10A0, key=SZ_SETPOINT)
+    def setpoint(self) -> float | None:  # 10A0
+        return self._msg_value(Code._10A0, key=SZ_SETPOINT)  # type: ignore[return-value]
 
-    @setpoint.setter
-    def setpoint(self, value) -> None:  # 10A0
+    @setpoint.setter  # TODO: can value be None?
+    def setpoint(self, value: float) -> None:  # 10A0
         self.set_config(setpoint=value)
 
     @property
-    def temperature(self) -> None | float:  # 1260
-        return self._msg_value(Code._1260, key=SZ_TEMPERATURE)
+    def temperature(self) -> float | None:  # 1260
+        return self._msg_value(Code._1260, key=SZ_TEMPERATURE)  # type: ignore[return-value]
 
     @property
-    def heat_demand(self) -> None | float:  # 3150
-        return self._msg_value(Code._3150, key=SZ_HEAT_DEMAND)
+    def heat_demand(self) -> float | None:  # 3150
+        return self._msg_value(Code._3150, key=SZ_HEAT_DEMAND)  # type: ignore[return-value]
 
     @property
-    def relay_demand(self) -> None | float:  # 0008
-        return self._msg_value(Code._0008, key=SZ_RELAY_DEMAND)
+    def relay_demand(self) -> float | None:  # 0008
+        return self._msg_value(Code._0008, key=SZ_RELAY_DEMAND)  # type: ignore[return-value]
 
     @property  # only seen with FC, but seems should pair with 0008?
-    def relay_failsafe(self) -> None | float:  # 0009
-        return self._msg_value(Code._0009, key=SZ_RELAY_FAILSAFE)
+    def relay_failsafe(self) -> float | None:  # 0009
+        return self._msg_value(Code._0009, key=SZ_RELAY_FAILSAFE)  # type: ignore[return-value]
 
-    def set_mode(self, *, mode=None, active=None, until=None) -> Future:
+    def set_mode(
+        self,
+        *,
+        mode: int | str | None = None,
+        active: bool | None = None,
+        until: dt | str | None = None,
+    ) -> asyncio.Task[Packet]:
         """Set the DHW mode (mode, active, until)."""
-        return self._send_cmd(
-            Command.set_dhw_mode(self.ctl.id, mode=mode, active=active, until=until)
-        )
 
-    def set_boost_mode(self) -> Future:
+        cmd = Command.set_dhw_mode(self.ctl.id, mode=mode, active=active, until=until)
+        return self._gwy.send_cmd(cmd, priority=Priority.HIGH, wait_for_reply=True)
+
+    def set_boost_mode(self) -> asyncio.Task[Packet]:
         """Enable DHW for an hour, despite any schedule."""
         return self.set_mode(
             mode=ZON_MODE_MAP.TEMPORARY,
@@ -374,12 +401,19 @@ class DhwZone(ZoneSchedule, ZoneBase):  # CS92A  # TODO: add Schedule
             until=dt.now() + td(hours=1),
         )
 
-    def reset_mode(self) -> Future:  # 1F41
+    def reset_mode(self) -> asyncio.Task[Packet]:  # 1F41
         """Revert the DHW to following its schedule."""
         return self.set_mode(mode=ZON_MODE_MAP.FOLLOW)
 
-    def set_config(self, *, setpoint=None, overrun=None, differential=None) -> Future:
+    def set_config(
+        self,
+        *,
+        setpoint: float | None = None,
+        overrun: int | None = None,
+        differential: float | None = None,
+    ) -> asyncio.Task[Packet]:
         """Set the DHW parameters (setpoint, overrun, differential)."""
+
         # dhw_params = self._msg_value(Code._10A0)
         # if setpoint is None:
         #     setpoint = dhw_params[SZ_SETPOINT]
@@ -388,16 +422,15 @@ class DhwZone(ZoneSchedule, ZoneBase):  # CS92A  # TODO: add Schedule
         # if differential is None:
         #     setpoint = dhw_params["differential"]
 
-        return self._send_cmd(
-            Command.set_dhw_params(
-                self.ctl.id,
-                setpoint=setpoint,
-                overrun=overrun,
-                differential=differential,
-            )
+        cmd = Command.set_dhw_params(
+            self.ctl.id,
+            setpoint=setpoint,
+            overrun=overrun,
+            differential=differential,
         )
+        return self._gwy.send_cmd(cmd, priority=Priority.HIGH)
 
-    def reset_config(self) -> Future:  # 10A0
+    def reset_config(self) -> asyncio.Task[Packet]:  # 10A0
         """Reset the DHW parameters to their default values."""
         return self.set_config(setpoint=50, overrun=5, differential=1)
 
@@ -421,13 +454,13 @@ class DhwZone(ZoneSchedule, ZoneBase):  # CS92A  # TODO: add Schedule
         return {a: getattr(self, a) for a in (SZ_TEMPERATURE, SZ_HEAT_DEMAND)}
 
 
-class Zone(ZoneSchedule, ZoneBase):
+class Zone(ZoneSchedule):
     """The Zone class for all zone types (but not DHW)."""
 
-    _SLUG: str = None  # type: ignore[assignment]
+    _SLUG: str = None
     _ROLE_ACTUATORS: str = DEV_ROLE_MAP.ACT
 
-    def __init__(self, tcs, zone_idx: str) -> None:
+    def __init__(self, tcs: _MultiZoneT, zone_idx: str) -> None:
         """Create a heating zone.
 
         The type of zone may not be known at instantiation. Even when it is known, zones
@@ -445,11 +478,11 @@ class Zone(ZoneSchedule, ZoneBase):
 
         super().__init__(tcs, zone_idx)
 
-        self._sensor = None  # schema attr
-        self.actuators = []  # schema attr
-        self.actuator_by_id = {}  # schema attr
+        self._sensor: Device | None = None
+        self.actuators: list[Device] = []
+        self.actuator_by_id: dict[DeviceIdT, Device] = {}
 
-    def _update_schema(self, *, append_actuators=True, **schema):
+    def _update_schema(self, **schema: Any) -> None:
         """Update a heating zone with new schema attrs.
 
         Raise an exception if the new schema is not a superset of the existing schema.
@@ -473,9 +506,9 @@ class Zone(ZoneSchedule, ZoneBase):
             if klass == self._SLUG:
                 return
 
-            if klass == ZON_ROLE.VAL and self._SLUG not in (
+            if klass == ZoneRole.VAL and self._SLUG not in (
                 None,
-                ZON_ROLE.ELE,
+                ZoneRole.ELE,
             ):
                 raise ValueError(f"Not a compatible zone class for {self}: {zone_type}")
 
@@ -483,15 +516,16 @@ class Zone(ZoneSchedule, ZoneBase):
                 raise ValueError(f"Not a known zone class (for {self}): {zone_type}")
 
             if self._SLUG is not None:
-                raise CorruptStateError(
+                raise exc.SystemSchemaInconsistent(
                     f"{self} changed zone class: from {self._SLUG} to {klass}"
                 )
 
             self.__class__ = ZONE_CLASS_BY_SLUG[klass]
             _LOGGER.debug("Promoted a Zone: %s (%s)", self.id, self.__class__)
 
-            # TODO: broken fixme
-            # self._gwy._loop.call_soon(self._setup_discovery_cmds)  # TODO: check this
+            self._setup_discovery_cmds()
+
+        dev_id: DeviceIdT
 
         # if schema.get(SZ_CLASS) == ZON_ROLE_MAP[ZON_ROLE.ACT]:
         #     schema.pop(SZ_CLASS)
@@ -510,11 +544,10 @@ class Zone(ZoneSchedule, ZoneBase):
         # super()._setup_discovery_cmds()
 
         for dev_role in (self._ROLE_ACTUATORS, DEV_ROLE_MAP.SEN):
-            self._add_discovery_cmd(
-                _mk_cmd(RQ, Code._000C, f"{self.idx}{dev_role}", self.ctl.id),
-                60 * 60 * 24,
-                delay=0.5,
+            cmd = Command.from_attrs(
+                RQ, self.ctl.id, Code._000C, f"{self.idx}{dev_role}"
             )
+            self._add_discovery_cmd(cmd, 60 * 60 * 24, delay=0.5)
 
         self._add_discovery_cmd(
             Command.get_zone_config(self.ctl.id, self.idx), 60 * 60 * 6, delay=30
@@ -534,26 +567,35 @@ class Zone(ZoneSchedule, ZoneBase):
         )  # longer dt as low yield (factory duration is 30 min): prefer eavesdropping
 
     def _add_discovery_cmd(
-        self, cmd, interval, *, delay: float = 0, timeout: float = None
-    ):
-        """Schedule a command to run periodically."""
+        self,
+        cmd: Command,
+        interval: float,
+        *,
+        delay: float = 0,
+        timeout: float | None = None,
+    ) -> None:
+        """Schedule a command to run periodically.
+
+        Both `timeout` and `delay` are in seconds.
+        """
         super()._add_discovery_cmd(cmd, interval, delay=delay, timeout=timeout)
 
         if cmd.code != Code._000C:  # or cmd._ctx == f"{self.idx}{ZON_ROLE_MAP.SEN}":
             return
 
         if [t for t in self._discovery_cmds if t[-2:] in ZON_ROLE_MAP.HEAT_ZONES] and (
-            self._discovery_cmds.pop(f"{self.idx}{ZON_ROLE_MAP.ACT}", None)
+            self._discovery_cmds.pop(f"{self.idx}{ZON_ROLE_MAP.ACT}", [])
         ):
             _LOGGER.warning(f"cmd({cmd}): inferior header removed from discovery")
 
-        if self._discovery_cmds.get(f"{self.idx}{ZON_ROLE_MAP.VAL}") and (
-            self._discovery_cmds[f"{self.idx}{ZON_ROLE_MAP.ELE}"]
+        if (
+            self._discovery_cmds.get(f"{self.idx}{ZON_ROLE_MAP.VAL}")
+            and (self._discovery_cmds[f"{self.idx}{ZON_ROLE_MAP.ELE}"])
         ):
             _LOGGER.warning(f"cmd({cmd}): inferior header removed from discovery")
 
     def _handle_msg(self, msg: Message) -> None:
-        def eavesdrop_zone_type(this, *, prev=None) -> None:
+        def eavesdrop_zone_type(this: Message, *, prev: Message | None = None) -> None:
             """TODO.
 
             There are three ways to determine the type of a zone:
@@ -565,30 +607,30 @@ class Zone(ZoneSchedule, ZoneBase):
             if this.code in (Code._0008, Code._0009):
                 assert self._SLUG in (
                     None,
-                    ZON_ROLE.ELE,
-                    ZON_ROLE.VAL,
-                    ZON_ROLE.MIX,
+                    ZoneRole.ELE,
+                    ZoneRole.VAL,
+                    ZoneRole.MIX,
                 ), self._SLUG
 
                 if self._SLUG is None:
                     # this might eventually be: ZON_ROLE.VAL
-                    self._update_schema(**{SZ_CLASS: ZON_ROLE_MAP[ZON_ROLE.ELE]})
+                    self._update_schema(**{SZ_CLASS: ZON_ROLE_MAP[ZoneRole.ELE]})
 
             elif this.code == Code._3150:  # TODO: and this.verb in (I_, RP)?
                 # MIX/ELE don't 3150
                 assert self._SLUG in (
                     None,
-                    ZON_ROLE.RAD,
-                    ZON_ROLE.UFH,
-                    ZON_ROLE.VAL,
+                    ZoneRole.RAD,
+                    ZoneRole.UFH,
+                    ZoneRole.VAL,
                 ), self._SLUG
 
                 if isinstance(this.src, TrvActuator):
-                    self._update_schema(**{SZ_CLASS: ZON_ROLE_MAP[ZON_ROLE.RAD]})
+                    self._update_schema(**{SZ_CLASS: ZON_ROLE_MAP[ZoneRole.RAD]})
                 elif isinstance(this.src, BdrSwitch):
-                    self._update_schema(**{SZ_CLASS: ZON_ROLE_MAP[ZON_ROLE.VAL]})
+                    self._update_schema(**{SZ_CLASS: ZON_ROLE_MAP[ZoneRole.VAL]})
                 elif isinstance(this.src, UfhController):
-                    self._update_schema(**{SZ_CLASS: ZON_ROLE_MAP[ZON_ROLE.UFH]})
+                    self._update_schema(**{SZ_CLASS: ZON_ROLE_MAP[ZoneRole.UFH]})
 
             assert (
                 msg.src is self.ctl or msg.src.type == DEV_TYPE_MAP.UFC
@@ -625,64 +667,76 @@ class Zone(ZoneSchedule, ZoneBase):
                 )
 
             # TODO: testing this concept, hoping to learn device_id of UFC
-            if msg.payload[SZ_ZONE_TYPE] == DEV_ROLE_MAP.UFH:
-                self._make_cmd(Code._000C, payload=f"{self.idx}{DEV_ROLE_MAP.UFH}")
+            # if msg.payload[SZ_ZONE_TYPE] == DEV_ROLE_MAP.UFH:
+            #     cmd = Command.from_attrs(
+            #         RQ, self.ctl.id, Code._000C, f"{self.idx}{DEV_ROLE_MAP.UFH}"
+            #     )
+            #     self._send_cmd(cmd)
 
         # If zone still doesn't have a zone class, maybe eavesdrop?
         if self._gwy.config.enable_eavesdrop and self._SLUG in (
             None,
-            ZON_ROLE.ELE,
+            ZoneRole.ELE,
         ):
             eavesdrop_zone_type(msg)
 
-    def _msg_value(self, *args, **kwargs):
+    def _msg_value(self, *args: Any, **kwargs: Any) -> Any:
         return super()._msg_value(*args, **kwargs, zone_idx=self.idx)
 
     @property
-    def sensor(self) -> None | Device:
+    def sensor(self) -> Device | None:
         return self._sensor
 
     @property
-    def heating_type(self) -> None | str:
-        if self._SLUG is not None:  # isinstance(self, ???)
-            return ZON_ROLE_MAP[self._SLUG]
+    def heating_type(self) -> str | None:
+        """Return the type of the zone/DHW (e.g. electric_zone, stored_dhw)."""
+
+        if self._SLUG is None:  # isinstance(self, ???)
+            return None
+        return ZON_ROLE_MAP[self._SLUG]  # type: ignore[no-any-return]
 
     @property
-    def name(self) -> None | str:  # 0004
+    def name(self) -> str | None:  # 0004
         """Return the name of the zone."""
-        return self._msg_value(Code._0004, key=SZ_NAME)
+
+        if self._gwy._zzz:
+            msgs = self._gwy._zzz.get(code=Code._0004, src=self._z_id, ctx=self._z_idx)
+            return msgs[0].payload.get(SZ_NAME) if msgs else None
+
+        return self._msg_value(Code._0004, key=SZ_NAME)  # type: ignore[no-any-return]
 
     @name.setter
-    def name(self, value) -> None:
-        """Set the name of the zone."""
-        self._send_cmd(Command.set_zone_name(self.ctl.id, self.idx, value))
+    def name(self, value: str) -> None:
+        raise NotImplementedError("The setter has been deprecated, use: .set_name()")
 
     @property
-    def config(self) -> None | dict:  # 000A
-        return self._msg_value(Code._000A)
+    def config(self) -> dict[str, Any] | None:  # 000A
+        return self._msg_value(Code._000A)  # type: ignore[no-any-return]
 
     @property
-    def mode(self) -> None | dict:  # 2349
-        return self._msg_value(Code._2349)
+    def mode(self) -> dict[str, Any] | None:  # 2349
+        return self._msg_value(Code._2349)  # type: ignore[no-any-return]
 
     @property
-    def setpoint(self) -> None | float:  # 2309 (2349 is a superset of 2309)
-        return self._msg_value((Code._2309, Code._2349), key=SZ_SETPOINT)
+    def setpoint(self) -> float | None:  # 2309 (2349 is a superset of 2309)
+        return self._msg_value((Code._2309, Code._2349), key=SZ_SETPOINT)  # type: ignore[no-any-return]
 
-    @setpoint.setter
-    def setpoint(self, value) -> None:  # 000A/2309
+    @setpoint.setter  # TODO: can value be None?
+    def setpoint(self, value: float) -> None:  # 000A/2309
         """Set the target temperature, until the next scheduled setpoint."""
+
         if value is None:
-            self.reset_mode()
-        else:
-            self._send_cmd(Command.set_zone_setpoint(self.ctl.id, self.idx, value))
+            return 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) -> None | float:  # 30C9
-        return self._msg_value(Code._30C9, key=SZ_TEMPERATURE)
+    def temperature(self) -> float | None:  # 30C9
+        return self._msg_value(Code._30C9, key=SZ_TEMPERATURE)  # type: ignore[no-any-return]
 
     @property
-    def heat_demand(self) -> None | float:  # 3150
+    def heat_demand(self) -> float | None:  # 3150
         """Return the zone's heat demand, estimated from its devices' heat demand."""
         demands = [
             d.heat_demand
@@ -692,28 +746,29 @@ class Zone(ZoneSchedule, ZoneBase):
         return _transform(max(demands + [0])) if demands else None
 
     @property
-    def window_open(self) -> None | bool:  # 12B0
+    def window_open(self) -> bool | None:  # 12B0
         """Return an estimate of the zone's current window_open state."""
-        return self._msg_value(Code._12B0, key=SZ_WINDOW_OPEN)
+        return self._msg_value(Code._12B0, key=SZ_WINDOW_OPEN)  # type: ignore[no-any-return]
 
-    def _get_temp(self) -> Future:
+    def _get_temp(self) -> asyncio.Task[Packet] | None:
         """Get the zone's latest temp from the Controller."""
         return self._send_cmd(Command.get_zone_temp(self.ctl.id, self.idx))
 
-    def reset_config(self) -> Future:  # 000A
+    def reset_config(self) -> asyncio.Task[Packet]:  # 000A
         """Reset the zone's parameters to their default values."""
         return self.set_config()
 
     def set_config(
         self,
         *,
-        min_temp=5,
-        max_temp=35,
+        min_temp: float = 5,
+        max_temp: float = 35,
         local_override: bool = False,
         openwindow_function: bool = False,
         multiroom_mode: bool = False,
-    ) -> Future:
+    ) -> asyncio.Task[Packet]:
         """Set the zone's parameters (min_temp, max_temp, etc.)."""
+
         cmd = Command.set_zone_config(
             self.ctl.id,
             self.idx,
@@ -723,29 +778,41 @@ class Zone(ZoneSchedule, ZoneBase):
             openwindow_function=openwindow_function,
             multiroom_mode=multiroom_mode,
         )
-        return self._send_cmd(cmd)
+        return self._gwy.send_cmd(cmd, priority=Priority.HIGH)
 
-    def reset_mode(self) -> Future:  # 2349
+    def reset_mode(self) -> asyncio.Task[Packet]:  # 2349
         """Revert the zone to following its schedule."""
         return self.set_mode(mode=ZON_MODE_MAP.FOLLOW)
 
-    def set_frost_mode(self) -> Future:  # 2349
+    def set_frost_mode(self) -> asyncio.Task[Packet]:  # 2349
         """Set the zone to the lowest possible setpoint, indefinitely."""
         return self.set_mode(mode=ZON_MODE_MAP.PERMANENT, setpoint=5)  # TODO
 
-    def set_mode(self, *, mode=None, setpoint=None, until=None) -> Future:  # 2309/2349
+    def set_mode(
+        self,
+        *,
+        mode: str | None = None,
+        setpoint: float | None = None,
+        until: dt | str | None = None,
+    ) -> asyncio.Task[Packet]:  # 2309/2349
         """Override the zone's setpoint for a specified duration, or indefinitely."""
-        if mode is None and until is None:  # Hometronics doesn't support 2349
-            cmd = Command.set_zone_setpoint(self.ctl.id, self.idx, setpoint)
-        else:
+
+        if mode is not None or until is not None:  # Hometronics doesn't support 2349
             cmd = Command.set_zone_mode(
                 self.ctl.id, self.idx, mode=mode, setpoint=setpoint, until=until
             )
-        return self._send_cmd(cmd)
+        elif setpoint is not None:  # unsure if Hometronics supports setpoint of None
+            cmd = Command.set_zone_setpoint(self.ctl.id, self.idx, setpoint)
+        else:
+            raise ValueError("Invalid mode/setpoint")
+
+        return self._gwy.send_cmd(cmd, priority=Priority.HIGH)
 
-    def set_name(self, name) -> Future:
+    def set_name(self, name: str) -> asyncio.Task[Packet]:
         """Set the zone's name."""
-        return self._send_cmd(Command.set_zone_name(self.ctl.id, self.idx, name))
+
+        cmd = Command.set_zone_name(self.ctl.id, self.idx, name)
+        return self._gwy.send_cmd(cmd, priority=Priority.HIGH)
 
     @property
     def schema(self) -> dict[str, Any]:
@@ -776,7 +843,7 @@ class EleZone(Zone):  # BDR91A/T  # TODO: 0008/0009/3150
 
     # def __init__(self,...  # NOTE: since zones are promotable, we can't use this here
 
-    _SLUG: str = ZON_ROLE.ELE
+    _SLUG: str = ZoneRole.ELE
     _ROLE_ACTUATORS: str = DEV_ROLE_MAP.ELE
 
     def _handle_msg(self, msg: Message) -> None:
@@ -790,15 +857,13 @@ class EleZone(Zone):  # BDR91A/T  # TODO: 0008/0009/3150
             raise TypeError("WHAT 2")
 
     @property
-    def heat_demand(self) -> None | float:
+    def heat_demand(self) -> float | None:
         """Return 0 as the zone's heat demand, as electric zones don't call for heat."""
         return 0
 
     @property
-    def relay_demand(self) -> None | float:  # 0008 (NOTE: CTLs wont RP|0008)
-        # if Code._0008 in self._msgs:
-        #     return self._msgs[Code._0008].payload[SZ_RELAY_DEMAND]
-        return self._msg_value(Code._0008, key=SZ_RELAY_DEMAND)
+    def relay_demand(self) -> float | None:  # 0008 (NOTE: CTLs won't RP|0008)
+        return self._msg_value(Code._0008, key=SZ_RELAY_DEMAND)  # type: ignore[no-any-return]
 
     @property
     def status(self) -> dict[str, Any]:
@@ -816,7 +881,7 @@ class MixZone(Zone):  # HM80  # TODO: 0008/0009/3150
 
     # def __init__(self,...  # NOTE: since zones are promotable, we can't use this here
 
-    _SLUG: str = ZON_ROLE.MIX
+    _SLUG: str = ZoneRole.MIX
     _ROLE_ACTUATORS: str = DEV_ROLE_MAP.MIX
 
     def _setup_discovery_cmds(self) -> None:
@@ -827,8 +892,8 @@ class MixZone(Zone):  # HM80  # TODO: 0008/0009/3150
         )
 
     @property
-    def mix_config(self) -> dict:  # 1030
-        return self._msg_value(Code._1030)
+    def mix_config(self) -> PayDictT._1030:
+        return self._msg_value(Code._1030)  # type: ignore[no-any-return]
 
     @property
     def params(self) -> dict[str, Any]:
@@ -843,7 +908,7 @@ class RadZone(Zone):  # HR92/HR80
 
     # def __init__(self,...  # NOTE: since zones are promotable, we can't use this here
 
-    _SLUG: str = ZON_ROLE.RAD
+    _SLUG: str = ZoneRole.RAD
     _ROLE_ACTUATORS: str = DEV_ROLE_MAP.RAD
 
 
@@ -852,11 +917,11 @@ class UfhZone(Zone):  # HCC80/HCE80  # TODO: needs checking
 
     # def __init__(self,...  # NOTE: since zones are promotable, we can't use this here
 
-    _SLUG: str = ZON_ROLE.UFH
+    _SLUG: str = ZoneRole.UFH
     _ROLE_ACTUATORS: str = DEV_ROLE_MAP.UFH
 
     @property
-    def heat_demand(self) -> None | float:  # 3150
+    def heat_demand(self) -> float | None:  # 3150
         """Return the zone's heat demand, estimated from its devices' heat demand."""
         if (demand := self._msg_value(Code._3150, key=SZ_HEAT_DEMAND)) is not None:
             return _transform(demand)
@@ -868,11 +933,11 @@ class ValZone(EleZone):  # BDR91A/T
 
     # def __init__(self,...  # NOTE: since zones are promotable, we can't use this here
 
-    _SLUG: str = ZON_ROLE.VAL
+    _SLUG: str = ZoneRole.VAL
     _ROLE_ACTUATORS: str = DEV_ROLE_MAP.VAL
 
     @property
-    def heat_demand(self) -> None | float:  # 0008 (NOTE: not 3150)
+    def heat_demand(self) -> float | None:  # 0008 (NOTE: not 3150)
         """Return the zone's heat demand, using relay demand as a proxy."""
         return self.relay_demand
 
@@ -887,10 +952,19 @@ def _transform(valve_pos: float) -> float:
     return math.floor((valve_pos - t1) * t1 / (t2 - t1) + t0 + 0.5) / 100
 
 
-ZONE_CLASS_BY_SLUG = class_by_attr(__name__, "_SLUG")  # ZON_ROLE.RAD: RadZone
+# e.g. {"RAD": RadZone}
+ZONE_CLASS_BY_SLUG: dict[str, type[DhwZone] | type[Zone]] = class_by_attr(
+    __name__, "_SLUG"
+)
 
 
-def zone_factory(tcs, idx: str, *, msg: Message = None, **schema) -> _ZoneT:
+def zone_factory(
+    tcs: _StoredHwT | _MultiZoneT,
+    idx: str,
+    *,
+    msg: Message | None = None,
+    **schema: Any,
+) -> DhwZone | Zone:
     """Return the zone class for a given zone_idx/klass (Zone or DhwZone).
 
     Some zones are promotable to a compatible sub class (e.g. ELE->VAL).
@@ -900,15 +974,15 @@ def zone_factory(tcs, idx: str, *, msg: Message = None, **schema) -> _ZoneT:
         ctl_addr: Address,
         idx: str,
         *,
-        msg: Message = None,
+        msg: Message | None = None,
         eavesdrop: bool = False,
-        **schema,
-    ) -> type[_ZoneT]:
+        **schema: Any,
+    ) -> type[DhwZone] | type[Zone]:
         """Return the initial zone class for a given zone_idx/klass (Zone or DhwZone)."""
 
         # NOTE: for now, zones are always promoted after instantiation
 
-        # # a specified zone class always takes precidence (even if it is wrong)...
+        # # a specified zone class always takes precedence (even if it is wrong)...
         # if cls := ZONE_CLASS_BY_SLUG.get(schema.get(SZ_CLASS)):
         #     _LOGGER.debug(
         #         f"Using an explicitly-defined zone class for: {ctl_addr}_{idx} ({cls})"
@@ -937,10 +1011,16 @@ def zone_factory(tcs, idx: str, *, msg: Message = None, **schema) -> _ZoneT:
         )
         return Zone
 
-    return best_zon_class(
+    zon: DhwZone | Zone = best_zon_class(  # type: ignore[type-var]
         tcs.ctl.addr,
         idx,
         msg=msg,
         eavesdrop=tcs._gwy.config.enable_eavesdrop,
         **schema,
     ).create_from_schema(tcs, idx, **schema)
+
+    # assert isinstance(zon, DhwZone | Zone)  # mypy
+    return zon
+
+
+_ZoneT = TypeVar("_ZoneT", bound="ZoneBase")