plugwise 1.6.2__py3-none-any.whl → 1.6.4__py3-none-any.whl

plugwise/helper.py

@@ -2,6 +2,7 @@
 
 Plugwise Smile protocol helpers.
 """
+
 from __future__ import annotations
 
 import asyncio
@@ -28,6 +29,7 @@ from plugwise.constants import (
     NONE,
     OFF,
     P1_MEASUREMENTS,
+    PRIORITY_DEVICE_CLASSES,
     TEMP_CELSIUS,
     THERMOSTAT_CLASSES,
     TOGGLES,
@@ -67,6 +69,15 @@ from munch import Munch
 from packaging import version
 
 
+def search_actuator_functionalities(appliance: etree, actuator: str) -> etree | None:
+    """Helper-function for finding the relevant actuator xml-structure."""
+    locator = f"./actuator_functionalities/{actuator}"
+    if (search := appliance.find(locator)) is not None:
+        return search
+
+    return None
+
+
 class SmileComm:
     """The SmileComm class."""
 
@@ -179,7 +190,9 @@ class SmileComm:
                 # Command accepted gives empty body with status 202
                 return
             case 401:
-                msg = "Invalid Plugwise login, please retry with the correct credentials."
+                msg = (
+                    "Invalid Plugwise login, please retry with the correct credentials."
+                )
                 LOGGER.error("%s", msg)
                 raise InvalidAuthentication
             case 405:
@@ -266,7 +279,11 @@ class SmileHelper(SmileCommon):
         SmileCommon.__init__(self)
 
     def _all_appliances(self) -> None:
-        """Collect all appliances with relevant info."""
+        """Collect all appliances with relevant info.
+
+        Also, collect the P1 smartmeter info from a location
+        as this one is not available as an appliance.
+        """
         self._count = 0
         self._all_locations()
 
@@ -318,55 +335,33 @@ class SmileHelper(SmileCommon):
             if not (appl := self._appliance_info_finder(appl, appliance)):
                 continue
 
-            # P1: for gateway and smartmeter switch entity_id - part 1
-            # This is done to avoid breakage in HA Core
-            if appl.pwclass == "gateway" and self.smile_type == "power":
-                appl.entity_id = appl.location
-
             self._create_gw_entities(appl)
 
-        # For P1 collect the connected SmartMeter info
         if self.smile_type == "power":
-            self._p1_smartmeter_info_finder(appl)
-            # P1: for gateway and smartmeter switch entity_id - part 2
-            for item in self.gw_entities:
-                if item != self.gateway_id:
-                    self.gateway_id = item
-                    # Leave for-loop to avoid a 2nd device_id switch
-                    break
-
-        # Place the gateway and optional heater_central devices as 1st and 2nd
-        for dev_class in ("heater_central", "gateway"):
-            for entity_id, entity in dict(self.gw_entities).items():
-                if entity["dev_class"] == dev_class:
-                    tmp_entity = entity
-                    self.gw_entities.pop(entity_id)
-                    cleared_dict = self.gw_entities
-                    add_to_front = {entity_id: tmp_entity}
-                    self.gw_entities = {**add_to_front, **cleared_dict}
+            self._get_p1_smartmeter_info()
 
-    def _all_locations(self) -> None:
-        """Collect all locations."""
-        loc = Munch()
-        locations = self._domain_objects.findall("./location")
-        for location in locations:
-            loc.name = location.find("name").text
-            loc.loc_id = location.attrib["id"]
-            if loc.name == "Home":
-                self._home_location = loc.loc_id
+        # Sort the gw_entities
+        self._sort_gw_entities()
 
-            self._loc_data[loc.loc_id] = {"name": loc.name}
+    def _get_p1_smartmeter_info(self) -> None:
+        """For P1 collect the connected SmartMeter info from the Home/building location.
 
-    def _p1_smartmeter_info_finder(self, appl: Munch) -> None:
-        """Collect P1 DSMR SmartMeter info."""
+        Note: For P1, the entity_id for the gateway and smartmeter are
+        switched to maintain backward compatibility with existing implementations.
+        """
+        appl = Munch()
         loc_id = next(iter(self._loc_data.keys()))
-        location = self._domain_objects.find(f'./location[@id="{loc_id}"]')
+        if (
+            location := self._domain_objects.find(f'./location[@id="{loc_id}"]')
+        ) is None:
+            return
+
         locator = MODULE_LOCATOR
         module_data = self._get_module_data(location, locator)
         if not module_data["contents"]:
             LOGGER.error("No module data found for SmartMeter")  # pragma: no cover
-            return None  # pragma: no cover
-
+            return  # pragma: no cover
+        appl.available = None
         appl.entity_id = self.gateway_id
         appl.firmware = module_data["firmware_version"]
         appl.hardware = module_data["hardware_version"]
@@ -379,21 +374,52 @@ class SmileHelper(SmileCommon):
         appl.vendor_name = module_data["vendor_name"]
         appl.zigbee_mac = None
 
+        # Replace the entity_id of the gateway by the smartmeter location_id
+        self.gw_entities[loc_id] = self.gw_entities.pop(self.gateway_id)
+        self.gateway_id = loc_id
+
         self._create_gw_entities(appl)
 
+    def _sort_gw_entities(self) -> None:
+        """Place the gateway and optional heater_central entities as 1st and 2nd."""
+        for dev_class in PRIORITY_DEVICE_CLASSES:
+            for entity_id, entity in dict(self.gw_entities).items():
+                if entity["dev_class"] == dev_class:
+                    priority_entity = entity
+                    self.gw_entities.pop(entity_id)
+                    other_entities = self.gw_entities
+                    priority_entities = {entity_id: priority_entity}
+                    self.gw_entities = {**priority_entities, **other_entities}
+
+    def _all_locations(self) -> None:
+        """Collect all locations."""
+        loc = Munch()
+        locations = self._domain_objects.findall("./location")
+        for location in locations:
+            loc.name = location.find("name").text
+            loc.loc_id = location.attrib["id"]
+            if loc.name == "Home":
+                self._home_location = loc.loc_id
+
+            self._loc_data[loc.loc_id] = {"name": loc.name}
+
     def _appliance_info_finder(self, appl: Munch, appliance: etree) -> Munch:
         """Collect info for all appliances found."""
         match appl.pwclass:
             case "gateway":
-                # Collect gateway device info
+                # Collect gateway entity info
                 return self._appl_gateway_info(appl, appliance)
             case _ as dev_class if dev_class in THERMOSTAT_CLASSES:
-                # Collect thermostat device info
+                # Collect thermostat entity info
                 return self._appl_thermostat_info(appl, appliance)
             case "heater_central":
-                # Collect heater_central device info
-                self._appl_heater_central_info(appl, appliance, False)  # False means non-legacy device
-                self._appl_dhw_mode_info(appl, appliance)
+                # Collect heater_central entity info
+                self._appl_heater_central_info(
+                    appl, appliance, False
+                )  # False means non-legacy entity
+                self._dhw_allowed_modes = self._get_appl_actuator_modes(
+                    appliance, "domestic_hot_water_mode_control_functionality"
+                )
                 # Skip orphaned heater_central (Core Issue #104433)
                 if appl.entity_id != self._heater_id:
                     return Munch()
@@ -430,11 +456,15 @@ class SmileHelper(SmileCommon):
 
         # Adam: collect the ZigBee MAC address of the Smile
         if self.smile(ADAM):
-            if (found := self._domain_objects.find(".//protocols/zig_bee_coordinator")) is not None:
+            if (
+                found := self._domain_objects.find(".//protocols/zig_bee_coordinator")
+            ) is not None:
                 appl.zigbee_mac = found.find("mac_address").text
 
             # Also, collect regulation_modes and check for cooling, indicating cooling-mode is present
-            self._appl_regulation_mode_info(appliance)
+            self._reg_allowed_modes = self._get_appl_actuator_modes(
+                appliance, "regulation_mode_control_functionality"
+            )
 
             # Finally, collect the gateway_modes
             self._gw_allowed_modes = []
@@ -445,32 +475,24 @@ class SmileHelper(SmileCommon):
 
         return appl
 
-    def _appl_regulation_mode_info(self, appliance: etree) -> None:
-        """Helper-function for _appliance_info_finder()."""
-        reg_mode_list: list[str] = []
-        locator = "./actuator_functionalities/regulation_mode_control_functionality"
-        if (search := appliance.find(locator)) is not None:
-            if search.find("allowed_modes") is not None:
-                for mode in search.find("allowed_modes"):
-                    reg_mode_list.append(mode.text)
-                    if mode.text == "cooling":
-                        self._cooling_present = True
-                self._reg_allowed_modes = reg_mode_list
-
-    def _appl_dhw_mode_info(self, appl: Munch, appliance: etree) -> Munch:
-        """Helper-function for _appliance_info_finder().
-
-        Collect dhw control operation modes - Anna + Loria.
-        """
-        dhw_mode_list: list[str] = []
-        locator = "./actuator_functionalities/domestic_hot_water_mode_control_functionality"
-        if (search := appliance.find(locator)) is not None:
-            if search.find("allowed_modes") is not None:
-                for mode in search.find("allowed_modes"):
-                    dhw_mode_list.append(mode.text)
-                self._dhw_allowed_modes = dhw_mode_list
+    def _get_appl_actuator_modes(
+        self, appliance: etree, actuator_type: str
+    ) -> list[str]:
+        """Get allowed modes for the given actuator type."""
+        mode_list: list[str] = []
+        if (
+            search := search_actuator_functionalities(appliance, actuator_type)
+        ) is not None and (modes := search.find("allowed_modes")) is not None:
+            for mode in modes:
+                mode_list.append(mode.text)
+                self._check_cooling_mode(mode.text)
 
-        return appl
+        return mode_list
+
+    def _check_cooling_mode(self, mode: str) -> None:
+        """Check if cooling mode is present and update state."""
+        if mode == "cooling":
+            self._cooling_present = True
 
     def _get_appliances_with_offset_functionality(self) -> list[str]:
         """Helper-function collecting all appliance that have offset_functionality."""
@@ -510,7 +532,7 @@ class SmileHelper(SmileCommon):
         # !! DON'T CHANGE below two if-lines, will break stuff !!
         if self.smile_type == "power":
             if entity["dev_class"] == "smartmeter":
-                 data.update(self._power_data_from_location(entity["location"]))
+                data.update(self._power_data_from_location(entity["location"]))
 
             return data
 
@@ -636,13 +658,19 @@ class SmileHelper(SmileCommon):
     def _get_actuator_functionalities(
         self, xml: etree, entity: GwEntityData, data: GwEntityData
     ) -> None:
-        """Helper-function for _get_measurement_data()."""
+        """Get and process the actuator_functionalities details for an entity.
+
+        Add the resulting dict(s) to the entity's data.
+        """
         for item in ACTIVE_ACTUATORS:
             # Skip max_dhw_temperature, not initially valid,
             # skip thermostat for all but zones with thermostats
             if item == "max_dhw_temperature" or (
-                item == "thermostat" and (
-                    entity["dev_class"] != "climate" if self.smile(ADAM) else entity["dev_class"] != "thermostat"
+                item == "thermostat"
+                and (
+                    entity["dev_class"] != "climate"
+                    if self.smile(ADAM)
+                    else entity["dev_class"] != "thermostat"
                 )
             ):
                 continue
@@ -689,6 +717,21 @@ class SmileHelper(SmileCommon):
                 act_item = cast(ActuatorType, item)
                 data[act_item] = temp_dict
 
+    def _get_actuator_mode(
+        self, appliance: etree, entity_id: str, key: str
+    ) -> str | None:
+        """Helper-function for _get_regulation_mode and _get_gateway_mode.
+
+        Collect the requested gateway mode.
+        """
+        if not (self.smile(ADAM) and entity_id == self.gateway_id):
+            return None
+
+        if (search := search_actuator_functionalities(appliance, key)) is not None:
+            return str(search.find("mode").text)
+
+        return None
+
     def _get_regulation_mode(
         self, appliance: etree, entity_id: str, data: GwEntityData
     ) -> None:
@@ -696,14 +739,14 @@ class SmileHelper(SmileCommon):
 
         Adam: collect the gateway regulation_mode.
         """
-        if not (self.smile(ADAM) and entity_id == self.gateway_id):
-            return
-
-        locator = "./actuator_functionalities/regulation_mode_control_functionality"
-        if (search := appliance.find(locator)) is not None:
-            data["select_regulation_mode"] = search.find("mode").text
+        if (
+            mode := self._get_actuator_mode(
+                appliance, entity_id, "regulation_mode_control_functionality"
+            )
+        ) is not None:
+            data["select_regulation_mode"] = mode
             self._count += 1
-            self._cooling_enabled = data["select_regulation_mode"] == "cooling"
+            self._cooling_enabled = mode == "cooling"
 
     def _get_gateway_mode(
         self, appliance: etree, entity_id: str, data: GwEntityData
@@ -712,12 +755,12 @@ class SmileHelper(SmileCommon):
 
         Adam: collect the gateway mode.
         """
-        if not (self.smile(ADAM) and entity_id == self.gateway_id):
-            return
-
-        locator = "./actuator_functionalities/gateway_mode_control_functionality"
-        if (search := appliance.find(locator)) is not None:
-            data["select_gateway_mode"] = search.find("mode").text
+        if (
+            mode := self._get_actuator_mode(
+                appliance, entity_id, "gateway_mode_control_functionality"
+            )
+        ) is not None:
+            data["select_gateway_mode"] = mode
             self._count += 1
 
     def _get_gateway_outdoor_temp(self, entity_id: str, data: GwEntityData) -> None:
@@ -768,19 +811,23 @@ class SmileHelper(SmileCommon):
             data["binary_sensors"]["heating_state"] = data["c_heating_state"]
 
         if self.smile(ADAM):
+            # First count when not present, then create and init to False.
+            # When present init to False
             if "heating_state" not in data["binary_sensors"]:
                 self._count += 1
             data["binary_sensors"]["heating_state"] = False
+
             if "cooling_state" not in data["binary_sensors"]:
                 self._count += 1
             data["binary_sensors"]["cooling_state"] = False
+
             if self._cooling_enabled:
                 data["binary_sensors"]["cooling_state"] = data["c_heating_state"]
             else:
                 data["binary_sensors"]["heating_state"] = data["c_heating_state"]
 
     def _update_anna_cooling(self, entity_id: str, data: GwEntityData) -> None:
-        """Update the Anna heater_central device for cooling.
+        """Update the Anna heater_central entity for cooling.
 
         Support added for Techneco Elga and Thercon Loria/Thermastage.
         """
@@ -798,7 +845,11 @@ class SmileHelper(SmileCommon):
             # Techneco Elga has cooling-capability
             self._cooling_present = True
             data["model"] = "Generic heater/cooler"
-            self._cooling_enabled = data["elga_status_code"] in (8, 9)
+            # Cooling_enabled in xml does NOT show the correct status!
+            # Setting it specifically:
+            self._cooling_enabled = data["binary_sensors"]["cooling_enabled"] = data[
+                "elga_status_code"
+            ] in (8, 9)
             data["binary_sensors"]["cooling_state"] = self._cooling_active = (
                 data["elga_status_code"] == 8
             )
@@ -812,11 +863,17 @@ class SmileHelper(SmileCommon):
 
     def _update_loria_cooling(self, data: GwEntityData) -> None:
         """Loria/Thermastage: base cooling-related on cooling_state and modulation_level."""
-        self._cooling_enabled = data["binary_sensors"]["cooling_state"]
+        # For Loria/Thermastage it's not clear if cooling_enabled in xml shows the correct status,
+        # setting it specifically:
+        self._cooling_enabled = data["binary_sensors"]["cooling_enabled"] = data[
+            "binary_sensors"
+        ]["cooling_state"]
         self._cooling_active = data["sensors"]["modulation_level"] == 100
         # For Loria the above does not work (pw-beta issue #301)
         if "cooling_ena_switch" in data["switches"]:
-            self._cooling_enabled = data["switches"]["cooling_ena_switch"]
+            self._cooling_enabled = data["binary_sensors"]["cooling_enabled"] = data[
+                "switches"
+            ]["cooling_ena_switch"]
             self._cooling_active = data["binary_sensors"]["cooling_state"]
 
     def _cleanup_data(self, data: GwEntityData) -> None:
@@ -866,7 +923,10 @@ class SmileHelper(SmileCommon):
                     "dev_class": "climate",
                     "model": "ThermoZone",
                     "name": loc_data["name"],
-                    "thermostats": {"primary": loc_data["primary"], "secondary": loc_data["secondary"]},
+                    "thermostats": {
+                        "primary": loc_data["primary"],
+                        "secondary": loc_data["secondary"],
+                    },
                     "vendor": "Plugwise",
                 }
                 self._count += 3
@@ -906,10 +966,12 @@ class SmileHelper(SmileCommon):
             if thermo_matching[appl_class] == thermo_loc["primary_prio"]:
                 thermo_loc["primary"].append(appliance_id)
             # Pre-elect new primary
-            elif (thermo_rank := thermo_matching[appl_class]) > thermo_loc["primary_prio"]:
+            elif (thermo_rank := thermo_matching[appl_class]) > thermo_loc[
+                "primary_prio"
+            ]:
                 thermo_loc["primary_prio"] = thermo_rank
                 # Demote former primary
-                if (tl_primary := thermo_loc["primary"]):
+                if tl_primary := thermo_loc["primary"]:
                     thermo_loc["secondary"] += tl_primary
                     thermo_loc["primary"] = []
 
@@ -1006,9 +1068,17 @@ class SmileHelper(SmileCommon):
         for rule in self._domain_objects.findall(f'./rule[name="{name}"]'):
             active = rule.find("active").text
             if rule.find(locator) is not None:
-                schedule_ids[rule.attrib["id"]] = {"location": loc_id, "name": name, "active": active}
+                schedule_ids[rule.attrib["id"]] = {
+                    "location": loc_id,
+                    "name": name,
+                    "active": active,
+                }
             else:
-                schedule_ids[rule.attrib["id"]] = {"location": NONE, "name": name, "active": active}
+                schedule_ids[rule.attrib["id"]] = {
+                    "location": NONE,
+                    "name": name,
+                    "active": active,
+                }
 
         return schedule_ids
 
@@ -1025,9 +1095,17 @@ class SmileHelper(SmileCommon):
                 name = rule.find("name").text
                 active = rule.find("active").text
                 if rule.find(locator2) is not None:
-                    schedule_ids[rule.attrib["id"]] = {"location": loc_id, "name": name, "active": active}
+                    schedule_ids[rule.attrib["id"]] = {
+                        "location": loc_id,
+                        "name": name,
+                        "active": active,
+                    }
                 else:
-                    schedule_ids[rule.attrib["id"]] = {"location": NONE, "name": name, "active": active}
+                    schedule_ids[rule.attrib["id"]] = {
+                        "location": NONE,
+                        "name": name,
+                        "active": active,
+                    }
 
         return schedule_ids
 

plugwise/legacy/data.py

@@ -2,6 +2,7 @@
 
 Plugwise Smile protocol data-collection helpers for legacy devices.
 """
+
 from __future__ import annotations
 
 # Dict as class
@@ -63,6 +64,7 @@ class SmileLegacyData(SmileLegacyHelper):
 
         # Thermostat data (presets, temperatures etc)
         self._climate_data(entity, data)
+        self._get_anna_control_state(data)
 
         return data
 
@@ -91,3 +93,14 @@ class SmileLegacyData(SmileLegacyHelper):
         self._count += 1
         if sel_schedule in (NONE, OFF):
             data["climate_mode"] = "heat"
+
+    def _get_anna_control_state(self, data: GwEntityData) -> None:
+        """Set the thermostat control_state based on the opentherm/onoff device state."""
+        data["control_state"] = "idle"
+        for entity in self.gw_entities.values():
+            if entity["dev_class"] != "heater_central":
+                continue
+
+            binary_sensors = entity["binary_sensors"]
+            if binary_sensors["heating_state"]:
+                data["control_state"] = "heating"

plugwise/legacy/helper.py

@@ -2,6 +2,7 @@
 
 Plugwise Smile protocol helpers.
 """
+
 from __future__ import annotations
 
 from typing import cast
@@ -169,10 +170,7 @@ class SmileLegacyHelper(SmileCommon):
             loc.loc_id = location.attrib["id"]
             # Filter the valid single location for P1 legacy: services not empty
             locator = "./services"
-            if (
-                self.smile_type == "power"
-                and len(location.find(locator)) == 0
-            ):
+            if self.smile_type == "power" and len(location.find(locator)) == 0:
                 continue
 
             if loc.name == "Home":
@@ -212,15 +210,15 @@ class SmileLegacyHelper(SmileCommon):
     def _appliance_info_finder(self, appliance: etree, appl: Munch) -> Munch:
         """Collect entity info (Smile/Stretch, Thermostats, OpenTherm/On-Off): firmware, model and vendor name."""
         match appl.pwclass:
-        # Collect thermostat entity info
+            # Collect thermostat entity info
             case _ as dev_class if dev_class in THERMOSTAT_CLASSES:
                 return self._appl_thermostat_info(appl, appliance, self._modules)
-        # Collect heater_central entity info
+            # Collect heater_central entity info
             case "heater_central":
                 return self._appl_heater_central_info(
                     appl, appliance, True, self._appliances, self._modules
                 )  # True means legacy device
-        # Collect info from Stretches
+            # Collect info from Stretches
             case _:
                 return self._energy_entity_info_finder(appliance, appl)
 
@@ -231,7 +229,9 @@ class SmileLegacyHelper(SmileCommon):
         """
         if self.smile_type in ("power", "stretch"):
             locator = "./services/electricity_point_meter"
-            module_data = self._get_module_data(appliance, locator, self._modules, legacy=True)
+            module_data = self._get_module_data(
+                appliance, locator, self._modules, legacy=True
+            )
             appl.zigbee_mac = module_data["zigbee_mac_address"]
             # Filter appliance without zigbee_mac, it's an orphaned device
             if appl.zigbee_mac is None and self.smile_type != "power":
@@ -362,10 +362,7 @@ class SmileLegacyHelper(SmileCommon):
         self._count_data_items(data)
 
     def _get_actuator_functionalities(
-        self,
-        xml: etree,
-        entity: GwEntityData,
-        data: GwEntityData
+        self, xml: etree, entity: GwEntityData, data: GwEntityData
     ) -> None:
         """Helper-function for _get_measurement_data()."""
         for item in ACTIVE_ACTUATORS:
@@ -458,7 +455,9 @@ class SmileLegacyHelper(SmileCommon):
             active = result.text == "on"
 
         # Show an empty schedule as no schedule found
-        directives = search.find(f'./rule[@id="{rule_id}"]/directives/when/then') is not None
+        directives = (
+            search.find(f'./rule[@id="{rule_id}"]/directives/when/then') is not None
+        )
         if directives and name is not None:
             available = [name, OFF]
             selected = name if active else OFF

plugwise/legacy/smile.py

@@ -2,6 +2,7 @@
 
 Plugwise backend module for Home Assistant Core - covering the legacy P1, Anna, and Stretch devices.
 """
+
 from __future__ import annotations
 
 from collections.abc import Awaitable, Callable
@@ -24,7 +25,7 @@ from plugwise.constants import (
     PlugwiseData,
     ThermoLoc,
 )
-from plugwise.exceptions import ConnectionFailedError, PlugwiseError
+from plugwise.exceptions import ConnectionFailedError, DataMissingError, PlugwiseError
 from plugwise.legacy.data import SmileLegacyData
 
 import aiohttp
@@ -119,18 +120,30 @@ class SmileLegacyAPI(SmileLegacyData):
             )
             self.gw_data: GatewayData = {}
             self.gw_entities: dict[str, GwEntityData] = {}
-            await self.full_xml_update()
-            self.get_all_gateway_entities()
+            try:
+                await self.full_xml_update()
+                self.get_all_gateway_entities()
+                # Detect failed data-retrieval
+                _ = self.gw_entities[self.gateway_id]["location"]
+            except KeyError as err:  # pragma: no cover
+                raise DataMissingError(
+                    "No (full) Plugwise legacy data received"
+                ) from err
         # Otherwise perform an incremental update
         else:
-            self._domain_objects = await self.request(DOMAIN_OBJECTS)
-            match self._target_smile:
-                case "smile_v2":
-                    self._modules = await self.request(MODULES)
-                case self._target_smile if self._target_smile in REQUIRE_APPLIANCES:
-                    self._appliances = await self.request(APPLIANCES)
-
-            self._update_gw_entities()
+            try:
+                self._domain_objects = await self.request(DOMAIN_OBJECTS)
+                match self._target_smile:
+                    case "smile_v2":
+                        self._modules = await self.request(MODULES)
+                    case self._target_smile if self._target_smile in REQUIRE_APPLIANCES:
+                        self._appliances = await self.request(APPLIANCES)
+
+                self._update_gw_entities()
+                # Detect failed data-retrieval
+                _ = self.gw_entities[self.gateway_id]["location"]
+            except KeyError as err:  # pragma: no cover
+                raise DataMissingError("No legacy Plugwise data received") from err
 
         self._previous_day_number = day_number
         return PlugwiseData(
@@ -138,9 +151,9 @@ class SmileLegacyAPI(SmileLegacyData):
             gateway=self.gw_data,
         )
 
-########################################################################################################
-###  API Set and HA Service-related Functions                                                        ###
-########################################################################################################
+    ########################################################################################################
+    ###  API Set and HA Service-related Functions                                                        ###
+    ########################################################################################################
 
     async def delete_notification(self) -> None:
         """Set-function placeholder for legacy devices."""
@@ -181,12 +194,16 @@ class SmileLegacyAPI(SmileLegacyData):
     async def set_regulation_mode(self, mode: str) -> None:
         """Set-function placeholder for legacy devices."""
 
-    async def set_select(self, key: str, loc_id: str, option: str, state: str | None) -> None:
+    async def set_select(
+        self, key: str, loc_id: str, option: str, state: str | None
+    ) -> None:
         """Set the thermostat schedule option."""
         # schedule name corresponds to select option
         await self.set_schedule_state("dummy", state, option)
 
-    async def set_schedule_state(self, _: str, state: str | None, name: str | None) -> None:
+    async def set_schedule_state(
+        self, _: str, state: str | None, name: str | None
+    ) -> None:
         """Activate/deactivate the Schedule.
 
         Determined from - DOMAIN_OBJECTS.
@@ -205,7 +222,9 @@ class SmileLegacyAPI(SmileLegacyData):
                 schedule_rule_id = rule.attrib["id"]
 
         if schedule_rule_id is None:
-            raise PlugwiseError("Plugwise: no schedule with this name available.")  # pragma: no cover
+            raise PlugwiseError(
+                "Plugwise: no schedule with this name available."
+            )  # pragma: no cover
 
         new_state = "false"
         if state == "on":