aioWiserHeatAPI 1.5.18__tar.gz → 1.6.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aioWiserHeatAPI
-Version: 1.5.18
+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
@@ -10,7 +10,7 @@ Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3.11
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.11
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: zeroconf>=0.131.0
@@ -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.18
+# 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,21 @@ 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
+* Added ButtonPanel device support
+
 ### v1.5.18
 
 * Better handle client response exeption and fit into retry routing

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

@@ -1,4 +1,4 @@
-# Drayton Wiser Hub API Async v1.5.18
+# 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,21 @@ 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
+* Added ButtonPanel device support
+
 ### v1.5.18
 
 * Better handle client response exeption and fit into retry routing

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

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

{aiowiserheatapi-1.5.18 → 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.6.0/aioWiserHeatAPI/button_panel.py

@@ -0,0 +1,43 @@
+from typing import Any
+
+from .helpers.device import _WiserDevice
+
+
+class _WiserButtonPanel(_WiserDevice):
+    """Class representing a Wiser Button Panel"""
+
+    @property
+    def number_of_gangs(self) -> list[int]:
+        """Number of gangs."""
+        return self._device_type_data.get("NumberOfGangs")
+
+    @property
+    def events(self) -> list[dict[str, Any]]:
+        """Events info."""
+        return self._device_type_data.get("Events")
+
+
+class _WiserButtonPanelCollection:
+    """Class holding all Wiser Button Panels"""
+
+    def __init__(self):
+        self._items = []
+
+    @property
+    def all(self) -> list[_WiserButtonPanel]:
+        return list(self._items)
+
+    @property
+    def count(self) -> int:
+        return len(self.all)
+
+    def get_by_id(self, id: int) -> _WiserButtonPanel:
+        """
+        Gets a button panel object from the sensor id
+        param id: id of button panel
+        return: _WiserButtonPanel object
+        """
+        try:
+            return [buttonpanel for buttonpanel in self.all if buttonpanel.id == id][0]
+        except IndexError:
+            return None

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

@@ -101,10 +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.18 → aiowiserheatapi-1.6.0}/aioWiserHeatAPI/devices.py

@@ -3,32 +3,41 @@ Module to manage all devices
 """
 
 import enum
+from dataclasses import dataclass
+from typing import Any
 
 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 .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
@@ -40,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"
@@ -54,9 +173,10 @@ class _WiserDeviceTypeEnum(enum.Enum):
     WindowDoorSensor = "BinarySensor"
     BoilerInterface = "BoilerInterface"
     CFMT = "HeatingActuator"
+    ButtonPanel = "ButtonPanel"
 
 
-PRODUCT_TYPE_CONFIG = {
+PRODUCT_TYPE_CONFIG_OLD = {
     "iTRV": {
         "class": _WiserSmartValve,
         "collection": _WiserSmartValveCollection,
@@ -93,47 +213,40 @@ PRODUCT_TYPE_CONFIG = {
         "class": _WiserShutter,
         "collection": _WiserShutterCollection,
         "endpoint": WISERSHUTTER,
-        "device_id_field": "DeviceId",
         "schedule_type": WiserScheduleTypeEnum.level,
     },
     "OnOffLight": {
         "class": _WiserLight,
         "collection": _WiserLightCollection,
         "endpoint": WISERLIGHT,
-        "device_id_field": "DeviceId",
         "schedule_type": WiserScheduleTypeEnum.level,
     },
     "DimmableLight": {
         "class": _WiserDimmableLight,
         "collection": _WiserLightCollection,
         "endpoint": WISERLIGHT,
-        "device_id_field": "DeviceId",
         "schedule_type": WiserScheduleTypeEnum.level,
     },
     "PowerTagE": {
         "class": _WiserPowerTagEnergy,
         "collection": _WiserPowerTagEnergyCollection,
         "endpoint": WISERPOWERTAGENERGY,
-        "device_id_field": "DeviceId",
         "has_v2_equipment": True,
     },
     "SmokeAlarmDevice": {
         "class": _WiserSmokeAlarm,
         "collection": _WiserSmokeAlarmCollection,
         "endpoint": WISERSMOKEALARM,
-        "device_id_field": "DeviceId",
     },
     "WindowDoorSensor": {
         "class": _WiserWindowDoorSensor,
         "collection": _WiserBinarySensorCollection,
         "endpoint": WISERBINARYSENSOR,
-        "device_id_field": "DeviceId",
     },
     "BoilerInterface": {
         "class": _WiserBoilerInterface,
         "collection": _WiserBoilerInterfaceCollection,
         "endpoint": WISERBOILERINTERFACE,
-        "device_id_field": "DeviceId",
     },
     "CFMT": {
         "class": _WiserHeatingActuator,
@@ -142,6 +255,11 @@ PRODUCT_TYPE_CONFIG = {
         "heating": True,
         "has_v2_equipment": True,
     },
+    "ButtonPanel": {
+        "class": _WiserButtonPanel,
+        "collection": _WiserButtonPanelCollection,
+        "endpoint": WISERBUTTONPANEL,
+    },
 }
 
 
@@ -172,75 +290,86 @@ class _WiserDeviceCollection:
         ]
         return equipment_data[0] if equipment_data else None
 
+    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
+
     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(device_config.get("device_id_field", "id"))
-                        == device.get("id")
-                    ]
+        """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:
@@ -269,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:
         """