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

plugwise/legacy/helper.py

@@ -4,14 +4,12 @@ Plugwise Smile protocol helpers.
 """
 from __future__ import annotations
 
-import datetime as dt
 from typing import cast
 
 from plugwise.common import SmileCommon
 from plugwise.constants import (
     ACTIVE_ACTUATORS,
     ACTUATOR_CLASSES,
-    ANNA,
     APPLIANCES,
     ATTR_NAME,
     ATTR_UNIT_OF_MEASUREMENT,
@@ -24,12 +22,9 @@ from plugwise.constants import (
     HEATER_CENTRAL_MEASUREMENTS,
     LIMITS,
     NONE,
-    OBSOLETE_MEASUREMENTS,
     P1_LEGACY_MEASUREMENTS,
     SENSORS,
-    SPECIAL_PLUG_TYPES,
     SPECIALS,
-    SWITCH_GROUP_TYPES,
     SWITCHES,
     TEMP_CELSIUS,
     THERMOSTAT_CLASSES,
@@ -46,7 +41,7 @@ from plugwise.constants import (
     SwitchType,
     ThermoLoc,
 )
-from plugwise.util import format_measure, power_data_local_format, version_to_model
+from plugwise.util import format_measure, skip_obsolete_measurements, version_to_model
 
 # This way of importing aiohttp is because of patch/mocking in testing (aiohttp timeouts)
 from defusedxml import ElementTree as etree
@@ -97,6 +92,60 @@ class SmileLegacyHelper(SmileCommon):
         self.smile_zigbee_mac_address: str | None
         SmileCommon.__init__(self)
 
+    def _all_appliances(self) -> None:
+        """Collect all appliances with relevant info."""
+        self._count = 0
+        self._all_locations()
+
+        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"):
+            appl = Munch()
+            appl.pwclass = appliance.find("type").text
+            # Skip thermostats that have this key, should be an orphaned device (Core #81712)
+            if (
+                appl.pwclass == "thermostat"
+                and appliance.find("actuator_functionalities/") is None
+            ):
+                continue  # pragma: no cover
+
+            appl.location = self._home_location
+            appl.dev_id = appliance.attrib["id"]
+            appl.name = appliance.find("name").text
+            appl.model = appl.pwclass.replace("_", " ").title()
+            appl.firmware = None
+            appl.hardware = None
+            appl.mac = None
+            appl.zigbee_mac = None
+            appl.vendor_name = None
+
+            # Determine class for this appliance
+            # Skip on heater_central when no active device present or on orphaned stretch devices
+            if not (appl := self._appliance_info_finder(appliance, appl)):
+                continue
+
+            # Skip orphaned heater_central (Core Issue #104433)
+            if appl.pwclass == "heater_central" and appl.dev_id != self._heater_id:
+                continue  # pragma: no cover
+
+            self._create_gw_devices(appl)
+
+        # Place the gateway and optional heater_central devices as 1st and 2nd
+        for dev_class in ("heater_central", "gateway"):
+            for dev_id, device in dict(self.gw_devices).items():
+                if device["dev_class"] == dev_class:
+                    tmp_device = device
+                    self.gw_devices.pop(dev_id)
+                    cleared_dict = self.gw_devices
+                    add_to_front = {dev_id: tmp_device}
+                    self.gw_devices = {**add_to_front, **cleared_dict}
+
     def _all_locations(self) -> None:
         """Collect all locations."""
         loc = Munch()
@@ -127,6 +176,44 @@ class SmileLegacyHelper(SmileCommon):
 
             self.loc_data[loc.loc_id] = {"name": loc.name}
 
+    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 _appliance_info_finder(self, appliance: etree, appl: Munch) -> Munch:
+        """Collect device info (Smile/Stretch, Thermostats, OpenTherm/On-Off): firmware, model and vendor name."""
+        match appl.pwclass:
+        # Collect thermostat device info
+            case _ as dev_class if dev_class in THERMOSTAT_CLASSES:
+                return self._appl_thermostat_info(appl, appliance, self._modules)
+        # Collect heater_central device info
+            case "heater_central":
+                return self._appl_heater_central_info(appl, appliance, self._appliances, self._modules)
+        # Collect info from Stretches
+            case _:
+                return self._energy_device_info_finder(appliance, appl)
+
     def _energy_device_info_finder(self, appliance: etree, appl: Munch) -> Munch:
         """Helper-function for _appliance_info_finder().
 
@@ -154,21 +241,6 @@ class SmileLegacyHelper(SmileCommon):
 
         return appl  # pragma: no cover
 
-    def _appliance_info_finder(self, appliance: etree, appl: Munch) -> Munch:
-        """Collect device info (Smile/Stretch, Thermostats, OpenTherm/On-Off): firmware, model and vendor name."""
-        # Collect thermostat device info
-        if appl.pwclass in THERMOSTAT_CLASSES:
-            return self._appl_thermostat_info(appl, appliance, self._modules)
-
-        # Collect heater_central device info
-        if appl.pwclass == "heater_central":
-            return self._appl_heater_central_info(appl, appliance, self._appliances, self._modules)
-
-        # Collect info from Stretches
-        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()))
@@ -182,130 +254,72 @@ class SmileLegacyHelper(SmileCommon):
         location = self._locations.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
+        self._create_gw_devices(appl)
 
-        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 _create_legacy_gateway(self) -> None:
-        """Create the (missing) gateway devices for legacy Anna, P1 and Stretch.
+    def _get_measurement_data(self, dev_id: str) -> DeviceData:
+        """Helper-function for smile.py: _get_device_data().
 
-        Use the home_location or FAKE_APPL as device id.
+        Collect the appliance-data based on device id.
         """
-        self.gateway_id = self._home_location
+        data: DeviceData = {"binary_sensors": {}, "sensors": {}, "switches": {}}
+        # Get P1 smartmeter data from LOCATIONS or MODULES
+        device = self.gw_devices[dev_id]
+        # !! DON'T CHANGE below two if-lines, will break stuff !!
         if self.smile_type == "power":
-            self.gateway_id = FAKE_APPL
+            if device["dev_class"] == "smartmeter":
+                data.update(self._power_data_from_modules())
 
-        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
+            return data
 
-    def _all_appliances(self) -> None:
-        """Collect all appliances with relevant info."""
-        self._count = 0
-        self._all_locations()
+        measurements = DEVICE_MEASUREMENTS
+        if self._is_thermostat and dev_id == self._heater_id:
+            measurements = HEATER_CENTRAL_MEASUREMENTS
 
-        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
+        if (
+            appliance := self._appliances.find(f'./appliance[@id="{dev_id}"]')
+        ) is not None:
+            self._appliance_measurements(appliance, data, measurements)
+            self._get_lock_state(appliance, data, self._stretch_v2)
 
-        for appliance in self._appliances.findall("./appliance"):
-            appl = Munch()
-            appl.pwclass = appliance.find("type").text
-            # Skip thermostats that have this key, should be an orphaned device (Core #81712)
-            if (
-                appl.pwclass == "thermostat"
-                and appliance.find("actuator_functionalities/") is None
-            ):
-                continue  # pragma: no cover
+            if appliance.find("type").text in ACTUATOR_CLASSES:
+                self._get_actuator_functionalities(appliance, device, data)
 
-            appl.location = self._home_location
-            appl.dev_id = appliance.attrib["id"]
-            appl.name = appliance.find("name").text
-            appl.model = appl.pwclass.replace("_", " ").title()
-            appl.firmware = None
-            appl.hardware = None
-            appl.mac = None
-            appl.zigbee_mac = None
-            appl.vendor_name = None
+        # 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
 
-            # Determine class for this appliance
-            # Skip on heater_central when no active device present or on orphaned stretch devices
-            if not (appl := self._appliance_info_finder(appliance, appl)):
-                continue
+        if "c_heating_state" in data:
+            data.pop("c_heating_state")
+            self._count -= 1
 
-            # Skip orphaned heater_central (Core Issue #104433)
-            if appl.pwclass == "heater_central" and appl.dev_id != self._heater_id:
-                continue  # pragma: no cover
+        return data
 
-            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
+    def _power_data_from_modules(self) -> DeviceData:
+        """Helper-function for smile.py: _get_device_data().
 
-        # Place the gateway and optional heater_central devices as 1st and 2nd
-        for dev_class in ("heater_central", "gateway"):
-            for dev_id, device in dict(self.gw_devices).items():
-                if device["dev_class"] == dev_class:
-                    tmp_device = device
-                    self.gw_devices.pop(dev_id)
-                    cleared_dict = self.gw_devices
-                    add_to_front = {dev_id: tmp_device}
-                    self.gw_devices = {**add_to_front, **cleared_dict}
+        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"]
+        t_string = "tariff_indicator"
 
-    def _presets(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,
-                ]
+        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:
+                    self._collect_power_values(direct_data, loc, t_string, legacy=True)
 
-        return presets
+        self._count += len(direct_data["sensors"])
+        return direct_data
 
     def _appliance_measurements(
         self,
@@ -320,20 +334,8 @@ class SmileLegacyHelper(SmileCommon):
                 if measurement == "domestic_hot_water_state":
                     continue
 
-                # 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  # pragma: no cover
+                if skip_obsolete_measurements(appliance, measurement):
+                    continue  # pragma: no cover
 
                 if new_name := getattr(attrs, ATTR_NAME, None):
                     measurement = new_name
@@ -406,194 +408,19 @@ class SmileLegacyHelper(SmileCommon):
                 act_item = cast(ActuatorType, item)
                 data[act_item] = temp_dict
 
-    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 or MODULES
-        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_modules())
-
-            return data
-
-        measurements = DEVICE_MEASUREMENTS
-        if self._is_thermostat and dev_id == self._heater_id:
-            measurements = HEATER_CENTRAL_MEASUREMENTS
-
-        if (
-            appliance := self._appliances.find(f'./appliance[@id="{dev_id}"]')
-        ) is not None:
-            self._appliance_measurements(appliance, data, measurements)
-            self._get_lock_state(appliance, data)
-
-            if appliance.find("type").text in ACTUATOR_CLASSES:
-                self._get_actuator_functionalities(appliance, device, 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:
-            data.pop("c_heating_state")
-            self._count -= 1
-
-        return data
-
-    def _thermostat_uri(self) -> str:
-        """Determine the location-set_temperature uri - from APPLIANCES."""
-        locator = "./appliance[type='thermostat']"
-        appliance_id = self._appliances.find(locator).attrib["id"]
-
-        return f"{APPLIANCES};id={appliance_id}/thermostat"
-
-    def _get_group_switches(self) -> dict[str, DeviceData]:
-        """Helper-function for smile.py: get_all_devices().
-
-        Collect switching- or pump-group info.
-        """
-        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")
-            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"])
-
-            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
-
-        return switch_groups
-
-    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]
-
-            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}")
-
-            direct_data["sensors"][net_string] = tmp_val
-
-        return direct_data
-
-    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 for P1 legacy electricity_point_meter or gas_*_meter data
-        if loc.logs.find(loc.locator) is None:
-            if "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
-
-        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}"
-        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
-
-    def _power_data_from_modules(self) -> DeviceData:
-        """Helper-function for smile.py: _get_device_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().
 
-        Collect the power-data from MODULES (P1 legacy only).
+        Obtain the value/state for the given object from a location in DOMAIN_OBJECTS
         """
-        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
+        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
 
-        self._count += len(direct_data["sensors"])
-        return direct_data
+        return val
 
     def _preset(self) -> str | None:
         """Helper-function for smile.py: device_data_climate().
@@ -609,6 +436,19 @@ class SmileLegacyHelper(SmileCommon):
 
         return active_rule["icon"]
 
+    def _presets(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 _schedules(self) -> tuple[list[str], str]:
         """Collect available schedules/schedules for the legacy thermostat."""
         available: list[str] = [NONE]
@@ -634,32 +474,9 @@ class SmileLegacyHelper(SmileCommon):
 
         return available, selected
 
-    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
-
-        return val
-
-    def _get_lock_state(self, xml: etree, data: DeviceData) -> None:
-        """Helper-function for _get_measurement_data().
+    def _thermostat_uri(self) -> str:
+        """Determine the location-set_temperature uri - from APPLIANCES."""
+        locator = "./appliance[type='thermostat']"
+        appliance_id = self._appliances.find(locator).attrib["id"]
 
-        Adam & Stretches: obtain the relay-switch lock state.
-        """
-        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:
-                data["switches"]["lock"] = found.text == "true"
-                self._count += 1
+        return f"{APPLIANCES};id={appliance_id}/thermostat"