plugwise 0.37.1a2__py3-none-any.whl → 0.37.2__py3-none-any.whl

plugwise/helper.py

@@ -27,13 +27,10 @@ from plugwise.constants import (
     LOCATIONS,
     LOGGER,
     NONE,
-    OBSOLETE_MEASUREMENTS,
     OFF,
     P1_MEASUREMENTS,
     SENSORS,
-    SPECIAL_PLUG_TYPES,
     SPECIALS,
-    SWITCH_GROUP_TYPES,
     SWITCHES,
     TEMP_CELSIUS,
     THERMOSTAT_CLASSES,
@@ -42,7 +39,6 @@ from plugwise.constants import (
     ActuatorData,
     ActuatorDataType,
     ActuatorType,
-    ApplianceType,
     BinarySensorType,
     DeviceData,
     GatewayData,
@@ -62,7 +58,7 @@ from plugwise.util import (
     check_model,
     escape_illegal_xml_characters,
     format_measure,
-    power_data_local_format,
+    skip_obsolete_measurements,
 )
 
 # This way of importing aiohttp is because of patch/mocking in testing (aiohttp timeouts)
@@ -112,34 +108,6 @@ class SmileComm:
         self._endpoint = f"http://{host}:{str(port)}"
         self._timeout = timeout
 
-    async def _request_validate(self, resp: ClientResponse, method: str) -> etree:
-        """Helper-function for _request(): validate the returned data."""
-        # 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
-
-        if resp.status == 401:
-            msg = "Invalid Plugwise login, please retry with the correct credentials."
-            LOGGER.error("%s", msg)
-            raise InvalidAuthentication
-
-        if not (result := await resp.text()) or "<error>" 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 _request(
         self,
         command: str,
@@ -185,6 +153,34 @@ class SmileComm:
 
         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."""
+        # 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
+
+        if resp.status == 401:
+            msg = "Invalid Plugwise login, please retry with the correct credentials."
+            LOGGER.error("%s", msg)
+            raise InvalidAuthentication
+
+        if not (result := await resp.text()) or "<error>" 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()
@@ -195,8 +191,6 @@ class SmileHelper(SmileCommon):
 
     def __init__(self) -> None:
         """Set the constructor for this class."""
-        self._cooling_activation_outdoor_temp: float
-        self._cooling_deactivation_threshold: float
         self._cooling_present: bool
         self._count: int
         self._dhw_allowed_modes: list[str] = []
@@ -212,7 +206,6 @@ class SmileHelper(SmileCommon):
         self._notifications: dict[str, dict[str, str]] = {}
         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._status: etree
@@ -248,144 +241,6 @@ class SmileHelper(SmileCommon):
         self.therms_with_offset_func: list[str] = []
         SmileCommon.__init__(self)
 
-    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 _energy_device_info_finder(self, appliance: etree, appl: Munch) -> Munch:
-        """Helper-function for _appliance_info_finder().
-
-        Collect energy device info (Smartmeter, Plug): firmware, model and vendor name.
-        """
-        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)
-            appl.hardware = module_data["hardware_version"]
-            appl.model = module_data["vendor_model"]
-            appl.vendor_name = module_data["vendor_name"]
-            appl.firmware = module_data["firmware_version"]
-
-            return appl
-
-        if self.smile(ADAM):
-            locator = "./logs/interval_log/electricity_interval_meter"
-            mod_type = "electricity_interval_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:
-                return None
-
-            appl.vendor_name = module_data["vendor_name"]
-            appl.model = check_model(module_data["vendor_model"], appl.vendor_name)
-            appl.hardware = module_data["hardware_version"]
-            appl.firmware = module_data["firmware_version"]
-
-            return appl
-
-        return appl  # pragma: no cover
-
-    def _appliance_info_finder(self, appl: Munch, appliance: etree) -> Munch:
-        """Collect device info (Smile/Stretch, Thermostats, OpenTherm/On-Off): firmware, model and vendor name."""
-        # Collect gateway device info
-        if appl.pwclass == "gateway":
-            self.gateway_id = appliance.attrib["id"]
-            appl.firmware = self.smile_fw_version
-            appl.hardware = self.smile_hw_version
-            appl.mac = self.smile_mac_address
-            appl.model = self.smile_model
-            appl.name = self.smile_name
-            appl.vendor_name = "Plugwise"
-
-            # Adam: look for the ZigBee MAC address of the Smile
-            if self.smile(ADAM) and (
-                (found := self._domain_objects.find(".//protocols/zig_bee_coordinator")) is not None
-            ):
-                appl.zigbee_mac = found.find("mac_address").text
-
-            # Adam: collect regulation_modes and check for cooling, indicating cooling-mode is present
-            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
-
-            # Adam: check for presence of gateway_modes
-            self._gw_allowed_modes = []
-            locator = "./actuator_functionalities/gateway_mode_control_functionality[type='gateway_mode']/allowed_modes"
-            if appliance.find(locator) is not None:
-                # Limit the possible gateway-modes
-                self._gw_allowed_modes = ["away", "full", "vacation"]
-
-            return appl
-
-        # Collect thermostat device info
-        if appl.pwclass in THERMOSTAT_CLASSES:
-            return self._appl_thermostat_info(appl, appliance)
-
-        # Collect extra heater_central device info
-        if appl.pwclass == "heater_central":
-            appl = self._appl_heater_central_info(appl, appliance)
-            # Anna + Loria: collect dhw control operation modes
-            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
-
-            return appl
-
-        # Collect info from power-related devices (Plug, Aqara Smart Plug)
-        appl = self._energy_device_info_finder(appliance, appl)
-
-        return appl
-
-    def _p1_smartmeter_info_finder(self, appl: Munch) -> None:
-        """Collect P1 DSMR Smartmeter info."""
-        loc_id = next(iter(self.loc_data.keys()))
-        appl.dev_id = self.gateway_id
-        appl.location = loc_id
-        appl.mac = None
-        appl.model = self.smile_model
-        appl.name = "P1"
-        appl.pwclass = "smartmeter"
-        appl.zigbee_mac = None
-        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}
-        self._count += 1
-
-        for key, value in {
-            "firmware": appl.firmware,
-            "hardware": appl.hardware,
-            "location": appl.location,
-            "mac_address": appl.mac,
-            "model": appl.model,
-            "name": appl.name,
-            "zigbee_mac_address": appl.zigbee_mac,
-            "vendor": appl.vendor_name,
-        }.items():
-            if value is not None or key == "location":
-                p1_key = cast(ApplianceType, key)
-                self.gw_devices[appl.dev_id][p1_key] = value
-                self._count += 1
-
     def _all_appliances(self) -> None:
         """Collect all appliances with relevant info."""
         self._count = 0
@@ -436,22 +291,7 @@ class SmileHelper(SmileCommon):
             if appl.pwclass in THERMOSTAT_CLASSES and appl.location is None:
                 continue
 
-            self.gw_devices[appl.dev_id] = {"dev_class": appl.pwclass}
-            self._count += 1
-            for key, value in {
-                "firmware": appl.firmware,
-                "hardware": appl.hardware,
-                "location": appl.location,
-                "mac_address": appl.mac,
-                "model": appl.model,
-                "name": appl.name,
-                "zigbee_mac_address": appl.zigbee_mac,
-                "vendor": appl.vendor_name,
-            }.items():
-                if value is not None or key == "location":
-                    appl_key = cast(ApplianceType, key)
-                    self.gw_devices[appl.dev_id][appl_key] = value
-                    self._count += 1
+            self._create_gw_devices(appl)
 
         # For P1 collect the connected SmartMeter info
         if self.smile_type == "power":
@@ -473,80 +313,263 @@ class SmileHelper(SmileCommon):
                     add_to_front = {dev_id: tmp_device}
                     self.gw_devices = {**add_to_front, **cleared_dict}
 
-    def _control_state(self, loc_id: str) -> str | bool:
-        """Helper-function for _device_data_adam().
+    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
 
-        Adam: find the thermostat control_state of a location, from DOMAIN_OBJECTS.
-        Represents the heating/cooling demand-state of the local master thermostat.
-        Note: heating or cooling can still be active when the setpoint has been reached.
+            self.loc_data[loc.loc_id] = {"name": loc.name}
+
+    def _p1_smartmeter_info_finder(self, appl: Munch) -> None:
+        """Collect P1 DSMR Smartmeter info."""
+        loc_id = next(iter(self.loc_data.keys()))
+        appl.dev_id = self.gateway_id
+        appl.location = loc_id
+        appl.mac = None
+        appl.model = self.smile_model
+        appl.name = "P1"
+        appl.pwclass = "smartmeter"
+        appl.zigbee_mac = None
+        location = self._domain_objects.find(f'./location[@id="{loc_id}"]')
+        appl = self._energy_device_info_finder(appl, location)
+
+        self._create_gw_devices(appl)
+
+    def _appliance_info_finder(self, appl: Munch, appliance: etree) -> Munch:
+        """Collect device info (Smile/Stretch, Thermostats, OpenTherm/On-Off): firmware, model and vendor name."""
+        match appl.pwclass:
+            case "gateway":
+                # Collect gateway device info
+                return self._appl_gateway_info(appl, appliance)
+            case _ as dev_class if dev_class in THERMOSTAT_CLASSES:
+                # Collect thermostat device info
+                return self._appl_thermostat_info(appl, appliance)
+            case "heater_central":
+                # Collect heater_central device info
+                self._appl_heater_central_info(appl, appliance)
+                self._appl_dhw_mode_info(appl, appliance)
+                return appl
+            case _:
+                # Collect info from power-related devices (Plug, Aqara Smart Plug)
+                return self._energy_device_info_finder(appl, appliance)
+
+    def _energy_device_info_finder(self, appl: Munch, appliance: etree) -> Munch:
+        """Helper-function for _appliance_info_finder().
+
+        Collect energy device info (Smartmeter, Plug): firmware, model and vendor name.
         """
-        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)
+        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)
+            appl.hardware = module_data["hardware_version"]
+            appl.model = module_data["vendor_model"]
+            appl.vendor_name = module_data["vendor_name"]
+            appl.firmware = module_data["firmware_version"]
 
-        return False
+            return appl
 
-    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 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
+        if self.smile(ADAM):
+            locator = "./logs/interval_log/electricity_interval_meter"
+            mod_type = "electricity_interval_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:
+                return None
 
-        for rule_id in rule_ids:
-            directives: etree = self._domain_objects.find(
-                f'rule[@id="{rule_id}"]/directives'
-            )
-            for directive in directives:
-                preset = directive.find("then").attrib
-                presets[directive.attrib["preset"]] = [
-                    float(preset["heating_setpoint"]),
-                    float(preset["cooling_setpoint"]),
-                ]
+            appl.vendor_name = module_data["vendor_name"]
+            appl.model = check_model(module_data["vendor_model"], appl.vendor_name)
+            appl.hardware = module_data["hardware_version"]
+            appl.firmware = module_data["firmware_version"]
 
-        return presets
+            return appl
 
-    def _rule_ids_by_name(self, name: str, loc_id: str) -> dict[str, dict[str, str]]:
-        """Helper-function for _presets().
+        return appl  # pragma: no cover
 
-        Obtain the rule_id from the given name and and provide the location_id, when present.
-        """
-        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"]] = {"location": loc_id, "name": name, "active": active}
-            else:
-                schedule_ids[rule.attrib["id"]] = {"location": NONE, "name": name, "active": active}
+    def _appl_gateway_info(self, appl: Munch, appliance: etree) -> Munch:
+        """Helper-function for _appliance_info_finder()."""
+        self.gateway_id = appliance.attrib["id"]
+        appl.firmware = self.smile_fw_version
+        appl.hardware = self.smile_hw_version
+        appl.mac = self.smile_mac_address
+        appl.model = self.smile_model
+        appl.name = self.smile_name
+        appl.vendor_name = "Plugwise"
 
-        return schedule_ids
+        # 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:
+                appl.zigbee_mac = found.find("mac_address").text
 
-    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().
+            # Also, collect regulation_modes and check for cooling, indicating cooling-mode is present
+            self._appl_regulation_mode_info(appliance)
 
-        Obtain the rule_id from the given template_tag and provide the location_id, when present.
-        """
-        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"]] = {"location": loc_id, "name": name, "active": active}
-                else:
-                    schedule_ids[rule.attrib["id"]] = {"location": NONE, "name": name, "active": active}
+            # Finally, collect the gateway_modes
+            self._gw_allowed_modes = []
+            locator = "./actuator_functionalities/gateway_mode_control_functionality[type='gateway_mode']/allowed_modes"
+            if appliance.find(locator) is not None:
+                # Limit the possible gateway-modes
+                self._gw_allowed_modes = ["away", "full", "vacation"]
 
-        return schedule_ids
+        return appl
 
-    def _appliance_measurements(
-        self,
+    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
+
+        return appl
+
+    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._domain_objects.findall(
+            './/actuator_functionalities/offset_functionality[type="temperature_offset"]/offset/../../..'
+        )
+        for item in offset_appls:
+            therm_list.append(item.attrib["id"])
+
+        return therm_list
+
+    def _get_measurement_data(self, dev_id: str) -> DeviceData:
+        """Helper-function for smile.py: _get_device_data().
+
+        Collect the appliance-data based on device id.
+        """
+        data: DeviceData = {"binary_sensors": {}, "sensors": {}, "switches": {}}
+        # 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":
+                 data.update(self._power_data_from_location(device["location"]))
+
+            return data
+
+        # Get non-P1 data from APPLIANCES
+        measurements = DEVICE_MEASUREMENTS
+        if self._is_thermostat and dev_id == self._heater_id:
+            measurements = HEATER_CENTRAL_MEASUREMENTS
+            # Show the allowed dhw_modes (Loria only)
+            if self._dhw_allowed_modes:
+                data["dhw_modes"] = self._dhw_allowed_modes
+                # Counting of this item is done in _appliance_measurements()
+
+        if (
+            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)
+
+            for toggle, name in TOGGLES.items():
+                self._get_toggle_state(appliance, toggle, name, data)
+
+            if appliance.find("type").text in ACTUATOR_CLASSES:
+                self._get_actuator_functionalities(appliance, device, data)
+
+            # Collect availability-status for wireless connected devices to Adam
+            self._wireless_availability(appliance, data)
+
+        if dev_id == self.gateway_id and self.smile(ADAM):
+            self._get_regulation_mode(appliance, data)
+            self._get_gateway_mode(appliance, data)
+
+        # Adam & Anna: the Smile outdoor_temperature is present in DOMAIN_OBJECTS and LOCATIONS - under Home
+        # The outdoor_temperature present in APPLIANCES is a local sensor connected to the active device
+        if self._is_thermostat and dev_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}})
+                self._count += 1
+
+        if "c_heating_state" in data:
+            self._process_c_heating_state(data)
+            # Remove c_heating_state after processing
+            data.pop("c_heating_state")
+            self._count -= 1
+
+        if self._is_thermostat and self.smile(ANNA) and dev_id == self._heater_id:
+            # Anna+Elga: base cooling_state on the elga-status-code
+            if "elga_status_code" in data:
+                if data["thermostat_supports_cooling"]:
+                    # Techneco Elga has cooling-capability
+                    self._cooling_present = True
+                    data["model"] = "Generic heater/cooler"
+                    self._cooling_enabled = data["elga_status_code"] in [8, 9]
+                    data["binary_sensors"]["cooling_state"] = self._cooling_active = (
+                        data["elga_status_code"] == 8
+                    )
+                    # Elga has no cooling-switch
+                    if "cooling_ena_switch" in data["switches"]:
+                        data["switches"].pop("cooling_ena_switch")
+                        self._count -= 1
+
+                data.pop("elga_status_code", None)
+                self._count -= 1
+
+            # Loria/Thermastage: cooling-related is based on cooling_state
+            # and modulation_level
+            elif self._cooling_present and "cooling_state" in data["binary_sensors"]:
+                self._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_active = data["binary_sensors"]["cooling_state"]
+
+        self._cleanup_data(data)
+
+        return data
+
+    def _power_data_from_location(self, loc_id: str) -> DeviceData:
+        """Helper-function for smile.py: _get_device_data().
+
+        Collect the power-data based on Location ID, from LOCATIONS.
+        """
+        direct_data: DeviceData = {"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')
+        for loc.measurement, loc.attrs in P1_MEASUREMENTS.items():
+            for loc.log_type in log_list:
+                self._collect_power_values(direct_data, loc, t_string)
+
+        self._count += len(direct_data["sensors"])
+        return direct_data
+
+    def _appliance_measurements(
+        self,
         appliance: etree,
         data: DeviceData,
         measurements: dict[str, DATA | UOM],
@@ -555,20 +578,8 @@ class SmileHelper(SmileCommon):
         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:
-                # Skip known obsolete measurements
-                updated_date_locator = (
-                    f'.//logs/point_log[type="{measurement}"]/updated_date'
-                )
-                if (
-                    measurement in OBSOLETE_MEASUREMENTS
-                    and (updated_date_key := appliance.find(updated_date_locator))
-                    is not None
-                ):
-                    updated_date = updated_date_key.text.split("T")[0]
-                    date_1 = dt.datetime.strptime(updated_date, "%Y-%m-%d")
-                    date_2 = dt.datetime.now()
-                    if int((date_2 - date_1).days) > 7:
-                        continue
+                if skip_obsolete_measurements(appliance, measurement):
+                    continue
 
                 if new_name := getattr(attrs, ATTR_NAME, None):
                     measurement = new_name
@@ -587,20 +598,6 @@ class SmileHelper(SmileCommon):
                             appl_p_loc.text, getattr(attrs, ATTR_UNIT_OF_MEASUREMENT)
                         )
                         data["sensors"][s_key] = s_value
-                        # Anna: save cooling-related measurements for later use
-                        # Use the local outdoor temperature as reference for turning cooling on/off
-                        if measurement == "cooling_activation_outdoor_temperature":
-                            self._cooling_activation_outdoor_temp = data["sensors"][
-                                "cooling_activation_outdoor_temperature"
-                            ]
-                        if measurement == "cooling_deactivation_threshold":
-                            self._cooling_deactivation_threshold = data["sensors"][
-                                "cooling_deactivation_threshold"
-                            ]
-                        if measurement == "outdoor_air_temperature":
-                            self._outdoor_temp = data["sensors"][
-                                "outdoor_air_temperature"
-                            ]
                     case _ as measurement if measurement in SWITCHES:
                         sw_key = cast(SwitchType, measurement)
                         sw_value = appl_p_loc.text in ["on", "true"]
@@ -625,36 +622,34 @@ class SmileHelper(SmileCommon):
         # Don't count the above top-level dicts, only the remaining single items
         self._count += len(data) - 3
 
-    def _wireless_availability(self, appliance: etree, data: DeviceData) -> None:
+    def _get_toggle_state(
+        self, xml: etree, toggle: str, name: ToggleNameType, data: DeviceData
+    ) -> None:
         """Helper-function for _get_measurement_data().
 
-        Collect the availability-status for wireless connected devices.
+        Obtain the toggle state of a 'toggle' = switch.
         """
-        if self.smile(ADAM):
-            # Collect for Plugs
-            locator = "./logs/interval_log/electricity_interval_meter"
-            mod_type = "electricity_interval_meter"
-            module_data = self._get_module_data(appliance, locator, mod_type)
-            if module_data["reachable"] is None:
-                # Collect for wireless thermostats
-                locator = "./logs/point_log[type='thermostat']/thermostat"
-                mod_type = "thermostat"
-                module_data = self._get_module_data(appliance, locator, mod_type)
-
-            if module_data["reachable"] is not None:
-                data["available"] = module_data["reachable"]
+        if xml.find("type").text == "heater_central":
+            locator = f"./actuator_functionalities/toggle_functionality[type='{toggle}']/state"
+            if (state := xml.find(locator)) is not None:
+                data["switches"][name] = state.text == "on"
                 self._count += 1
 
-    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._domain_objects.findall(
-            './/actuator_functionalities/offset_functionality[type="temperature_offset"]/offset/../../..'
-        )
-        for item in offset_appls:
-            therm_list.append(item.attrib["id"])
-
-        return therm_list
+    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}",
+                )
 
     def _get_actuator_functionalities(
         self, xml: etree, device: DeviceData, data: DeviceData
@@ -710,6 +705,26 @@ class SmileHelper(SmileCommon):
                 act_item = cast(ActuatorType, item)
                 data[act_item] = temp_dict
 
+    def _wireless_availability(self, appliance: etree, data: DeviceData) -> None:
+        """Helper-function for _get_measurement_data().
+
+        Collect the availability-status for wireless connected devices.
+        """
+        if self.smile(ADAM):
+            # Collect for Plugs
+            locator = "./logs/interval_log/electricity_interval_meter"
+            mod_type = "electricity_interval_meter"
+            module_data = self._get_module_data(appliance, locator, mod_type)
+            if module_data["reachable"] is None:
+                # Collect for wireless thermostats
+                locator = "./logs/point_log[type='thermostat']/thermostat"
+                mod_type = "thermostat"
+                module_data = self._get_module_data(appliance, locator, mod_type)
+
+            if module_data["reachable"] is not None:
+                data["available"] = module_data["reachable"]
+                self._count += 1
+
     def _get_regulation_mode(self, appliance: etree, data: DeviceData) -> None:
         """Helper-function for _get_measurement_data().
 
@@ -731,27 +746,18 @@ class SmileHelper(SmileCommon):
             data["select_gateway_mode"] = search.find("mode").text
             self._count += 1
 
-    def _cleanup_data(self, data: DeviceData) -> None:
-        """Helper-function for _get_measurement_data().
+    def _object_value(self, obj_id: str, measurement: str) -> float | int | None:
+        """Helper-function for smile.py: _get_device_data() and _device_data_anna().
 
-        Clean up the data dict.
+        Obtain the value/state for the given object from a location in DOMAIN_OBJECTS
         """
-        # Don't show cooling-related when no cooling present,
-        # but, keep cooling_enabled for Elga
-        if not self._cooling_present:
-            if "cooling_state" in data["binary_sensors"]:
-                data["binary_sensors"].pop("cooling_state")
-                self._count -= 1
-            if "cooling_ena_switch" in data["switches"]:
-                data["switches"].pop("cooling_ena_switch")  # pragma: no cover
-                self._count -= 1  # pragma: no cover
-            if "cooling_enabled" in data["binary_sensors"]:
-                data["binary_sensors"].pop("cooling_enabled")  # pragma: no cover
-                self._count -= 1  # pragma: no cover
+        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)
 
-        if "thermostat_supports_cooling" in data:
-            data.pop("thermostat_supports_cooling", None)
-            self._count -= 1
+        return val
 
     def _process_c_heating_state(self, data: DeviceData) -> None:
         """Helper-function for _get_measurement_data().
@@ -781,103 +787,33 @@ class SmileHelper(SmileCommon):
         if self._elga:
             data["binary_sensors"]["heating_state"] = data["c_heating_state"]
 
-    def _get_measurement_data(self, dev_id: str) -> DeviceData:
-        """Helper-function for smile.py: _get_device_data().
+    def _cleanup_data(self, data: DeviceData) -> None:
+        """Helper-function for _get_measurement_data().
 
-        Collect the appliance-data based on device id.
+        Clean up the data dict.
         """
-        data: DeviceData = {"binary_sensors": {}, "sensors": {}, "switches": {}}
-        # 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":
-                 data.update(self._power_data_from_location(device["location"]))
-
-            return data
-
-        # Get non-P1 data from APPLIANCES
-        measurements = DEVICE_MEASUREMENTS
-        if self._is_thermostat and dev_id == self._heater_id:
-            measurements = HEATER_CENTRAL_MEASUREMENTS
-            # Show the allowed dhw_modes (Loria only)
-            if self._dhw_allowed_modes:
-                data["dhw_modes"] = self._dhw_allowed_modes
-                # Counting of this item is done in _appliance_measurements()
-
-        if (
-            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)
-
-            for toggle, name in TOGGLES.items():
-                self._get_toggle_state(appliance, toggle, name, data)
-
-            if appliance.find("type").text in ACTUATOR_CLASSES:
-                self._get_actuator_functionalities(appliance, device, data)
-
-            # Collect availability-status for wireless connected devices to Adam
-            self._wireless_availability(appliance, data)
-
-        if dev_id == self.gateway_id and self.smile(ADAM):
-            self._get_regulation_mode(appliance, data)
-            self._get_gateway_mode(appliance, data)
-
-        # Adam & Anna: the Smile outdoor_temperature is present in DOMAIN_OBJECTS and LOCATIONS - under Home
-        # The outdoor_temperature present in APPLIANCES is a local sensor connected to the active device
-        if self._is_thermostat and dev_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}})
-                self._count += 1
-
-        if "c_heating_state" in data:
-            self._process_c_heating_state(data)
-            # Remove c_heating_state after processing
-            data.pop("c_heating_state")
-            self._count -= 1
-
-        if self._is_thermostat and self.smile(ANNA) and dev_id == self._heater_id:
-            # Anna+Elga: base cooling_state on the elga-status-code
-            if "elga_status_code" in data:
-                if data["thermostat_supports_cooling"]:
-                    # Techneco Elga has cooling-capability
-                    self._cooling_present = True
-                    data["model"] = "Generic heater/cooler"
-                    self._cooling_enabled = data["elga_status_code"] in [8, 9]
-                    data["binary_sensors"]["cooling_state"] = self._cooling_active = (
-                        data["elga_status_code"] == 8
-                    )
-                    # Elga has no cooling-switch
-                    if "cooling_ena_switch" in data["switches"]:
-                        data["switches"].pop("cooling_ena_switch")
-                        self._count -= 1
-
-                data.pop("elga_status_code", None)
+        # Don't show cooling-related when no cooling present,
+        # but, keep cooling_enabled for Elga
+        if not self._cooling_present:
+            if "cooling_state" in data["binary_sensors"]:
+                data["binary_sensors"].pop("cooling_state")
                 self._count -= 1
+            if "cooling_ena_switch" in data["switches"]:
+                data["switches"].pop("cooling_ena_switch")  # pragma: no cover
+                self._count -= 1  # pragma: no cover
+            if "cooling_enabled" in data["binary_sensors"]:
+                data["binary_sensors"].pop("cooling_enabled")  # pragma: no cover
+                self._count -= 1  # pragma: no cover
 
-            # Loria/Thermastage: cooling-related is based on cooling_state
-            # and modulation_level
-            elif self._cooling_present and "cooling_state" in data["binary_sensors"]:
-                self._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_active = data["binary_sensors"]["cooling_state"]
-
-        self._cleanup_data(data)
-
-        return data
+        if "thermostat_supports_cooling" in data:
+            data.pop("thermostat_supports_cooling", None)
+            self._count -= 1
 
     def _scan_thermostats(self) -> None:
         """Helper-function for smile.py: get_all_devices().
 
         Update locations with thermostat ranking results and use
-        the result to update the device_class of slave thermostats.
+        the result to update the device_class of secondary thermostats.
         """
         self._thermo_locs = self._match_locations()
 
@@ -892,11 +828,11 @@ class SmileHelper(SmileCommon):
             for dev_id, device in self.gw_devices.items():
                 self._rank_thermostat(thermo_matching, loc_id, dev_id, device)
 
-        # Update slave thermostat class where needed
+        # Update secondary thermostat class where needed
         for dev_id, device in self.gw_devices.items():
             if (loc_id := device["location"]) in self._thermo_locs:
                 tl_loc_id = self._thermo_locs[loc_id]
-                if "slaves" in tl_loc_id and dev_id in tl_loc_id["slaves"]:
+                if "secondary" in tl_loc_id and dev_id in tl_loc_id["secondary"]:
                     device["dev_class"] = "thermo_sensor"
 
     def _match_locations(self) -> dict[str, ThermoLoc]:
@@ -909,7 +845,7 @@ class SmileHelper(SmileCommon):
             for appliance_details in self.gw_devices.values():
                 if appliance_details["location"] == location_id:
                     location_details.update(
-                        {"master": None, "master_prio": 0, "slaves": set()}
+                        {"primary": None, "primary_prio": 0, "secondary": set()}
                     )
                     matched_locations[location_id] = location_details
 
@@ -924,69 +860,38 @@ class SmileHelper(SmileCommon):
     ) -> None:
         """Helper-function for _scan_thermostats().
 
-        Rank the thermostat based on appliance_details: master or slave.
+        Rank the thermostat based on appliance_details: primary or secondary.
         """
         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)
+            # Pre-elect new primary
+            if thermo_matching[appl_class] > self._thermo_locs[loc_id]["primary_prio"]:
+                # Demote former primary
+                if (tl_primary:= self._thermo_locs[loc_id]["primary"]) is not None:
+                    self._thermo_locs[loc_id]["secondary"].add(tl_primary)
 
-                # Crown master
-                self._thermo_locs[loc_id]["master_prio"] = thermo_matching[appl_class]
-                self._thermo_locs[loc_id]["master"] = appliance_id
+                # Crown primary
+                self._thermo_locs[loc_id]["primary_prio"] = thermo_matching[appl_class]
+                self._thermo_locs[loc_id]["primary"] = appliance_id
 
             else:
-                self._thermo_locs[loc_id]["slaves"].add(appliance_id)
+                self._thermo_locs[loc_id]["secondary"].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.
-        """
-        locator = f'./location[@id="{loc_id}"]/actuator_functionalities/thermostat_functionality'
-        thermostat_functionality_id = self._domain_objects.find(locator).attrib["id"]
-
-        return f"{LOCATIONS};id={loc_id}/thermostat;id={thermostat_functionality_id}"
-
-    def _get_group_switches(self) -> dict[str, DeviceData]:
-        """Helper-function for smile.py: get_all_devices().
+    def _control_state(self, loc_id: str) -> str | bool:
+        """Helper-function for _device_data_adam().
 
-        Collect switching- or pump-group info.
+        Adam: find the thermostat control_state of a location, from DOMAIN_OBJECTS.
+        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.
         """
-        switch_groups: dict[str, DeviceData] = {}
-        # P1 and Anna don't have switchgroups
-        if self.smile_type == "power" or self.smile(ANNA):
-            return switch_groups
-
-        for group in self._domain_objects.findall("./group"):
-            members: list[str] = []
-            group_id = group.attrib["id"]
-            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:
-                if item.attrib["id"] in self.gw_devices:
-                    members.append(item.attrib["id"])
-
-            if group_type in SWITCH_GROUP_TYPES and members:
-                switch_groups.update(
-                    {
-                        group_id: {
-                            "dev_class": group_type,
-                            "model": "Switchgroup",
-                            "name": group_name,
-                            "members": members,
-                        },
-                    },
-                )
-                self._count += 4
+        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)
 
-        return switch_groups
+        return False
 
     def _heating_valves(self) -> int | bool:
         """Helper-function for smile.py: _device_data_adam().
@@ -1005,117 +910,73 @@ class SmileHelper(SmileCommon):
 
         return False if loc_found == 0 else open_valve_count
 
-    def power_data_energy_diff(
-        self,
-        measurement: str,
-        net_string: SensorType,
-        f_val: float | int,
-        direct_data: DeviceData,
-    ) -> DeviceData:
-        """Calculate differential energy."""
-        if (
-            "electricity" in measurement
-            and "phase" not in measurement
-            and "interval" not in net_string
-        ):
-            diff = 1
-            if "produced" in measurement:
-                diff = -1
-            if net_string not in direct_data["sensors"]:
-                tmp_val: float | int = 0
-            else:
-                tmp_val = direct_data["sensors"][net_string]
+    def _preset(self, loc_id: str) -> str | None:
+        """Helper-function for smile.py: device_data_climate().
 
-            if isinstance(f_val, int):
-                tmp_val += f_val * diff
-            else:
-                tmp_val += float(f_val * diff)
-                tmp_val = float(f"{round(tmp_val, 3):.3f}")
+        Collect the active preset based on Location ID.
+        """
+        locator = f'./location[@id="{loc_id}"]/preset'
+        if (preset := self._domain_objects.find(locator)) is not None:
+            return str(preset.text)
 
-            direct_data["sensors"][net_string] = tmp_val
+        return None  # pragma: no cover
 
-        return direct_data
+    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 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
 
-    def _power_data_peak_value(self, loc: Munch) -> Munch:
-        """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)
-        if loc.logs.find(loc.locator) is None:
-            if "log" in loc.log_type and (
-                "gas" in loc.measurement or "phase" in loc.measurement
-            ):
-                # Avoid double processing by skipping one peak-list option
-                if loc.peak_select == "nl_offpeak":
-                    loc.found = False
-                    return loc
+        for rule_id in rule_ids:
+            directives: etree = self._domain_objects.find(
+                f'rule[@id="{rule_id}"]/directives'
+            )
+            for directive in directives:
+                preset = directive.find("then").attrib
+                presets[directive.attrib["preset"]] = [
+                    float(preset["heating_setpoint"]),
+                    float(preset["cooling_setpoint"]),
+                ]
 
-                loc.locator = (
-                    f'./{loc.log_type}[type="{loc.measurement}"]/period/measurement'
-                )
-                if loc.logs.find(loc.locator) is None:
-                    loc.found = False
-                    return loc
-            else:
-                loc.found = False  # pragma: no cover
-                return loc  # pragma: no cover
-
-        if (peak := loc.peak_select.split("_")[1]) == "offpeak":
-            peak = "off_peak"
-        log_found = loc.log_type.split("_")[0]
-        loc.key_string = f"{loc.measurement}_{peak}_{log_found}"
-        if "gas" in loc.measurement or loc.log_type == "point_meter":
-            loc.key_string = f"{loc.measurement}_{log_found}"
-        if "phase" in loc.measurement:
-            loc.key_string = f"{loc.measurement}"
-        loc.net_string = f"net_electricity_{log_found}"
-        val = loc.logs.find(loc.locator).text
-        loc.f_val = power_data_local_format(loc.attrs, loc.key_string, val)
-
-        return loc
+        return presets
 
-    def _power_data_from_location(self, loc_id: str) -> DeviceData:
-        """Helper-function for smile.py: _get_device_data().
+    def _rule_ids_by_name(self, name: str, loc_id: str) -> dict[str, dict[str, str]]:
+        """Helper-function for _presets().
 
-        Collect the power-data based on Location ID, from LOCATIONS.
+        Obtain the rule_id from the given name and and provide the location_id, when present.
         """
-        direct_data: DeviceData = {"sensors": {}}
-        loc = Munch()
-        log_list: list[str] = ["point_log", "cumulative_log", "interval_log"]
-        peak_list: list[str] = ["nl_peak", "nl_offpeak"]
-        t_string = "tariff"
-
-        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:
-                for loc.peak_select in peak_list:
-                    loc.locator = (
-                        f'./{loc.log_type}[type="{loc.measurement}"]/period/'
-                        f'measurement[@{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
+        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"]] = {"location": loc_id, "name": name, "active": active}
+            else:
+                schedule_ids[rule.attrib["id"]] = {"location": NONE, "name": name, "active": active}
 
-        self._count += len(direct_data["sensors"])
-        return direct_data
+        return schedule_ids
 
-    def _preset(self, loc_id: str) -> str | None:
-        """Helper-function for smile.py: device_data_climate().
+    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().
 
-        Collect the active preset based on Location ID.
+        Obtain the rule_id from the given template_tag and provide the location_id, when present.
         """
-        locator = f'./location[@id="{loc_id}"]/preset'
-        if (preset := self._domain_objects.find(locator)) is not None:
-            return str(preset.text)
+        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"]] = {"location": loc_id, "name": name, "active": active}
+                else:
+                    schedule_ids[rule.attrib["id"]] = {"location": NONE, "name": name, "active": active}
 
-        return None  # pragma: no cover
+        return schedule_ids
 
     def _schedules(self, location: str) -> tuple[list[str], str]:
         """Helper-function for smile.py: _device_data_climate().
@@ -1174,57 +1035,12 @@ class SmileHelper(SmileCommon):
 
         return sorted(schedules_dates.items(), key=lambda kv: kv[1])[-1][0]
 
-    def _object_value(self, obj_id: str, measurement: str) -> float | int | None:
-        """Helper-function for smile.py: _get_device_data() and _device_data_anna().
-
-        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 _get_lock_state(self, xml: etree, data: DeviceData) -> None:
-        """Helper-function for _get_measurement_data().
-
-        Adam & Stretches: obtain the relay-switch lock state.
-        """
-        actuator = "actuator_functionalities"
-        func_type = "relay_functionality"
-        if xml.find("type").text not in SPECIAL_PLUG_TYPES:
-            locator = f"./{actuator}/{func_type}/lock"
-            if (found := xml.find(locator)) is not None:
-                data["switches"]["lock"] = found.text == "true"
-                self._count += 1
-
-    def _get_toggle_state(
-        self, xml: etree, toggle: str, name: ToggleNameType, data: DeviceData
-    ) -> None:
-        """Helper-function for _get_measurement_data().
+    def _thermostat_uri(self, loc_id: str) -> str:
+        """Helper-function for smile.py: set_temperature().
 
-        Obtain the toggle state of a 'toggle' = switch.
+        Determine the location-set_temperature uri - from LOCATIONS.
         """
-        if xml.find("type").text == "heater_central":
-            locator = f"./actuator_functionalities/toggle_functionality[type='{toggle}']/state"
-            if (state := xml.find(locator)) is not None:
-                data["switches"][name] = state.text == "on"
-                self._count += 1
+        locator = f'./location[@id="{loc_id}"]/actuator_functionalities/thermostat_functionality'
+        thermostat_functionality_id = self._domain_objects.find(locator).attrib["id"]
 
-    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}",
-                )
+        return f"{LOCATIONS};id={loc_id}/thermostat;id={thermostat_functionality_id}"