aioWiserHeatAPI 1.5.19__tar.gz → 1.6.0__tar.gz

{aiowiserheatapi-1.5.19 → aiowiserheatapi-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aioWiserHeatAPI
-Version: 1.5.19
+Version: 1.6.0
 Summary: An AsyncIO API for controlling the Drayton Wiser Heating system
 Home-page: https://github.com/msp1974/aioWiserHeatAPI
 Author: Mark Parker
@@ -18,7 +18,7 @@ Requires-Dist: aiohttp>=3.9.3
 Requires-Dist: aiofiles>=23.2.1
 Requires-Dist: pyyaml>=6.0.1
 
-# Drayton Wiser Hub API Async v1.5.19
+# Drayton Wiser Hub API Async v1.6.0
 
 This repository contains a simple API which queries the Drayton Wiser Heating sysystem used in the UK.
 
@@ -72,6 +72,16 @@ Documentation available in [info.md](https://github.com/msp1974/wiserHeatAPIv2/b
 
 ## Changelog
 
+### v1.6.0
+* Refactored how devices are enumerated
+* BREAKING CHANGE - threshold sensor is now a device attribute and not its own device
+* Added: support for 2 gang light switches
+* Added: support for threshold and UI configuration as device attributes
+* Added: support for PTC devices
+* Added: UUID now exists for all devices (for future use)
+* Added: New attributes and stored extra config for Hot Water to support HW Climate automation in HA integration
+* Added: Control of interacts with room climate for binary sensors
+
 ### v1.5.19
 * Fixed error when BoilerInterface does not provide DeviceId field
 * Fixed not supporting non ascii characters in schedule names

{aiowiserheatapi-1.5.19 → aiowiserheatapi-1.6.0}/README.md

@@ -1,4 +1,4 @@
-# Drayton Wiser Hub API Async v1.5.19
+# Drayton Wiser Hub API Async v1.6.0
 
 This repository contains a simple API which queries the Drayton Wiser Heating sysystem used in the UK.
 
@@ -52,6 +52,16 @@ Documentation available in [info.md](https://github.com/msp1974/wiserHeatAPIv2/b
 
 ## Changelog
 
+### v1.6.0
+* Refactored how devices are enumerated
+* BREAKING CHANGE - threshold sensor is now a device attribute and not its own device
+* Added: support for 2 gang light switches
+* Added: support for threshold and UI configuration as device attributes
+* Added: support for PTC devices
+* Added: UUID now exists for all devices (for future use)
+* Added: New attributes and stored extra config for Hot Water to support HW Climate automation in HA integration
+* Added: Control of interacts with room climate for binary sensors
+
 ### v1.5.19
 * Fixed error when BoilerInterface does not provide DeviceId field
 * Fixed not supporting non ascii characters in schedule names

{aiowiserheatapi-1.5.19 → aiowiserheatapi-1.6.0}/aioWiserHeatAPI/__init__.py

@@ -3,6 +3,6 @@ import logging
 name = "aioWiserHeatAPI"
 __all__ = ["wiserAPI", "wiserDiscovery"]
 
-__VERSION__ = "1.5.19"
+__VERSION__ = "1.6.0"
 
 _LOGGER = logging.getLogger(__name__)

{aiowiserheatapi-1.5.19 → aiowiserheatapi-1.6.0}/aioWiserHeatAPI/binary_sensor.py

@@ -2,13 +2,43 @@
 Handles binary_sensor devices
 """
 
+import inspect
+
+from aioWiserHeatAPI import _LOGGER
+
 from .helpers.battery import _WiserBattery
 from .helpers.device import _WiserDevice
+from .helpers.threshold import _WiserThresholdSensor
 
 
 class _WiserBinarySensor(_WiserDevice):
     """Class representing a Wiser Binary Sensor"""
 
+    def __init__(self, *args):
+        """Initialise."""
+        super().__init__(*args)
+        self._threshold_sensors: list[_WiserThresholdSensor] = []
+
+    async def _send_command(self, cmd: dict):
+        """
+        Send control command to the Threshold sensor
+        param cmd: json command structure
+        return: boolen - true = success, false = failed
+        """
+        result = await self._wiser_rest_controller._send_command(
+            self._endpoint.format(self.device_type_id), cmd
+        )
+        if result:
+            self._device_type_data = result
+        if result:
+            _LOGGER.debug(
+                "Wiser light - {} command successful".format(
+                    inspect.stack()[1].function
+                )
+            )
+            return True
+        return False
+
     @property
     def active(self) -> bool:
         """Get if is active"""
@@ -19,6 +49,11 @@ class _WiserBinarySensor(_WiserDevice):
         """Get the if interacts with room climate"""
         return self._device_type_data.get("InteractsWithRoomClimate")
 
+    async def set_interacts_with_room_climate(self, enabled: bool):
+        if await self._send_command({"InteractsWithRoomClimate": str(enabled).lower()}):
+            self._interacts_with_room_climate = enabled
+            return True
+
     @property
     def type(self) -> str:
         """Get the type of device"""
@@ -34,6 +69,11 @@ class _WiserBinarySensor(_WiserDevice):
         """Get the battery information for the smokealarm"""
         return _WiserBattery(self._data)
 
+    @property
+    def threshold_sensors(self) -> list[_WiserThresholdSensor]:
+        """Get threshold sensors."""
+        return self._threshold_sensors
+
 
 class _WiserWindowDoorSensor(_WiserBinarySensor):
     """Class representing a Wiser WindowDoor Sensor"""

{aiowiserheatapi-1.5.19 → aiowiserheatapi-1.6.0}/aioWiserHeatAPI/const.py

@@ -101,11 +101,14 @@ WISERHEATINGACTUATOR = "HeatingActuator/{}"
 WISERUFHCONTROLLER = "UnderFloorHeating/{}"
 WISERSHUTTER = "Shutter/{}"
 WISERLIGHT = "Light/{}"
+WISERPOWERTAGCONTROL = "PTC/{}"
 WISERPOWERTAGENERGY = "PTE/{}"
 WISERSMOKEALARM = "SmokeAlarmDevice/{}"
 WISERBINARYSENSOR = "BinarySensor/{}"
 WISERBOILERINTERFACE = "BoilerInterface/{}"
 WISERBUTTONPANEL = "ButtonPanel/{}"
+WISERTHRESHOLDSENSOR = "ThresholdSensor/{}"
+WISERUICONFIGURATION = "UIConfiguration/{}"
 
 
 # Enums

{aiowiserheatapi-1.5.19 → aiowiserheatapi-1.6.0}/aioWiserHeatAPI/devices.py

@@ -3,28 +3,41 @@ Module to manage all devices
 """
 
 import enum
+from dataclasses import dataclass
+from typing import Any
 
-from .binary_sensor import _WiserBinarySensorCollection, _WiserWindowDoorSensor
+from .binary_sensor import (
+    _WiserBinarySensor,
+    _WiserBinarySensorCollection,
+    _WiserWindowDoorSensor,
+)
 from .boiler_interface import _WiserBoilerInterface, _WiserBoilerInterfaceCollection
 from .button_panel import _WiserButtonPanel, _WiserButtonPanelCollection
 from .const import (
-    TEXT_UNKNOWN,
     WISERBINARYSENSOR,
     WISERBOILERINTERFACE,
     WISERBUTTONPANEL,
     WISERHEATINGACTUATOR,
     WISERLIGHT,
+    WISERPOWERTAGCONTROL,
     WISERPOWERTAGENERGY,
     WISERROOMSTAT,
     WISERSHUTTER,
     WISERSMARTPLUG,
     WISERSMARTVALVE,
     WISERSMOKEALARM,
+    WISERTHRESHOLDSENSOR,
     WISERUFHCONTROLLER,
+    WISERUICONFIGURATION,
 )
 from .heating_actuator import _WiserHeatingActuator, _WiserHeatingActuatorCollection
 from .helpers.device import _WiserDevice
+from .helpers.threshold import (
+    _WiserThresholdSensor,
+)
+from .helpers.uiconfiguration import _WiserUIConfigSensor
 from .light import _WiserDimmableLight, _WiserLight, _WiserLightCollection
+from .ptc import _WiserPowerTagControl, _WiserPowerTagControlCollection
 from .pte import _WiserPowerTagEnergy, _WiserPowerTagEnergyCollection
 from .rest_controller import _WiserRestController
 from .roomstat import _WiserRoomStat, _WiserRoomStatCollection
@@ -36,6 +49,116 @@ from .smokealarm import _WiserSmokeAlarm, _WiserSmokeAlarmCollection
 from .ufh import _WiserUFHController, _WiserUFHControllerCollection
 
 
+@dataclass(frozen=True, kw_only=True)
+class DeviceConfig:
+    device_class: Any
+    collection: Any
+    endpoint: str = None
+    heating: bool = False
+    schedule_type: WiserScheduleTypeEnum | None = None
+    has_v2_equipment: bool = False
+
+
+@dataclass(frozen=True, kw_only=True)
+class AncillaryDeviceConfig:
+    device_class: Any
+    attribute: str
+    endpoint: str = None
+
+
+PRODUCT_TYPE_CONFIG = {
+    "SmartValve": DeviceConfig(
+        device_class=_WiserSmartValve,
+        collection=_WiserSmartValveCollection,
+        endpoint=WISERSMARTVALVE,
+        heating=True,
+    ),
+    "RoomStat": DeviceConfig(
+        device_class=_WiserRoomStat,
+        collection=_WiserRoomStatCollection,
+        endpoint=WISERROOMSTAT,
+        heating=True,
+    ),
+    "SmartPlug": DeviceConfig(
+        device_class=_WiserSmartPlug,
+        collection=_WiserSmartPlugCollection,
+        endpoint=WISERSMARTPLUG,
+        schedule_type=WiserScheduleTypeEnum.onoff,
+        has_v2_equipment=True,
+    ),
+    "HeatingActuator": DeviceConfig(
+        device_class=_WiserHeatingActuator,
+        collection=_WiserHeatingActuatorCollection,
+        endpoint=WISERHEATINGACTUATOR,
+        heating=True,
+        has_v2_equipment=True,
+    ),
+    "UnderFloorHeating": DeviceConfig(
+        device_class=_WiserUFHController,
+        collection=_WiserUFHControllerCollection,
+        endpoint=WISERUFHCONTROLLER,
+        heating=True,
+    ),
+    "Light": DeviceConfig(
+        device_class=_WiserLight,
+        collection=_WiserLightCollection,
+        endpoint=WISERLIGHT,
+        schedule_type=WiserScheduleTypeEnum.level,
+    ),
+    "Shutter": DeviceConfig(
+        device_class=_WiserShutter,
+        collection=_WiserShutterCollection,
+        endpoint=WISERSHUTTER,
+        schedule_type=WiserScheduleTypeEnum.level,
+    ),
+    "PTC": DeviceConfig(
+        device_class=_WiserPowerTagControl,
+        collection=_WiserPowerTagControlCollection,
+        endpoint=WISERPOWERTAGCONTROL,
+        has_v2_equipment=True,
+    ),
+    "PTE": DeviceConfig(
+        device_class=_WiserPowerTagEnergy,
+        collection=_WiserPowerTagEnergyCollection,
+        endpoint=WISERPOWERTAGENERGY,
+        has_v2_equipment=True,
+    ),
+    "SmokeAlarmDevice": DeviceConfig(
+        device_class=_WiserSmokeAlarm,
+        collection=_WiserSmokeAlarmCollection,
+        endpoint=WISERSMOKEALARM,
+    ),
+    "BinarySensor": DeviceConfig(
+        device_class=_WiserBinarySensor,
+        collection=_WiserBinarySensorCollection,
+        endpoint=WISERBINARYSENSOR,
+    ),
+    "BoilerInterface": DeviceConfig(
+        device_class=_WiserBoilerInterface,
+        collection=_WiserBoilerInterfaceCollection,
+        endpoint=WISERBOILERINTERFACE,
+    ),
+    "ButtonPanel": DeviceConfig(
+        device_class=_WiserButtonPanel,
+        collection=_WiserButtonPanelCollection,
+        endpoint=WISERBUTTONPANEL,
+    ),
+}
+
+ANCILLARY_SENSOR_CONFIG = {
+    "ThresholdSensor": AncillaryDeviceConfig(
+        device_class=_WiserThresholdSensor,
+        attribute="_threshold_sensors",
+        endpoint=WISERTHRESHOLDSENSOR,
+    ),
+    "UIConfiguration": AncillaryDeviceConfig(
+        device_class=_WiserUIConfigSensor,
+        attribute="_uiconfig_sensors",
+        endpoint=WISERUICONFIGURATION,
+    ),
+}
+
+
 class _WiserDeviceTypeEnum(enum.Enum):
     iTRV = "SmartValve"
     RoomStat = "RoomStat"
@@ -53,7 +176,7 @@ class _WiserDeviceTypeEnum(enum.Enum):
     ButtonPanel = "ButtonPanel"
 
 
-PRODUCT_TYPE_CONFIG = {
+PRODUCT_TYPE_CONFIG_OLD = {
     "iTRV": {
         "class": _WiserSmartValve,
         "collection": _WiserSmartValveCollection,
@@ -167,79 +290,86 @@ class _WiserDeviceCollection:
         ]
         return equipment_data[0] if equipment_data else None
 
-    def _build(self):
-        """Build collection of devices by type"""
-
-        # Instantiate collection classes
-        for device_type in _WiserDeviceTypeEnum:
-            if (
-                device_type.value not in self._device_collection
-                and device_type.name in PRODUCT_TYPE_CONFIG
-            ):
-                self._device_collection[device_type.value] = PRODUCT_TYPE_CONFIG[
-                    device_type.name
-                ].get("collection")()
-
-        # Iterate device data for all known device types
-        if self._device_data:
-            for device in self._device_data:
-                device_type = device.get("ProductType", TEXT_UNKNOWN)
-                if device_type in PRODUCT_TYPE_CONFIG:
-                    device_config = PRODUCT_TYPE_CONFIG[device_type]
-                    device_info = [
-                        device_info
-                        for device_info in self._domain_data.get(
-                            _WiserDeviceTypeEnum[device_type].value
-                        )
-                        if device_info.get("DeviceId", device_info.get("id"))
-                        == device.get("id")
-                    ]
+    def _get_device_info_by_id(self, device_id: int) -> dict[str, Any] | None:
+        """Get device entry by id."""
+        for device in self._domain_data.get("Device"):
+            if device.get("id") == device_id:
+                return device
+        return None
 
-                    # Safety net to prevent error if device info not found
-                    if not device_info:
-                        continue
+    def _build(self):
+        """Updated builf collection of devices.
 
+        Starts with device type key first and then gets matching device data
+        """
+        # TODO - limit checks based on DeviceCapabilityMatrix
+        for device_type in PRODUCT_TYPE_CONFIG:
+            # If not yet in the collection, add empty collection to device collections.
+            if device_type not in self._device_collection:
+                self._device_collection[device_type] = PRODUCT_TYPE_CONFIG[
+                    device_type
+                ].collection()
+
+            if device_type_data := self._domain_data.get(device_type):
+                # We have this device type in data
+                device_config = PRODUCT_TYPE_CONFIG[device_type]
+
+                # Now build collection of devices
+                for device in device_type_data:
                     # Get class to create and collection to append for device
-                    device_class = PRODUCT_TYPE_CONFIG[device_type].get("class")
+                    device_class = device_config.device_class
+
+                    # TODO: Fix this so not fudged
+                    if device_type == "Light" and device.get("IsDimmable"):
+                        device_class = _WiserDimmableLight
+
+                    # Device info id can be DeviceId or id depending on device type
+                    device_info_id = device.get("DeviceId", device.get("id"))
+
+                    # Get device info data
+                    device_info_data = self._get_device_info_by_id(device_info_id)
 
                     # If heating device add room id
-                    if device_config.get("heating"):
-                        if not device.get("RoomId"):
-                            device_info[0]["RoomId"] = self._get_temp_device_room_id(
-                                self._domain_data, device.get("id")
+                    if device_config.heating:
+                        if not device.get("RoomId", device_info_data.get("RoomId")):
+                            device["RoomId"] = self._get_temp_device_room_id(
+                                self._domain_data, device_info_id
                             )
 
                     # If schedule device add schedule
-                    if device_config.get("schedule_type"):
-                        device_schedule = [
-                            schedule
-                            for schedule in self._schedules.get_by_type(
-                                device_config.get("schedule_type")
-                            )
-                            if schedule.id == device_info[0].get("ScheduleId")
-                        ]
+                    if device_config.schedule_type:
+                        device_schedule = self._schedules.get_by_id(
+                            device_config.schedule_type, device.get("ScheduleId")
+                        )
                     else:
                         device_schedule = None
 
-                    # If has equipment entry, add equipment to device info data
-                    if device_config.get("has_v2_equipment"):
-                        device_info[0]["EquipmentData"] = self._get_equipment_data(
-                            device_info[0].get("EquipmentId")
-                        )
-
                     # Add device to collection
-                    self._device_collection[
-                        _WiserDeviceTypeEnum[device_type].value
-                    ]._items.append(
+                    self._device_collection[device_type]._items.append(
                         device_class(
                             self._wiser_rest_controller,
-                            device_config.get("endpoint"),
+                            device_config.endpoint,
+                            device_info_data,
                             device,
-                            device_info[0],
-                            device_schedule[0] if device_schedule else None,
+                            device_schedule,
                         )
                     )
 
+        # Add ancillary sensors to device
+        for anc_device_type, anc_device_type_info in ANCILLARY_SENSOR_CONFIG.items():
+            if anc_device_type_data := self._domain_data.get(anc_device_type):
+                for anc_device in anc_device_type_data:
+                    device_id = anc_device.get("DeviceId", anc_device.get("id"))
+                    if device := self.get_by_id(device_id):
+                        if hasattr(device, anc_device_type_info.attribute):
+                            getattr(device, anc_device_type_info.attribute).append(
+                                anc_device_type_info.device_class(
+                                    self._wiser_rest_controller,
+                                    anc_device_type_info.endpoint,
+                                    anc_device,
+                                )
+                            )
+
     def _get_temp_device_room_id(self, domain_data: dict, device_id: int) -> int:
         rooms = domain_data.get("Room")
         for room in rooms:
@@ -268,52 +398,90 @@ class _WiserDeviceCollection:
     @property
     def heating_actuators(self) -> _WiserHeatingActuatorCollection:
         """Return all heating actuators"""
-        return self._device_collection["HeatingActuator"]
+        try:
+            return self._device_collection["HeatingActuator"]
+        except KeyError:
+            return None
 
     @property
     def lights(self) -> _WiserLightCollection:
         """Return all lights"""
-        return self._device_collection["Light"]
+        try:
+            return self._device_collection["Light"]
+        except KeyError:
+            return None
+
+    @property
+    def power_tags_c(self) -> _WiserPowerTagControlCollection:
+        """Return all power tag Cs"""
+        try:
+            return self._device_collection["PTC"]
+        except KeyError:
+            return None
 
     @property
     def power_tags(self) -> _WiserPowerTagEnergyCollection:
         """Return all power tags"""
-        return self._device_collection["PTE"]
+        try:
+            return self._device_collection["PTE"]
+        except KeyError:
+            return None
 
     @property
     def roomstats(self) -> _WiserRoomStatCollection:
         """Return all roomstats"""
-        return self._device_collection["RoomStat"]
+        try:
+            return self._device_collection["RoomStat"]
+        except KeyError:
+            return None
 
     @property
     def shutters(self) -> _WiserShutterCollection:
         """Return all shutters"""
-        return self._device_collection["Shutter"]
+        try:
+            return self._device_collection["Shutter"]
+        except KeyError:
+            return None
 
     @property
     def smartplugs(self) -> _WiserSmartPlugCollection:
         """Return all smart plugs"""
-        return self._device_collection["SmartPlug"]
+        try:
+            return self._device_collection["SmartPlug"]
+        except KeyError:
+            return None
 
     @property
     def smartvalves(self) -> _WiserSmartValveCollection:
         """Return all smart valves (iTRVs)"""
-        return self._device_collection["SmartValve"]
+        try:
+            return self._device_collection["SmartValve"]
+        except KeyError:
+            return None
 
     @property
     def smokealarms(self) -> _WiserSmokeAlarmCollection:
         """Return all smoke alarms"""
-        return self._device_collection["SmokeAlarmDevice"]
+        try:
+            return self._device_collection["SmokeAlarmDevice"]
+        except KeyError:
+            return None
 
     @property
     def ufh_controllers(self) -> _WiserUFHControllerCollection:
         """Return all UFH controllers"""
-        return self._device_collection["UnderFloorHeating"]
+        try:
+            return self._device_collection["UnderFloorHeating"]
+        except KeyError:
+            return None
 
     @property
     def binary_sensor(self):
         """Return all binary sensors"""
-        return self._device_collection["BinarySensor"]
+        try:
+            return self._device_collection["BinarySensor"]
+        except KeyError:
+            return None
 
     def get_by_id(self, device_id: int) -> _WiserDevice:
         """

{aiowiserheatapi-1.5.19 → aiowiserheatapi-1.6.0}/aioWiserHeatAPI/heating_actuator.py

@@ -2,6 +2,8 @@ from .const import TEMP_OFF, TEXT_UNKNOWN, WISERHEATINGACTUATOR, WiserTempLimits
 from .helpers.device import _WiserDevice
 from .helpers.equipment import _WiserEquipment
 from .helpers.temp import _WiserTemperatureFunctions as tf
+from .helpers.threshold import _WiserThresholdSensor
+from .helpers.uiconfiguration import _WiserUIConfigSensor
 from .rest_controller import _WiserRestController
 
 
@@ -107,6 +109,12 @@ class _WiserTemperatureSensor:
 class _WiserHeatingActuator(_WiserDevice):
     """Class representing a Wiser Heating Actuator device"""
 
+    def __init__(self, *args):
+        """Initialise."""
+        super().__init__(*args)
+        self._threshold_sensors: list[_WiserThresholdSensor] = []
+        self._uiconfig_sensors: list[_WiserUIConfigSensor] = []
+
     @property
     def current_target_temperature(self) -> float:
         """Get the current target temperature setting"""
@@ -161,6 +169,16 @@ class _WiserHeatingActuator(_WiserDevice):
         """Get output type"""
         return self._device_type_data.get("OutputType", TEXT_UNKNOWN)
 
+    @property
+    def threshold_sensors(self) -> list[_WiserThresholdSensor]:
+        """Get threshold sensors."""
+        return self._threshold_sensors
+
+    @property
+    def uiconfig_sensors(self) -> list[_WiserUIConfigSensor]:
+        """Get ui configuration sensors."""
+        return self._uiconfig_sensors
+
 
 class _WiserHeatingActuatorCollection(object):
     """Class holding all wiser heating actuators"""

{aiowiserheatapi-1.5.19 → aiowiserheatapi-1.6.0}/aioWiserHeatAPI/helpers/device.py

@@ -1,5 +1,7 @@
+import hashlib
 import inspect
 from typing import Union
+from uuid import UUID
 
 from .. import _LOGGER
 from ..const import (
@@ -76,7 +78,7 @@ class _WiserDevice(object):
     @property
     def device_type_id(self) -> int:
         """Get the device id for the specific device type"""
-        return self._data.get("id")
+        return self._device_type_data.get("id")
 
     @property
     def identify(self) -> bool:
@@ -188,7 +190,13 @@ class _WiserDevice(object):
     @property
     def uuid(self) -> str:
         """Get UUID zigbee"""
-        return self._device_type_data.get("UUID", TEXT_UNKNOWN)
+        if uuid := self._device_type_data.get("UUID"):
+            return uuid
+        uname = (
+            f"{self.product_type}_{self.serial_number}_{self.id}_{self.device_type_id}"
+        )
+        hexstr = hashlib.md5(uname.encode("UTF-8")).hexdigest()
+        return UUID(hex=hexstr)
 
     # END Added by LGO