plugwise 0.36.2__py3-none-any.whl → 0.37.0__py3-none-any.whl

plugwise/helper.py

@@ -8,32 +8,19 @@ import asyncio
 import datetime as dt
 from typing import cast
 
-# 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
-from defusedxml import ElementTree as etree
-from munch import Munch
-import semver
-
-from .constants import (
+from plugwise.constants import (
     ACTIVE_ACTUATORS,
     ACTUATOR_CLASSES,
     ADAM,
     ANNA,
-    APPLIANCES,
     ATTR_NAME,
     ATTR_UNIT_OF_MEASUREMENT,
     BINARY_SENSORS,
     DATA,
     DEVICE_MEASUREMENTS,
     DHW_SETPOINT,
-    ENERGY_KILO_WATT_HOUR,
+    DOMAIN_OBJECTS,
     ENERGY_WATT_HOUR,
-    FAKE_APPL,
-    FAKE_LOC,
     HEATER_CENTRAL_MEASUREMENTS,
     LIMITS,
     LOCATIONS,
@@ -41,9 +28,7 @@ from .constants import (
     NONE,
     OBSOLETE_MEASUREMENTS,
     OFF,
-    P1_LEGACY_MEASUREMENTS,
     P1_MEASUREMENTS,
-    POWER_WATT,
     SENSORS,
     SPECIAL_PLUG_TYPES,
     SPECIALS,
@@ -67,43 +52,27 @@ from .constants import (
     ThermoLoc,
     ToggleNameType,
 )
-from .exceptions import (
+from plugwise.exceptions import (
     ConnectionFailedError,
     InvalidAuthentication,
     InvalidXMLError,
     ResponseError,
 )
-from .util import escape_illegal_xml_characters, format_measure, version_to_model
-
-
-def check_model(name: str | None, vendor_name: str | None) -> str | None:
-    """Model checking before using version_to_model."""
-    if vendor_name == "Plugwise" and ((model := version_to_model(name)) != "Unknown"):
-        return model
-
-    return name
-
-
-def etree_to_dict(element: etree) -> dict[str, str]:
-    """Helper-function translating xml Element to dict."""
-    node: dict[str, str] = {}
-    if element is not None:
-        node.update(element.items())
-
-    return node
-
+from plugwise.util import (
+    check_model,
+    escape_illegal_xml_characters,
+    format_measure,
+    power_data_local_format,
+)
 
-def power_data_local_format(
-    attrs: dict[str, str], key_string: str, val: str
-) -> float | int:
-    """Format power data."""
-    # Special formatting of P1_MEASUREMENT POWER_WATT values, do not move to util-format_measure() function!
-    if all(item in key_string for item in ("electricity", "cumulative")):
-        return format_measure(val, ENERGY_KILO_WATT_HOUR)
-    if (attrs_uom := getattr(attrs, ATTR_UNIT_OF_MEASUREMENT)) == POWER_WATT:
-        return int(round(float(val)))
+# This way of importing aiohttp is because of patch/mocking in testing (aiohttp timeouts)
+from aiohttp import BasicAuth, ClientError, ClientResponse, ClientSession, ClientTimeout
 
-    return format_measure(val, attrs_uom)
+# Time related
+from dateutil import tz
+from dateutil.parser import parse
+from defusedxml import ElementTree as etree
+from munch import Munch
 
 
 class SmileComm:
@@ -113,10 +82,10 @@ class SmileComm:
         self,
         host: str,
         password: str,
+        websession: ClientSession | None,
         username: str,
         port: int,
         timeout: float,
-        websession: ClientSession | None,
     ) -> None:
         """Set the constructor for this class."""
         if not websession:
@@ -148,6 +117,7 @@ class SmileComm:
         # Command accepted gives empty body with status 202
         if resp.status == 202:
             return
+
         # Cornercase for stretch not responding with 202
         if method == "put" and resp.status == 200:
             return
@@ -164,9 +134,9 @@ class SmileComm:
         try:
             # Encode to ensure utf8 parsing
             xml = etree.XML(escape_illegal_xml_characters(result).encode())
-        except etree.ParseError:
+        except etree.ParseError as exc:
             LOGGER.warning("Smile returns invalid XML for %s", self._endpoint)
-            raise InvalidXMLError
+            raise InvalidXMLError from exc
 
         return xml
 
@@ -202,15 +172,15 @@ class SmileComm:
                 )
         except (
             ClientError
-        ) as err:  # ClientError is an ancestor class of ServerTimeoutError
+        ) 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,
-                    err,
+                    exc,
                 )
-                raise ConnectionFailedError
+                raise ConnectionFailedError from exc
             return await self._request(command, retry - 1)
 
         return await self._request_validate(resp, method)
@@ -225,33 +195,29 @@ class SmileHelper:
 
     def __init__(self) -> None:
         """Set the constructor for this class."""
-        self._appliances: etree
         self._cooling_activation_outdoor_temp: float
         self._cooling_deactivation_threshold: float
-        self._cooling_present = False
+        self._cooling_present: bool
         self._count: int
         self._dhw_allowed_modes: list[str] = []
         self._domain_objects: etree
-        self._elga = False
+        self._endpoint: str
+        self._elga: bool
         self._gw_allowed_modes: list[str] = []
         self._heater_id: str
         self._home_location: str
-        self._is_thermostat = False
-        self._last_active: dict[str, str | None] = {}
+        self._is_thermostat: bool
+        self._last_active: dict[str, str | None]
         self._last_modified: dict[str, str] = {}
-        self._locations: etree
-        self._loc_data: dict[str, ThermoLoc] = {}
-        self._modules: etree
         self._notifications: dict[str, dict[str, str]] = {}
-        self._on_off_device = False
-        self._opentherm_device = False
+        self._on_off_device: bool
+        self._opentherm_device: bool
         self._outdoor_temp: float
         self._reg_allowed_modes: list[str] = []
         self._schedule_old_states: dict[str, dict[str, str]] = {}
         self._smile_legacy = False
         self._status: etree
-        self._stretch_v2 = False
-        self._stretch_v3 = False
+        self._stretch_v2: bool
         self._system: etree
         self._thermo_locs: dict[str, ThermoLoc] = {}
         ###################################################################
@@ -270,17 +236,16 @@ class SmileHelper:
         self._cooling_enabled = False
 
         self.device_items: int = 0
-        self.device_list: list[str]
         self.gateway_id: str
         self.gw_data: GatewayData = {}
         self.gw_devices: dict[str, DeviceData] = {}
+        self.loc_data: dict[str, ThermoLoc]
         self.smile_fw_version: str | None = None
         self.smile_hw_version: str | None = None
         self.smile_mac_address: str | None = None
         self.smile_model: str
         self.smile_name: str
         self.smile_type: str
-        self.smile_version: tuple[str, semver.version.Version]
         self.smile_zigbee_mac_address: str | None = None
         self.therms_with_offset_func: list[str] = []
 
@@ -291,34 +256,14 @@ class SmileHelper:
     def _all_locations(self) -> None:
         """Collect all locations."""
         loc = Munch()
-
-        locations = self._locations.findall("./location")
-        # Legacy Anna without outdoor_temp and Stretches have no locations, create fake location-data
-        if not locations and self._smile_legacy:
-            self._home_location = FAKE_LOC
-            self._loc_data[FAKE_LOC] = {"name": "Home"}
-            return
-
+        locations = self._domain_objects.findall("./location")
         for location in locations:
             loc.name = location.find("name").text
             loc.loc_id = location.attrib["id"]
-            # Filter the valid single location for P1 legacy: services not empty
-            locator = "./services"
-            if (
-                self._smile_legacy
-                and self.smile_type == "power"
-                and len(location.find(locator)) == 0
-            ):
-                continue
-
             if loc.name == "Home":
                 self._home_location = loc.loc_id
-            # Replace location-name for P1 legacy, can contain privacy-related info
-            if self._smile_legacy and self.smile_type == "power":
-                loc.name = "Home"
-                self._home_location = loc.loc_id
 
-            self._loc_data[loc.loc_id] = {"name": loc.name}
+            self.loc_data[loc.loc_id] = {"name": loc.name}
 
     def _get_module_data(
         self, appliance: etree, locator: str, mod_type: str
@@ -338,9 +283,9 @@ class SmileHelper:
         }
         if (appl_search := appliance.find(locator)) is not None:
             link_id = appl_search.attrib["id"]
-            loc = f".//{mod_type}[@id='{link_id}']...."
+            loc = f".//services/{mod_type}[@id='{link_id}']...."
             # Not possible to walrus for some reason...
-            module = self._modules.find(loc)
+            module = self._domain_objects.find(loc)
             if module is not None:  # pylint: disable=consider-using-assignment-expr
                 model_data["contents"] = True
                 if (vendor_name := module.find("vendor_name").text) is not None:
@@ -354,12 +299,6 @@ class SmileHelper:
                 if (zb_node := module.find("./protocols/zig_bee_node")) is not None:
                     model_data["zigbee_mac_address"] = zb_node.find("mac_address").text
                     model_data["reachable"] = zb_node.find("reachable").text == "true"
-                # Stretches
-                if (router := module.find("./protocols/network_router")) is not None:
-                    model_data["zigbee_mac_address"] = router.find("mac_address").text
-                # Also look for the Circle+/Stealth M+
-                if (coord := module.find("./protocols/network_coordinator")) is not None:
-                    model_data["zigbee_mac_address"] = coord.find("mac_address").text
 
         return model_data
 
@@ -368,24 +307,14 @@ class SmileHelper:
 
         Collect energy device info (Circle, Plug, Stealth): firmware, model and vendor name.
         """
-        if self.smile_type in ("power", "stretch"):
-            locator = "./services/electricity_point_meter"
-            if not self._smile_legacy:
-                locator = "./logs/point_log/electricity_point_meter"
+        if self.smile_type == "power":
+            locator = "./logs/point_log/electricity_point_meter"
             mod_type = "electricity_point_meter"
-
             module_data = self._get_module_data(appliance, locator, mod_type)
-            # Filter appliance without zigbee_mac, it's an orphaned device
             appl.zigbee_mac = module_data["zigbee_mac_address"]
-            if appl.zigbee_mac is None and self.smile_type != "power":
-                return None
-
             appl.hardware = module_data["hardware_version"]
             appl.model = module_data["vendor_model"]
             appl.vendor_name = module_data["vendor_name"]
-            if appl.hardware is not None:
-                hw_version = appl.hardware.replace("-", "")
-                appl.model = version_to_model(hw_version)
             appl.firmware = module_data["firmware_version"]
 
             return appl
@@ -422,7 +351,7 @@ class SmileHelper:
 
             # Adam: look for the ZigBee MAC address of the Smile
             if self.smile(ADAM) and (
-                (found := self._modules.find(".//protocols/zig_bee_coordinator")) is not None
+                (found := self._domain_objects.find(".//protocols/zig_bee_coordinator")) is not None
             ):
                 appl.zigbee_mac = found.find("mac_address").text
 
@@ -463,7 +392,7 @@ class SmileHelper:
         if appl.pwclass == "heater_central":
             # Remove heater_central when no active device present
             if not self._opentherm_device and not self._on_off_device:
-                return None
+                return None  # pragma: no cover
 
             # Find the valid heater_central
             self._heater_id = self._check_heater_central()
@@ -504,7 +433,7 @@ class SmileHelper:
 
             return appl
 
-        # Collect info from Stretches
+        # Collect info from power-related devices (Plug, Aqara Smart Plug)
         appl = self._energy_device_info_finder(appliance, appl)
 
         return appl
@@ -518,7 +447,7 @@ class SmileHelper:
         locator = "./appliance[type='heater_central']"
         hc_count = 0
         hc_list: list[dict[str, bool]] = []
-        for heater_central in self._appliances.findall(locator):
+        for heater_central in self._domain_objects.findall(locator):
             hc_count += 1
             hc_id: str = heater_central.attrib["id"]
             has_actuators: bool = (
@@ -539,17 +468,15 @@ class SmileHelper:
 
     def _p1_smartmeter_info_finder(self, appl: Munch) -> None:
         """Collect P1 DSMR Smartmeter info."""
-        loc_id = next(iter(self._loc_data.keys()))
+        loc_id = next(iter(self.loc_data.keys()))
         appl.dev_id = self.gateway_id
         appl.location = loc_id
-        if self._smile_legacy:
-            appl.dev_id = loc_id
         appl.mac = None
         appl.model = self.smile_model
         appl.name = "P1"
         appl.pwclass = "smartmeter"
         appl.zigbee_mac = None
-        location = self._locations.find(f'./location[@id="{loc_id}"]')
+        location = self._domain_objects.find(f'./location[@id="{loc_id}"]')
         appl = self._energy_device_info_finder(location, appl)
 
         self.gw_devices[appl.dev_id] = {"dev_class": appl.pwclass}
@@ -570,46 +497,12 @@ class SmileHelper:
                 self.gw_devices[appl.dev_id][p1_key] = value
                 self._count += 1
 
-    def _create_legacy_gateway(self) -> None:
-        """Create the (missing) gateway devices for legacy Anna, P1 and Stretch.
-
-        Use the home_location or FAKE_APPL as device id.
-        """
-        self.gateway_id = self._home_location
-        if self.smile_type == "power":
-            self.gateway_id = FAKE_APPL
-
-        self.gw_devices[self.gateway_id] = {"dev_class": "gateway"}
-        self._count += 1
-        for key, value in {
-            "firmware": self.smile_fw_version,
-            "location": self._home_location,
-            "mac_address": self.smile_mac_address,
-            "model": self.smile_model,
-            "name": self.smile_name,
-            "zigbee_mac_address": self.smile_zigbee_mac_address,
-            "vendor": "Plugwise",
-        }.items():
-            if value is not None:
-                gw_key = cast(ApplianceType, key)
-                self.gw_devices[self.gateway_id][gw_key] = value
-                self._count += 1
-
     def _all_appliances(self) -> None:
         """Collect all appliances with relevant info."""
         self._count = 0
         self._all_locations()
 
-        if self._smile_legacy:
-            self._create_legacy_gateway()
-            # For legacy P1 collect the connected SmartMeter info
-            if self.smile_type == "power":
-                appl = Munch()
-                self._p1_smartmeter_info_finder(appl)
-                # Legacy P1 has no more devices
-                return
-
-        for appliance in self._appliances.findall("./appliance"):
+        for appliance in self._domain_objects.findall("./appliance"):
             appl = Munch()
             appl.pwclass = appliance.find("type").text
             # Skip thermostats that have this key, should be an orphaned device (Core #81712)
@@ -622,11 +515,9 @@ class SmileHelper:
             appl.location = None
             if (appl_loc := appliance.find("location")) is not None:
                 appl.location = appl_loc.attrib["id"]
-            # Provide a location for legacy_anna, also don't assign the _home_location
-            # to thermostat-devices without a location, they are not active
-            elif (
-                self._smile_legacy and self.smile_type == "thermostat"
-            ) or appl.pwclass not in THERMOSTAT_CLASSES:
+            # Don't assign the _home_location to thermostat-devices without a location,
+            # they are not active
+            elif appl.pwclass not in THERMOSTAT_CLASSES:
                 appl.location = self._home_location
 
             appl.dev_id = appliance.attrib["id"]
@@ -639,7 +530,7 @@ class SmileHelper:
             appl.vendor_name = None
 
             # Determine class for this appliance
-            # Skip on heater_central when no active device present or on orphaned stretch devices
+            # Skip on heater_central when no active device present
             if not (appl := self._appliance_info_finder(appliance, appl)):
                 continue
 
@@ -652,12 +543,8 @@ class SmileHelper:
             if appl.pwclass == "gateway" and self.smile_type == "power":
                 appl.dev_id = appl.location
 
-            # Don't show orphaned non-legacy thermostat-types or the OpenTherm Gateway.
-            if (
-                not self._smile_legacy
-                and appl.pwclass in THERMOSTAT_CLASSES
-                and appl.location is None
-            ):
+            # Don't show orphaned thermostat-types or the OpenTherm Gateway.
+            if appl.pwclass in THERMOSTAT_CLASSES and appl.location is None:
                 continue
 
             self.gw_devices[appl.dev_id] = {"dev_class": appl.pwclass}
@@ -677,7 +564,7 @@ class SmileHelper:
                     self.gw_devices[appl.dev_id][appl_key] = value
                     self._count += 1
 
-        # For non-legacy P1 collect the connected SmartMeter info
+        # For P1 collect the connected SmartMeter info
         if self.smile_type == "power":
             self._p1_smartmeter_info_finder(appl)
             # P1: for gateway and smartmeter switch device_id - part 2
@@ -697,22 +584,6 @@ class SmileHelper:
                     add_to_front = {dev_id: tmp_device}
                     self.gw_devices = {**add_to_front, **cleared_dict}
 
-    def _match_locations(self) -> dict[str, ThermoLoc]:
-        """Helper-function for _scan_thermostats().
-
-        Match appliances with locations.
-        """
-        matched_locations: dict[str, ThermoLoc] = {}
-        for location_id, location_details in self._loc_data.items():
-            for appliance_details in self.gw_devices.values():
-                if appliance_details["location"] == location_id:
-                    location_details.update(
-                        {"master": None, "master_prio": 0, "slaves": set()}
-                    )
-                    matched_locations[location_id] = location_details
-
-        return matched_locations
-
     def _control_state(self, loc_id: str) -> str | bool:
         """Helper-function for _device_data_adam().
 
@@ -728,28 +599,11 @@ class SmileHelper:
 
         return False
 
-    def _presets_legacy(self) -> dict[str, list[float]]:
-        """Helper-function for presets() - collect Presets for a legacy Anna."""
-        presets: dict[str, list[float]] = {}
-        for directive in self._domain_objects.findall("rule/directives/when/then"):
-            if directive is not None and directive.get("icon") is not None:
-                # Ensure list of heating_setpoint, cooling_setpoint
-                presets[directive.attrib["icon"]] = [
-                    float(directive.attrib["temperature"]),
-                    0,
-                ]
-
-        return presets
-
     def _presets(self, loc_id: str) -> dict[str, list[float]]:
         """Collect Presets for a Thermostat based on location_id."""
         presets: dict[str, list[float]] = {}
         tag_1 = "zone_setpoint_and_state_based_on_preset"
         tag_2 = "Thermostat presets"
-
-        if self._smile_legacy:
-            return self._presets_legacy()
-
         if not (rule_ids := self._rule_ids_by_tag(tag_1, loc_id)):
             if not (rule_ids := self._rule_ids_by_name(tag_2, loc_id)):
                 return presets  # pragma: no cover
@@ -767,35 +621,38 @@ class SmileHelper:
 
         return presets
 
-    def _rule_ids_by_name(self, name: str, loc_id: str) -> dict[str, str]:
+    def _rule_ids_by_name(self, name: str, loc_id: str) -> dict[str, dict[str, str]]:
         """Helper-function for _presets().
 
         Obtain the rule_id from the given name and and provide the location_id, when present.
         """
-        schedule_ids: dict[str, str] = {}
+        schedule_ids: dict[str, dict[str, str]] = {}
         locator = f'./contexts/context/zone/location[@id="{loc_id}"]'
         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"]] = loc_id
+                schedule_ids[rule.attrib["id"]] = {"location": loc_id, "name": name, "active": active}
             else:
-                schedule_ids[rule.attrib["id"]] = NONE
+                schedule_ids[rule.attrib["id"]] = {"location": NONE, "name": name, "active": active}
 
         return schedule_ids
 
-    def _rule_ids_by_tag(self, tag: str, loc_id: str) -> dict[str, str]:
+    def _rule_ids_by_tag(self, tag: str, loc_id: str) -> dict[str, dict[str, str]]:
         """Helper-function for _presets(), _schedules() and _last_active_schedule().
 
         Obtain the rule_id from the given template_tag and provide the location_id, when present.
         """
-        schedule_ids: dict[str, str] = {}
+        schedule_ids: dict[str, dict[str, str]] = {}
         locator1 = f'./template[@tag="{tag}"]'
         locator2 = f'./contexts/context/zone/location[@id="{loc_id}"]'
         for rule in self._domain_objects.findall("./rule"):
             if rule.find(locator1) is not None:
+                name = rule.find("name").text
+                active = rule.find("active").text
                 if rule.find(locator2) is not None:
-                    schedule_ids[rule.attrib["id"]] = loc_id
+                    schedule_ids[rule.attrib["id"]] = {"location": loc_id, "name": name, "active": active}
                 else:
-                    schedule_ids[rule.attrib["id"]] = NONE
+                    schedule_ids[rule.attrib["id"]] = {"location": NONE, "name": name, "active": active}
 
         return schedule_ids
 
@@ -809,9 +666,6 @@ class SmileHelper:
         for measurement, attrs in measurements.items():
             p_locator = f'.//logs/point_log[type="{measurement}"]/period/measurement'
             if (appl_p_loc := appliance.find(p_locator)) is not None:
-                if self._smile_legacy and measurement == "domestic_hot_water_state":
-                    continue
-
                 # Skip known obsolete measurements
                 updated_date_locator = (
                     f'.//logs/point_log[type="{measurement}"]/updated_date'
@@ -882,10 +736,10 @@ class SmileHelper:
         # Don't count the above top-level dicts, only the remaining single items
         self._count += len(data) - 3
 
-    def _wireless_availablity(self, appliance: etree, data: DeviceData) -> None:
+    def _wireless_availability(self, appliance: etree, data: DeviceData) -> None:
         """Helper-function for _get_measurement_data().
 
-        Collect the availablity-status for wireless connected devices.
+        Collect the availability-status for wireless connected devices.
         """
         if self.smile(ADAM):
             # Collect for Plugs
@@ -905,7 +759,7 @@ class SmileHelper:
     def _get_appliances_with_offset_functionality(self) -> list[str]:
         """Helper-function collecting all appliance that have offset_functionality."""
         therm_list: list[str] = []
-        offset_appls = self._appliances.findall(
+        offset_appls = self._domain_objects.findall(
             './/actuator_functionalities/offset_functionality[type="temperature_offset"]/offset/../../..'
         )
         for item in offset_appls:
@@ -929,10 +783,6 @@ class SmileHelper:
             functionality = "thermostat_functionality"
             if item == "temperature_offset":
                 functionality = "offset_functionality"
-                # Don't support temperature_offset for legacy Anna
-                if self._smile_legacy:
-                    continue
-
             # When there is no updated_date-text, skip the actuator
             updated_date_location = f'.//actuator_functionalities/{functionality}[type="{item}"]/updated_date'
             if (
@@ -1048,19 +898,16 @@ class SmileHelper:
         Collect the appliance-data based on device id.
         """
         data: DeviceData = {"binary_sensors": {}, "sensors": {}, "switches": {}}
-        # Get P1 smartmeter data from LOCATIONS or MODULES
+        # Get P1 smartmeter data from LOCATIONS
         device = self.gw_devices[dev_id]
         # !! DON'T CHANGE below two if-lines, will break stuff !!
         if self.smile_type == "power":
             if device["dev_class"] == "smartmeter":
-                if not self._smile_legacy:
-                    data.update(self._power_data_from_location(device["location"]))
-                else:
-                    data.update(self._power_data_from_modules())
+                 data.update(self._power_data_from_location(device["location"]))
 
             return data
 
-        # Get non-p1 data from APPLIANCES, for legacy from DOMAIN_OBJECTS.
+        # Get non-P1 data from APPLIANCES
         measurements = DEVICE_MEASUREMENTS
         if self._is_thermostat and dev_id == self._heater_id:
             measurements = HEATER_CENTRAL_MEASUREMENTS
@@ -1070,7 +917,7 @@ class SmileHelper:
                 # Counting of this item is done in _appliance_measurements()
 
         if (
-            appliance := self._appliances.find(f'./appliance[@id="{dev_id}"]')
+            appliance := self._domain_objects.find(f'./appliance[@id="{dev_id}"]')
         ) is not None:
             self._appliance_measurements(appliance, data, measurements)
             self._get_lock_state(appliance, data)
@@ -1082,7 +929,7 @@ class SmileHelper:
                 self._get_actuator_functionalities(appliance, device, data)
 
             # Collect availability-status for wireless connected devices to Adam
-            self._wireless_availablity(appliance, data)
+            self._wireless_availability(appliance, data)
 
         if dev_id == self.gateway_id and self.smile(ADAM):
             self._get_regulation_mode(appliance, data)
@@ -1137,33 +984,6 @@ class SmileHelper:
 
         return data
 
-    def _rank_thermostat(
-        self,
-        thermo_matching: dict[str, int],
-        loc_id: str,
-        appliance_id: str,
-        appliance_details: DeviceData,
-    ) -> None:
-        """Helper-function for _scan_thermostats().
-
-        Rank the thermostat based on appliance_details: master or slave.
-        """
-        appl_class = appliance_details["dev_class"]
-        appl_d_loc = appliance_details["location"]
-        if loc_id == appl_d_loc and appl_class in thermo_matching:
-            # Pre-elect new master
-            if thermo_matching[appl_class] > self._thermo_locs[loc_id]["master_prio"]:
-                # Demote former master
-                if (tl_master := self._thermo_locs[loc_id]["master"]) is not None:
-                    self._thermo_locs[loc_id]["slaves"].add(tl_master)
-
-                # Crown master
-                self._thermo_locs[loc_id]["master_prio"] = thermo_matching[appl_class]
-                self._thermo_locs[loc_id]["master"] = appliance_id
-
-            else:
-                self._thermo_locs[loc_id]["slaves"].add(appliance_id)
-
     def _scan_thermostats(self) -> None:
         """Helper-function for smile.py: get_all_devices().
 
@@ -1190,26 +1010,56 @@ class SmileHelper:
                 if "slaves" in tl_loc_id and dev_id in tl_loc_id["slaves"]:
                     device["dev_class"] = "thermo_sensor"
 
-    def _thermostat_uri_legacy(self) -> str:
-        """Helper-function for _thermostat_uri().
+    def _match_locations(self) -> dict[str, ThermoLoc]:
+        """Helper-function for _scan_thermostats().
 
-        Determine the location-set_temperature uri - from APPLIANCES.
+        Match appliances with locations.
         """
-        locator = "./appliance[type='thermostat']"
-        appliance_id = self._appliances.find(locator).attrib["id"]
+        matched_locations: dict[str, ThermoLoc] = {}
+        for location_id, location_details in self.loc_data.items():
+            for appliance_details in self.gw_devices.values():
+                if appliance_details["location"] == location_id:
+                    location_details.update(
+                        {"master": None, "master_prio": 0, "slaves": set()}
+                    )
+                    matched_locations[location_id] = location_details
+
+        return matched_locations
 
-        return f"{APPLIANCES};id={appliance_id}/thermostat"
+    def _rank_thermostat(
+        self,
+        thermo_matching: dict[str, int],
+        loc_id: str,
+        appliance_id: str,
+        appliance_details: DeviceData,
+    ) -> None:
+        """Helper-function for _scan_thermostats().
+
+        Rank the thermostat based on appliance_details: master or slave.
+        """
+        appl_class = appliance_details["dev_class"]
+        appl_d_loc = appliance_details["location"]
+        if loc_id == appl_d_loc and appl_class in thermo_matching:
+            # Pre-elect new master
+            if thermo_matching[appl_class] > self._thermo_locs[loc_id]["master_prio"]:
+                # Demote former master
+                if (tl_master := self._thermo_locs[loc_id]["master"]) is not None:
+                    self._thermo_locs[loc_id]["slaves"].add(tl_master)
+
+                # Crown master
+                self._thermo_locs[loc_id]["master_prio"] = thermo_matching[appl_class]
+                self._thermo_locs[loc_id]["master"] = appliance_id
+
+            else:
+                self._thermo_locs[loc_id]["slaves"].add(appliance_id)
 
     def _thermostat_uri(self, loc_id: str) -> str:
         """Helper-function for smile.py: set_temperature().
 
         Determine the location-set_temperature uri - from LOCATIONS.
         """
-        if self._smile_legacy:
-            return self._thermostat_uri_legacy()
-
         locator = f'./location[@id="{loc_id}"]/actuator_functionalities/thermostat_functionality'
-        thermostat_functionality_id = self._locations.find(locator).attrib["id"]
+        thermostat_functionality_id = self._domain_objects.find(locator).attrib["id"]
 
         return f"{LOCATIONS};id={loc_id}/thermostat;id={thermostat_functionality_id}"
 
@@ -1229,8 +1079,8 @@ class SmileHelper:
             group_name = group.find("name").text
             group_type = group.find("type").text
             group_appliances = group.findall("appliances/appliance")
+            # Check if members are not orphaned
             for item in group_appliances:
-                # Check if members are not orphaned - stretch
                 if item.attrib["id"] in self.gw_devices:
                     members.append(item.attrib["id"])
 
@@ -1257,7 +1107,7 @@ class SmileHelper:
         """
         loc_found: int = 0
         open_valve_count: int = 0
-        for appliance in self._appliances.findall("./appliance"):
+        for appliance in self._domain_objects.findall("./appliance"):
             locator = './logs/point_log[type="valve_position"]/period/measurement'
             if (appl_loc := appliance.find(locator)) is not None:
                 loc_found += 1
@@ -1301,7 +1151,6 @@ class SmileHelper:
         """Helper-function for _power_data_from_location() and _power_data_from_modules()."""
         loc.found = True
         # If locator not found look for P1 gas_consumed or phase data (without tariff)
-        # or for P1 legacy electricity_point_meter or gas_*_meter data
         if loc.logs.find(loc.locator) is None:
             if "log" in loc.log_type and (
                 "gas" in loc.measurement or "phase" in loc.measurement
@@ -1317,25 +1166,9 @@ class SmileHelper:
                 if loc.logs.find(loc.locator) is None:
                     loc.found = False
                     return loc
-            # P1 legacy point_meter has no tariff_indicator
-            elif "meter" in loc.log_type and (
-                "point" in loc.log_type or "gas" in loc.measurement
-            ):
-                # Avoid double processing by skipping one peak-list option
-                if loc.peak_select == "nl_offpeak":
-                    loc.found = False
-                    return loc
-
-                loc.locator = (
-                    f"./{loc.meas_list[0]}_{loc.log_type}/"
-                    f'measurement[@directionality="{loc.meas_list[1]}"]'
-                )
-                if loc.logs.find(loc.locator) is None:
-                    loc.found = False
-                    return loc
             else:
-                loc.found = False
-                return loc
+                loc.found = False  # pragma: no cover
+                return loc  # pragma: no cover
 
         if (peak := loc.peak_select.split("_")[1]) == "offpeak":
             peak = "off_peak"
@@ -1362,7 +1195,7 @@ class SmileHelper:
         peak_list: list[str] = ["nl_peak", "nl_offpeak"]
         t_string = "tariff"
 
-        search = self._locations
+        search = self._domain_objects
         loc.logs = search.find(f'./location[@id="{loc_id}"]/logs')
         for loc.measurement, loc.attrs in P1_MEASUREMENTS.items():
             for loc.log_type in log_list:
@@ -1384,92 +1217,16 @@ class SmileHelper:
         self._count += len(direct_data["sensors"])
         return direct_data
 
-    def _power_data_from_modules(self) -> DeviceData:
-        """Helper-function for smile.py: _get_device_data().
-
-        Collect the power-data from MODULES (P1 legacy only).
-        """
-        direct_data: DeviceData = {"sensors": {}}
-        loc = Munch()
-        mod_list: list[str] = ["interval_meter", "cumulative_meter", "point_meter"]
-        peak_list: list[str] = ["nl_peak", "nl_offpeak"]
-        t_string = "tariff_indicator"
-
-        search = self._modules
-        mod_logs = search.findall("./module/services")
-        for loc.measurement, loc.attrs in P1_LEGACY_MEASUREMENTS.items():
-            loc.meas_list = loc.measurement.split("_")
-            for loc.logs in mod_logs:
-                for loc.log_type in mod_list:
-                    for loc.peak_select in peak_list:
-                        loc.locator = (
-                            f"./{loc.meas_list[0]}_{loc.log_type}/measurement"
-                            f'[@directionality="{loc.meas_list[1]}"][@{t_string}="{loc.peak_select}"]'
-                        )
-                        loc = self._power_data_peak_value(loc)
-                        if not loc.found:
-                            continue
-
-                        direct_data = self.power_data_energy_diff(
-                            loc.measurement, loc.net_string, loc.f_val, direct_data
-                        )
-                        key = cast(SensorType, loc.key_string)
-                        direct_data["sensors"][key] = loc.f_val
-
-        self._count += len(direct_data["sensors"])
-        return direct_data
-
     def _preset(self, loc_id: str) -> str | None:
         """Helper-function for smile.py: device_data_climate().
 
         Collect the active preset based on Location ID.
         """
-        if not self._smile_legacy:
-            locator = f'./location[@id="{loc_id}"]/preset'
-            if (preset := self._domain_objects.find(locator)) is not None:
-                return str(preset.text)
-            return None
+        locator = f'./location[@id="{loc_id}"]/preset'
+        if (preset := self._domain_objects.find(locator)) is not None:
+            return str(preset.text)
 
-        locator = "./rule[active='true']/directives/when/then"
-        if (
-            not (active_rule := etree_to_dict(self._domain_objects.find(locator)))
-            or "icon" not in active_rule
-        ):
-            return None
-
-        return active_rule["icon"]
-
-    def _schedules_legacy(
-        self,
-        avail: list[str],
-        location: str,
-        sel: str,
-    ) -> tuple[list[str], str]:
-        """Helper-function for _schedules().
-
-        Collect available schedules/schedules for the legacy thermostat.
-        """
-        name: str | None = None
-
-        search = self._domain_objects
-        for schedule in search.findall("./rule"):
-            if rule_name := schedule.find("name").text:
-                if "preset" not in rule_name:
-                    name = rule_name
-
-        log_type = "schedule_state"
-        locator = f"./appliance[type='thermostat']/logs/point_log[type='{log_type}']/period/measurement"
-        active = False
-        if (result := search.find(locator)) is not None:
-            active = result.text == "on"
-
-        if name is not None:
-            avail = [name]
-            if active:
-                sel = name
-
-        self._last_active[location] = "".join(map(str, avail))
-        return avail, sel
+        return None  # pragma: no cover
 
     def _schedules(self, location: str) -> tuple[list[str], str]:
         """Helper-function for smile.py: _device_data_climate().
@@ -1478,13 +1235,8 @@ class SmileHelper:
         NEW: when a location_id is present then the schedule is active. Valid for both Adam and non-legacy Anna.
         """
         available: list[str] = [NONE]
-        rule_ids: dict[str, str] = {}
+        rule_ids: dict[str, dict[str, str]] = {}
         selected = NONE
-
-        # Legacy Anna schedule, only one schedule allowed
-        if self._smile_legacy:
-            return self._schedules_legacy(available, location, selected)
-
         # Adam schedules, one schedule can be linked to various locations
         # self._last_active contains the locations and the active schedule name per location, or None
         if location not in self._last_active:
@@ -1495,15 +1247,16 @@ class SmileHelper:
             return available, selected
 
         schedules: list[str] = []
-        for rule_id, loc_id in rule_ids.items():
-            name = self._domain_objects.find(f'./rule[@id="{rule_id}"]/name').text
+        for rule_id, data in rule_ids.items():
+            active = data["active"] == "true"
+            name = data["name"]
             locator = f'./rule[@id="{rule_id}"]/directives'
             # Show an empty schedule as no schedule found
             if self._domain_objects.find(locator) is None:
                 continue  # pragma: no cover
 
             available.append(name)
-            if location == loc_id:
+            if location == data["location"] and active:
                 selected = name
                 self._last_active[location] = selected
             schedules.append(name)
@@ -1542,7 +1295,6 @@ class SmileHelper:
         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
 
         return val
 
@@ -1553,9 +1305,6 @@ class SmileHelper:
         """
         actuator = "actuator_functionalities"
         func_type = "relay_functionality"
-        if self._stretch_v2:
-            actuator = "actuators"
-            func_type = "relay"
         if xml.find("type").text not in SPECIAL_PLUG_TYPES:
             locator = f"./{actuator}/{func_type}/lock"
             if (found := xml.find(locator)) is not None:
@@ -1574,8 +1323,19 @@ class SmileHelper:
             if (state := xml.find(locator)) is not None:
                 data["switches"][name] = state.text == "on"
                 self._count += 1
-                # Remove the cooling_enabled binary_sensor when the corresponding switch is present
-                # Except for Elga
-                if toggle == "cooling_enabled" and not self._elga:
-                    data["binary_sensors"].pop("cooling_enabled")
-                    self._count -= 1
+
+    def _get_plugwise_notifications(self) -> None:
+        """Collect the Plugwise notifications."""
+        self._notifications = {}
+        for notification in self._domain_objects.findall("./notification"):
+            try:
+                msg_id = notification.attrib["id"]
+                msg_type = notification.find("type").text
+                msg = notification.find("message").text
+                self._notifications.update({msg_id: {msg_type: msg}})
+                LOGGER.debug("Plugwise notifications: %s", self._notifications)
+            except AttributeError:  # pragma: no cover
+                LOGGER.debug(
+                    "Plugwise notification present but unable to process, manually investigate: %s",
+                    f"{self._endpoint}{DOMAIN_OBJECTS}",
+                )