plugwise 1.6.3__py3-none-any.whl → 1.7.0__py3-none-any.whl

plugwise/helper.py

@@ -2,9 +2,9 @@
 
 Plugwise Smile protocol helpers.
 """
+
 from __future__ import annotations
 
-import asyncio
 import datetime as dt
 from typing import cast
 
@@ -28,6 +28,7 @@ from plugwise.constants import (
     NONE,
     OFF,
     P1_MEASUREMENTS,
+    PRIORITY_DEVICE_CLASSES,
     TEMP_CELSIUS,
     THERMOSTAT_CLASSES,
     TOGGLES,
@@ -36,29 +37,20 @@ from plugwise.constants import (
     ActuatorData,
     ActuatorDataType,
     ActuatorType,
-    GatewayData,
     GwEntityData,
     SensorType,
     ThermoLoc,
     ToggleNameType,
 )
-from plugwise.exceptions import (
-    ConnectionFailedError,
-    InvalidAuthentication,
-    InvalidXMLError,
-    ResponseError,
-)
 from plugwise.util import (
     check_model,
+    collect_power_values,
     common_match_cases,
-    escape_illegal_xml_characters,
+    count_data_items,
     format_measure,
     skip_obsolete_measurements,
 )
 
-# This way of importing aiohttp is because of patch/mocking in testing (aiohttp timeouts)
-from aiohttp import BasicAuth, ClientError, ClientResponse, ClientSession, ClientTimeout
-
 # Time related
 from dateutil import tz
 from dateutil.parser import parse
@@ -67,144 +59,13 @@ from munch import Munch
 from packaging import version
 
 
-class SmileComm:
-    """The SmileComm class."""
-
-    def __init__(
-        self,
-        host: str,
-        password: str,
-        port: int,
-        timeout: int,
-        username: str,
-        websession: ClientSession | None,
-    ) -> None:
-        """Set the constructor for this class."""
-        if not websession:
-            aio_timeout = ClientTimeout(total=timeout)
-
-            async def _create_session() -> ClientSession:
-                return ClientSession(timeout=aio_timeout)  # pragma: no cover
-
-            loop = asyncio.get_event_loop()
-            if loop.is_running():
-                self._websession = ClientSession(timeout=aio_timeout)
-            else:
-                self._websession = loop.run_until_complete(
-                    _create_session()
-                )  # pragma: no cover
-        else:
-            self._websession = websession
+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
 
-        # Quickfix IPv6 formatting, not covering
-        if host.count(":") > 2:  # pragma: no cover
-            host = f"[{host}]"
-
-        self._auth = BasicAuth(username, password=password)
-        self._endpoint = f"http://{host}:{str(port)}"
-
-    async def _request(
-        self,
-        command: str,
-        retry: int = 3,
-        method: str = "get",
-        data: str | None = None,
-        headers: dict[str, str] | None = None,
-    ) -> etree:
-        """Get/put/delete data from a give URL."""
-        resp: ClientResponse
-        url = f"{self._endpoint}{command}"
-        use_headers = headers
-
-        try:
-            match method:
-                case "delete":
-                    resp = await self._websession.delete(url, auth=self._auth)
-                case "get":
-                    # Work-around for Stretchv2, should not hurt the other smiles
-                    use_headers = {"Accept-Encoding": "gzip"}
-                    resp = await self._websession.get(
-                        url, headers=use_headers, auth=self._auth
-                    )
-                case "post":
-                    use_headers = {"Content-type": "text/xml"}
-                    resp = await self._websession.post(
-                        url,
-                        headers=use_headers,
-                        data=data,
-                        auth=self._auth,
-                    )
-                case "put":
-                    use_headers = {"Content-type": "text/xml"}
-                    resp = await self._websession.put(
-                        url,
-                        headers=use_headers,
-                        data=data,
-                        auth=self._auth,
-                    )
-        except (
-            ClientError
-        ) as exc:  # ClientError is an ancestor class of ServerTimeoutError
-            if retry < 1:
-                LOGGER.warning(
-                    "Failed sending %s %s to Plugwise Smile, error: %s",
-                    method,
-                    command,
-                    exc,
-                )
-                raise ConnectionFailedError from exc
-            return await self._request(command, retry - 1)
-
-        if resp.status == 504:
-            if retry < 1:
-                LOGGER.warning(
-                    "Failed sending %s %s to Plugwise Smile, error: %s",
-                    method,
-                    command,
-                    "504 Gateway Timeout",
-                )
-                raise ConnectionFailedError
-            return await self._request(command, retry - 1)
-
-        return await self._request_validate(resp, method)
-
-    async def _request_validate(self, resp: ClientResponse, method: str) -> etree:
-        """Helper-function for _request(): validate the returned data."""
-        match resp.status:
-            case 200:
-                # Cornercases for server not responding with 202
-                if method in ("post", "put"):
-                    return
-            case 202:
-                # Command accepted gives empty body with status 202
-                return
-            case 401:
-                msg = "Invalid Plugwise login, please retry with the correct credentials."
-                LOGGER.error("%s", msg)
-                raise InvalidAuthentication
-            case 405:
-                msg = "405 Method not allowed."
-                LOGGER.error("%s", msg)
-                raise ConnectionFailedError
-
-        if not (result := await resp.text()) or (
-            "<error>" in result and "Not started" not in result
-        ):
-            LOGGER.warning("Smile response empty or error in %s", result)
-            raise ResponseError
-
-        try:
-            # Encode to ensure utf8 parsing
-            xml = etree.XML(escape_illegal_xml_characters(result).encode())
-        except etree.ParseError as exc:
-            LOGGER.warning("Smile returns invalid XML for %s", self._endpoint)
-            raise InvalidXMLError from exc
-
-        return xml
-
-    async def close_connection(self) -> None:
-        """Close the Plugwise connection."""
-        await self._websession.close()
+    return None
 
 
 class SmileHelper(SmileCommon):
@@ -212,61 +73,28 @@ class SmileHelper(SmileCommon):
 
     def __init__(self) -> None:
         """Set the constructor for this class."""
-        self._cooling_present: bool
-        self._count: int
-        self._dhw_allowed_modes: list[str] = []
-        self._domain_objects: etree
         self._endpoint: str
         self._elga: bool
-        self._gw_allowed_modes: list[str] = []
-        self._heater_id: str
-        self._home_location: str
         self._is_thermostat: bool
         self._last_active: dict[str, str | None]
-        self._last_modified: dict[str, str] = {}
         self._loc_data: dict[str, ThermoLoc]
-        self._notifications: dict[str, dict[str, str]] = {}
-        self._on_off_device: bool
-        self._opentherm_device: bool
-        self._reg_allowed_modes: list[str] = []
         self._schedule_old_states: dict[str, dict[str, str]]
-        self._status: etree
-        self._stretch_v2: bool
-        self._system: etree
-        self._thermo_locs: dict[str, ThermoLoc] = {}
-        ###################################################################
-        # '_cooling_enabled' can refer to the state of the Elga heatpump
-        # connected to an Anna. For Elga, 'elga_status_code' in (8, 9)
-        # means cooling mode is available, next to heating mode.
-        # 'elga_status_code' = 8 means cooling is active, 9 means idle.
-        #
-        # '_cooling_enabled' cam refer to the state of the Loria or
-        # Thermastage heatpump connected to an Anna. For these,
-        # 'cooling_enabled' = on means set to cooling mode, instead of to
-        # heating mode.
-        # 'cooling_state' = on means cooling is active.
-        ###################################################################
-        self._cooling_active = False
-        self._cooling_enabled = False
-
-        self.gateway_id: str
-        self.gw_data: GatewayData = {}
-        self.gw_entities: dict[str, GwEntityData] = {}
-        self.smile_fw_version: version.Version | None
+        self._gateway_id: str = NONE
+        self._zones: dict[str, GwEntityData]
+        self.gw_entities: dict[str, GwEntityData]
         self.smile_hw_version: str | None
         self.smile_mac_address: str | None
         self.smile_model: str
         self.smile_model_id: str | None
-        self.smile_name: str
-        self.smile_type: str
         self.smile_version: version.Version | None
-        self.smile_zigbee_mac_address: str | None
-        self.therms_with_offset_func: list[str] = []
-        self._zones: dict[str, GwEntityData] = {}
         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()
 
@@ -294,10 +122,10 @@ class SmileHelper(SmileCommon):
             appl.location = None
             if (appl_loc := appliance.find("location")) is not None:
                 appl.location = appl_loc.attrib["id"]
-            # Don't assign the _home_location to thermostat-devices without a location,
+            # Don't assign the _home_loc_id to thermostat-devices without a location,
             # they are not active
             elif appl.pwclass not in THERMOSTAT_CLASSES:
-                appl.location = self._home_location
+                appl.location = self._home_loc_id
 
             # Don't show orphaned thermostat-types
             if appl.pwclass in THERMOSTAT_CLASSES and appl.location is None:
@@ -318,59 +146,31 @@ 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."""
-        loc_id = next(iter(self._loc_data.keys()))
-        location = self._domain_objects.find(f'./location[@id="{loc_id}"]')
+        Note: For P1, the entity_id for the gateway and smartmeter are
+        switched to maintain backward compatibility with existing implementations.
+        """
+        appl = Munch()
         locator = MODULE_LOCATOR
-        module_data = self._get_module_data(location, locator)
+        module_data = self._get_module_data(self._home_location, locator)
         if not module_data["contents"]:
             LOGGER.error("No module data found for SmartMeter")  # pragma: no cover
-            return None  # pragma: no cover
-
-        appl.entity_id = self.gateway_id
+            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"]
-        appl.location = loc_id
+        appl.location = self._home_loc_id
         appl.mac = None
         appl.model = module_data["vendor_model"]
         appl.model_id = None  # don't use model_id for SmartMeter
@@ -379,21 +179,56 @@ 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[self._home_loc_id] = self.gw_entities.pop(self._gateway_id)
+        self._gateway_id = self._home_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"]
+            self._loc_data[loc.loc_id] = {"name": loc.name}
+            if loc.name != "Home":
+                continue
+
+            self._home_loc_id = loc.loc_id
+            self._home_location = self._domain_objects.find(
+                f"./location[@id='{loc.loc_id}']"
+            )
+
     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()
@@ -419,8 +254,8 @@ class SmileHelper(SmileCommon):
 
     def _appl_gateway_info(self, appl: Munch, appliance: etree) -> Munch:
         """Helper-function for _appliance_info_finder()."""
-        self.gateway_id = appliance.attrib["id"]
-        appl.firmware = str(self.smile_fw_version)
+        self._gateway_id = appliance.attrib["id"]
+        appl.firmware = str(self.smile_version)
         appl.hardware = self.smile_hw_version
         appl.mac = self.smile_mac_address
         appl.model = self.smile_model
@@ -430,11 +265,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 +284,18 @@ 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)
 
-        return appl
+        return mode_list
 
     def _get_appliances_with_offset_functionality(self) -> list[str]:
         """Helper-function collecting all appliance that have offset_functionality."""
@@ -510,7 +335,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())
 
             return data
 
@@ -552,21 +377,20 @@ class SmileHelper(SmileCommon):
 
         return data
 
-    def _power_data_from_location(self, loc_id: str) -> GwEntityData:
+    def _power_data_from_location(self) -> GwEntityData:
         """Helper-function for smile.py: _get_entity_data().
 
-        Collect the power-data based on Location ID, from LOCATIONS.
+        Collect the power-data from the Home location.
         """
         data: GwEntityData = {"sensors": {}}
         loc = Munch()
         log_list: list[str] = ["point_log", "cumulative_log", "interval_log"]
         t_string = "tariff"
 
-        search = self._domain_objects
-        loc.logs = search.find(f'./location[@id="{loc_id}"]/logs')
+        loc.logs = self._home_location.find("./logs")
         for loc.measurement, loc.attrs in P1_MEASUREMENTS.items():
             for loc.log_type in log_list:
-                self._collect_power_values(data, loc, t_string)
+                collect_power_values(data, loc, t_string)
 
         self._count += len(data["sensors"])
         return data
@@ -602,7 +426,7 @@ class SmileHelper(SmileCommon):
                     appl_i_loc.text, ENERGY_WATT_HOUR
                 )
 
-        self._count_data_items(data)
+        self._count = count_data_items(self._count, data)
 
     def _get_toggle_state(
         self, xml: etree, toggle: str, name: ToggleNameType, data: GwEntityData
@@ -625,7 +449,7 @@ class SmileHelper(SmileCommon):
                 msg_id = notification.attrib["id"]
                 msg_type = notification.find("type").text
                 msg = notification.find("message").text
-                self._notifications.update({msg_id: {msg_type: msg}})
+                self._notifications[msg_id] = {msg_type: msg}
                 LOGGER.debug("Plugwise notifications: %s", self._notifications)
             except AttributeError:  # pragma: no cover
                 LOGGER.debug(
@@ -636,13 +460,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 +519,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 +541,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,40 +557,23 @@ 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:
-        """Adam & Anna: the Smile outdoor_temperature is present in DOMAIN_OBJECTS and LOCATIONS.
-
-        Available under the Home location.
-        """
-        if self._is_thermostat and entity_id == self.gateway_id:
-            outdoor_temperature = self._object_value(
-                self._home_location, "outdoor_temperature"
-            )
-            if outdoor_temperature is not None:
-                data.update({"sensors": {"outdoor_temperature": outdoor_temperature}})
+        """Adam & Anna: the Smile outdoor_temperature is present in the Home location."""
+        if self._is_thermostat and entity_id == self._gateway_id:
+            locator = "./logs/point_log[type='outdoor_temperature']/period/measurement"
+            if (found := self._home_location.find(locator)) is not None:
+                value = format_measure(found.text, NONE)
+                data.update({"sensors": {"outdoor_temperature": value}})
                 self._count += 1
 
-    def _object_value(self, obj_id: str, measurement: str) -> float | int | None:
-        """Helper-function for smile.py: _get_entity_data().
-
-        Obtain the value/state for the given object from a location in DOMAIN_OBJECTS
-        """
-        val: float | int | None = None
-        search = self._domain_objects
-        locator = f'./location[@id="{obj_id}"]/logs/point_log[type="{measurement}"]/period/measurement'
-        if (found := search.find(locator)) is not None:
-            val = format_measure(found.text, NONE)
-
-        return val
-
     def _process_c_heating_state(self, data: GwEntityData) -> None:
         """Helper-function for _get_measurement_data().
 
@@ -768,19 +596,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.
         """
@@ -793,14 +625,20 @@ class SmileHelper(SmileCommon):
             self._update_loria_cooling(data)
 
     def _update_elga_cooling(self, data: GwEntityData) -> None:
-        """# Anna+Elga: base cooling_state on the elga-status-code."""
+        """# Anna+Elga: base cooling_state on the elga-status-code.
+
+        For Elga, 'elga_status_code' in (8, 9) means cooling is enabled.
+        'elga_status_code' = 8 means cooling is active, 9 means idle.
+        """
         if data["thermostat_supports_cooling"]:
             # Techneco Elga has cooling-capability
             self._cooling_present = True
             data["model"] = "Generic heater/cooler"
             # 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)
+            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
             )
@@ -813,14 +651,22 @@ class SmileHelper(SmileCommon):
         self._count -= 1
 
     def _update_loria_cooling(self, data: GwEntityData) -> None:
-        """Loria/Thermastage: base cooling-related on cooling_state and modulation_level."""
+        """Loria/Thermastage: base cooling-related on cooling_state and modulation_level.
+
+        For the Loria or Thermastage heatpump connected to an Anna cooling-enabled is
+        indicated via the Cooling Enable switch in the Plugwise App.
+        """
         # 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_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["binary_sensors"]["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:
@@ -870,7 +716,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
@@ -910,10 +759,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"] = []
 
@@ -929,11 +780,9 @@ class SmileHelper(SmileCommon):
         Represents the heating/cooling demand-state of the local primary thermostat.
         Note: heating or cooling can still be active when the setpoint has been reached.
         """
-        locator = f'location[@id="{loc_id}"]'
-        if (location := self._domain_objects.find(locator)) is not None:
-            locator = './actuator_functionalities/thermostat_functionality[type="thermostat"]/control_state'
-            if (ctrl_state := location.find(locator)) is not None:
-                return str(ctrl_state.text)
+        locator = f'location[@id="{loc_id}"]/actuator_functionalities/thermostat_functionality[type="thermostat"]/control_state'
+        if (ctrl_state := self._domain_objects.find(locator)) is not None:
+            return str(ctrl_state.text)
 
         # Handle missing control_state in regulation_mode off for firmware >= 3.2.0 (issue #776)
         # In newer firmware versions, default to "off" when control_state is not present
@@ -1010,9 +859,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
 
@@ -1029,9 +886,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