plugwise 0.35.0__tar.gz → 0.35.2__tar.gz

{plugwise-0.35.0 → plugwise-0.35.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: plugwise
-Version: 0.35.0
+Version: 0.35.2
 Summary: Plugwise Smile (Adam/Anna/P1) and Stretch module for Python 3.
 Home-page: https://github.com/plugwise/python-plugwise
 Author: Plugwise device owners

{plugwise-0.35.0 → plugwise-0.35.2}/plugwise/__init__.py

@@ -17,6 +17,7 @@ import semver
 
 from .constants import (
     ADAM,
+    ANNA,
     APPLIANCES,
     DEFAULT_PORT,
     DEFAULT_TIMEOUT,
@@ -51,7 +52,7 @@ from .exceptions import (
 from .helper import SmileComm, SmileHelper
 
 
-def remove_empty_platform_dicts(data: DeviceData) -> DeviceData:
+def remove_empty_platform_dicts(data: DeviceData) -> None:
     """Helper-function for removing any empty platform dicts."""
     if not data["binary_sensors"]:
         data.pop("binary_sensors")
@@ -60,16 +61,47 @@ def remove_empty_platform_dicts(data: DeviceData) -> DeviceData:
     if not data["switches"]:
         data.pop("switches")
 
-    return data
-
 
 class SmileData(SmileHelper):
     """The Plugwise Smile main class."""
 
-    def update_for_cooling(self, device: DeviceData) -> DeviceData:
+    def _update_gw_devices(self) -> None:
+        """Helper-function for _all_device_data() and async_update().
+
+        Collect data for each device and add to self.gw_devices.
+        """
+        for device_id, device in self.gw_devices.items():
+            data = self._get_device_data(device_id)
+            self._add_or_update_notifications(device_id, device, data)
+            device.update(data)
+            self._update_for_cooling(device)
+            remove_empty_platform_dicts(device)
+
+    def _add_or_update_notifications(
+        self, device_id: str, device: DeviceData, data: DeviceData
+    ) -> None:
+        """Helper-function adding or updating the Plugwise notifications."""
+        if (
+            device_id == self.gateway_id
+            and (
+                self._is_thermostat
+                or (self.smile_type == "power" and not self._smile_legacy)
+            )
+        ) or (
+            "binary_sensors" in device
+            and "plugwise_notification" in device["binary_sensors"]
+        ):
+            data["binary_sensors"]["plugwise_notification"] = bool(self._notifications)
+            self._count += 1
+
+    def _update_for_cooling(self, device: DeviceData) -> None:
         """Helper-function for adding/updating various cooling-related values."""
-        # For heating + cooling, replace setpoint with setpoint_high/_low
-        if self._cooling_present:
+        # For Anna and heating + cooling, replace setpoint with setpoint_high/_low
+        if (
+            self.smile(ANNA)
+            and self._cooling_present
+            and device["dev_class"] == "thermostat"
+        ):
             thermostat = device["thermostat"]
             sensors = device["sensors"]
             temp_dict: ActuatorData = {
@@ -90,36 +122,27 @@ class SmileData(SmileHelper):
             sensors["setpoint_high"] = temp_dict["setpoint_high"]
             self._count += 2
 
-        return device
-
-    def _update_gw_devices(self) -> None:
-        """Helper-function for _all_device_data() and async_update().
+    def get_all_devices(self) -> None:
+        """Determine the evices present from the obtained XML-data.
 
-        Collect data for each device and add to self.gw_devices.
+        Run this functions once to gather the initial device configuration,
+        then regularly run async_update() to refresh the device data.
         """
-        for device_id, device in self.gw_devices.items():
-            data = self._get_device_data(device_id)
-            if (
-                "binary_sensors" in device
-                and "plugwise_notification" in device["binary_sensors"]
-            ) or (
-                device_id == self.gateway_id
-                and (
-                    self._is_thermostat
-                    or (self.smile_type == "power" and not self._smile_legacy)
-                )
-            ):
-                data["binary_sensors"]["plugwise_notification"] = bool(
-                    self._notifications
-                )
-                self._count += 1
-            device.update(data)
+        # Gather all the devices and their initial data
+        self._all_appliances()
+        if self._is_thermostat:
+            self._scan_thermostats()
+            # Collect a list of thermostats with offset-capability
+            self.therms_with_offset_func = (
+                self._get_appliances_with_offset_functionality()
+            )
 
-            # Update for cooling
-            if device["dev_class"] in ZONE_THERMOSTATS and not self.smile(ADAM):
-                self.update_for_cooling(device)
+        # Collect and add switching- and/or pump-group devices
+        if group_data := self._get_group_switches():
+            self.gw_devices.update(group_data)
 
-            remove_empty_platform_dicts(device)
+        # Collect the remaining data for all devices
+        self._all_device_data()
 
     def _all_device_data(self) -> None:
         """Helper-function for get_all_devices().
@@ -145,67 +168,49 @@ class SmileData(SmileHelper):
                 {"heater_id": self._heater_id, "cooling_present": self._cooling_present}
             )
 
-    def get_all_devices(self) -> None:
-        """Determine the evices present from the obtained XML-data.
-
-        Run this functions once to gather the initial device configuration,
-        then regularly run async_update() to refresh the device data.
-        """
-        # Gather all the devices and their initial data
-        self._all_appliances()
-        if self.smile_type == "thermostat":
-            self._scan_thermostats()
-            # Collect a list of thermostats with offset-capability
-            self.therms_with_offset_func = (
-                self._get_appliances_with_offset_functionality()
-            )
-
-        # Collect switching- or pump-group data
-        if group_data := self._get_group_switches():
-            self.gw_devices.update(group_data)
-
-        # Collect the remaining data for all device
-        self._all_device_data()
-
     def _device_data_switching_group(
-        self, device: DeviceData, device_data: DeviceData
-    ) -> DeviceData:
+        self, device: DeviceData, data: DeviceData
+    ) -> None:
         """Helper-function for _get_device_data().
 
         Determine switching group device data.
         """
-        if device["dev_class"] not in SWITCH_GROUP_TYPES:
-            return device_data
-
-        counter = 0
-        for member in device["members"]:
-            if self.gw_devices[member]["switches"].get("relay"):
-                counter += 1
-        device_data["switches"]["relay"] = counter != 0
-        self._count += 1
-        return device_data
+        if device["dev_class"] in SWITCH_GROUP_TYPES:
+            counter = 0
+            for member in device["members"]:
+                if self.gw_devices[member]["switches"].get("relay"):
+                    counter += 1
+            data["switches"]["relay"] = counter != 0
+            self._count += 1
 
-    def _device_data_adam(
-        self, device: DeviceData, device_data: DeviceData
-    ) -> DeviceData:
+    def _device_data_adam(self, device: DeviceData, data: DeviceData) -> None:
         """Helper-function for _get_device_data().
 
-        Determine Adam heating-status for on-off heating via valves.
+        Determine Adam heating-status for on-off heating via valves,
+        available regulations_modes and thermostat control_states.
         """
-        # Indicate heating_state based on valves being open in case of city-provided heating
-        if (
-            self.smile(ADAM)
-            and device.get("dev_class") == "heater_central"
-            and self._on_off_device
-            and isinstance(self._heating_valves(), int)
-        ):
-            device_data["binary_sensors"]["heating_state"] = self._heating_valves() != 0
+        if self.smile(ADAM):
+            # Indicate heating_state based on valves being open in case of city-provided heating
+            if (
+                device["dev_class"] == "heater_central"
+                and self._on_off_device
+                and isinstance(self._heating_valves(), int)
+            ):
+                data["binary_sensors"]["heating_state"] = self._heating_valves() != 0
+
+            # Show the allowed regulation modes for Adam
+            if device["dev_class"] == "gateway" and self._reg_allowed_modes:
+                data["regulation_modes"] = self._reg_allowed_modes
+                self._count += 1
 
-        return device_data
+            # Control_state, only for Adam master thermostats
+            if device["dev_class"] in ZONE_THERMOSTATS:
+                loc_id = device["location"]
+                if ctrl_state := self._control_state(loc_id):
+                    data["control_state"] = ctrl_state
+                    self._count += 1
 
-    def _device_data_climate(
-        self, device: DeviceData, device_data: DeviceData
-    ) -> DeviceData:
+    def _device_data_climate(self, device: DeviceData, data: DeviceData) -> None:
         """Helper-function for _get_device_data().
 
         Determine climate-control device data.
@@ -213,44 +218,34 @@ class SmileData(SmileHelper):
         loc_id = device["location"]
 
         # Presets
-        device_data["preset_modes"] = None
-        device_data["active_preset"] = None
+        data["preset_modes"] = None
+        data["active_preset"] = None
         self._count += 2
         if presets := self._presets(loc_id):
-            device_data["preset_modes"] = list(presets)
-            device_data["active_preset"] = self._preset(loc_id)
+            data["preset_modes"] = list(presets)
+            data["active_preset"] = self._preset(loc_id)
 
         # Schedule
         avail_schedules, sel_schedule = self._schedules(loc_id)
-        device_data["available_schedules"] = avail_schedules
-        device_data["select_schedule"] = sel_schedule
+        data["available_schedules"] = avail_schedules
+        data["select_schedule"] = sel_schedule
         self._count += 2
 
-        # Control_state, only for Adam master thermostats
-        if ctrl_state := self._control_state(loc_id):
-            device_data["control_state"] = ctrl_state
-            self._count += 1
-
         # Operation modes: auto, heat, heat_cool, cool and off
-        device_data["mode"] = "auto"
+        data["mode"] = "auto"
         self._count += 1
         if sel_schedule == NONE:
-            device_data["mode"] = "heat"
+            data["mode"] = "heat"
             if self._cooling_present:
-                device_data["mode"] = (
-                    "cool" if self.check_reg_mode("cooling") else "heat_cool"
-                )
+                data["mode"] = "cool" if self.check_reg_mode("cooling") else "heat_cool"
 
         if self.check_reg_mode("off"):
-            device_data["mode"] = "off"
+            data["mode"] = "off"
 
-        if NONE in avail_schedules:
-            return device_data
-
-        device_data = self._get_schedule_states_with_off(
-            loc_id, avail_schedules, sel_schedule, device_data
-        )
-        return device_data
+        if NONE not in avail_schedules:
+            self._get_schedule_states_with_off(
+                loc_id, avail_schedules, sel_schedule, data
+            )
 
     def check_reg_mode(self, mode: str) -> bool:
         """Helper-function for device_data_climate()."""
@@ -261,7 +256,7 @@ class SmileData(SmileHelper):
 
     def _get_schedule_states_with_off(
         self, location: str, schedules: list[str], selected: str, data: DeviceData
-    ) -> DeviceData:
+    ) -> None:
         """Collect schedules with states for each thermostat.
 
         Also, replace NONE by OFF when none of the schedules are active,
@@ -282,34 +277,20 @@ class SmileData(SmileHelper):
             if all_off:
                 data["select_schedule"] = OFF
 
-        return data
-
     def _check_availability(
-        self, device: DeviceData, device_data: DeviceData
-    ) -> DeviceData:
+        self, device: DeviceData, dev_class: str, data: DeviceData, message: str
+    ) -> None:
         """Helper-function for _get_device_data().
 
         Provide availability status for the wired-commected devices.
         """
-        # OpenTherm device
-        if device["dev_class"] == "heater_central" and device["name"] != "OnOff":
-            device_data["available"] = True
+        if device["dev_class"] == dev_class:
+            data["available"] = True
             self._count += 1
-            for data in self._notifications.values():
-                for msg in data.values():
-                    if "no OpenTherm communication" in msg:
-                        device_data["available"] = False
-
-        # Smartmeter
-        if device["dev_class"] == "smartmeter":
-            device_data["available"] = True
-            self._count += 1
-            for data in self._notifications.values():
-                for msg in data.values():
-                    if "P1 does not seem to be connected to a smart meter" in msg:
-                        device_data["available"] = False
-
-        return device_data
+            for item in self._notifications.values():
+                for msg in item.values():
+                    if message in msg:
+                        data["available"] = False
 
     def _get_device_data(self, dev_id: str) -> DeviceData:
         """Helper-function for _all_device_data() and async_update().
@@ -317,44 +298,32 @@ class SmileData(SmileHelper):
         Provide device-data, based on Location ID (= dev_id), from APPLIANCES.
         """
         device = self.gw_devices[dev_id]
-        device_data = self._get_measurement_data(dev_id)
-        # Generic
-        if self.smile_type == "thermostat" and device["dev_class"] == "gateway":
-            # 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
-            outdoor_temperature = self._object_value(
-                self._home_location, "outdoor_temperature"
-            )
-            if outdoor_temperature is not None:
-                device_data["sensors"]["outdoor_temperature"] = outdoor_temperature
-                self._count += 1
-
-            # Show the allowed regulation modes
-            if self._reg_allowed_modes:
-                device_data["regulation_modes"] = self._reg_allowed_modes
-                self._count += 1
-
-        # Show the allowed dhw_modes
-        if device["dev_class"] == "heater_central" and self._dhw_allowed_modes:
-            device_data["dhw_modes"] = self._dhw_allowed_modes
-            self._count += 1
+        data = self._get_measurement_data(dev_id)
 
         # Check availability of non-legacy wired-connected devices
         if not self._smile_legacy:
-            self._check_availability(device, device_data)
+            # Smartmeter
+            self._check_availability(
+                device, "smartmeter", data, "P1 does not seem to be connected"
+            )
+            # OpenTherm device
+            if device["name"] != "OnOff":
+                self._check_availability(
+                    device, "heater_central", data, "no OpenTherm communication"
+                )
 
         # Switching groups data
-        device_data = self._device_data_switching_group(device, device_data)
-        # Specific, not generic Adam data
-        device_data = self._device_data_adam(device, device_data)
-        # No need to obtain thermostat data when the device is not a thermostat
+        self._device_data_switching_group(device, data)
+        # Adam data
+        self._device_data_adam(device, data)
+        # Skip obtaining data for non master-thermostats
         if device["dev_class"] not in ZONE_THERMOSTATS:
-            return device_data
+            return data
 
         # Thermostat data (presets, temperatures etc)
-        device_data = self._device_data_climate(device, device_data)
+        self._device_data_climate(device, data)
 
-        return device_data
+        return data
 
 
 class Smile(SmileComm, SmileData):
@@ -539,14 +508,18 @@ class Smile(SmileComm, SmileData):
             if result.find(locator_2) is not None:
                 self._elga = True
 
-    async def _update_domain_objects(self) -> None:
-        """Helper-function for smile.py: full_update_device() and async_update().
-
-        Request domain_objects data.
-        """
+    async def _full_update_device(self) -> None:
+        """Perform a first fetch of all XML data, needed for initialization."""
         self._domain_objects = await self._request(DOMAIN_OBJECTS)
+        self._get_plugwise_notifications()
+        self._locations = await self._request(LOCATIONS)
+        self._modules = await self._request(MODULES)
+        # P1 legacy has no appliances
+        if not (self.smile_type == "power" and self._smile_legacy):
+            self._appliances = await self._request(APPLIANCES)
 
-        # If Plugwise notifications present:
+    def _get_plugwise_notifications(self) -> None:
+        """Collect the Plugwise notifications."""
         self._notifications = {}
         for notification in self._domain_objects.findall("./notification"):
             try:
@@ -561,15 +534,6 @@ class Smile(SmileComm, SmileData):
                     f"{self._endpoint}{DOMAIN_OBJECTS}",
                 )
 
-    async def _full_update_device(self) -> None:
-        """Perform a first fetch of all XML data, needed for initialization."""
-        await self._update_domain_objects()
-        self._locations = await self._request(LOCATIONS)
-        self._modules = await self._request(MODULES)
-        # P1 legacy has no appliances
-        if not (self.smile_type == "power" and self._smile_legacy):
-            self._appliances = await self._request(APPLIANCES)
-
     async def async_update(self) -> PlugwiseData:
         """Perform an incremental update for updating the various device states."""
         # Perform a full update at day-change
@@ -587,7 +551,8 @@ class Smile(SmileComm, SmileData):
             self.get_all_devices()
         # Otherwise perform an incremental update
         else:
-            await self._update_domain_objects()
+            self._domain_objects = await self._request(DOMAIN_OBJECTS)
+            self._get_plugwise_notifications()
             match self._target_smile:
                 case "smile_v2":
                     self._modules = await self._request(MODULES)
@@ -701,7 +666,7 @@ class Smile(SmileComm, SmileData):
         template = (
             '<template tag="zone_preset_based_on_time_and_presence_with_override" />'
         )
-        if not self.smile(ADAM):
+        if self.smile(ANNA):
             locator = f'.//*[@id="{schedule_rule_id}"]/template'
             template_id = self._domain_objects.find(locator).attrib["id"]
             template = f'<template id="{template_id}" />'
@@ -755,7 +720,7 @@ class Smile(SmileComm, SmileData):
         if "setpoint" in items:
             setpoint = items["setpoint"]
 
-        if self._cooling_present and not self.smile(ADAM):
+        if self.smile(ANNA) and self._cooling_present:
             if "setpoint_high" not in items:
                 raise PlugwiseError(
                     "Plugwise: failed setting temperature: no valid input provided"

{plugwise-0.35.0 → plugwise-0.35.2}/plugwise/constants.py

@@ -80,7 +80,7 @@ HW_MODELS: Final[dict[str, str]] = {
 MAX_SETPOINT: Final[float] = 30.0
 MIN_SETPOINT: Final[float] = 4.0
 NONE: Final = "None"
-OFF: Final = "Off"
+OFF: Final = "off"
 
 # XML data paths
 APPLIANCES: Final = "/core/appliances"
@@ -257,12 +257,6 @@ BinarySensorType = Literal[
 ]
 BINARY_SENSORS: Final[tuple[str, ...]] = get_args(BinarySensorType)
 
-NumberType = Literal[
-    "maximum_boiler_temperature",
-    "max_dhw_temperature",
-    "temperature_offset",
-]
-
 LIMITS: Final[tuple[str, ...]] = (
     "offset",
     "setpoint",
@@ -271,17 +265,6 @@ LIMITS: Final[tuple[str, ...]] = (
     "upper_bound",
 )
 
-SelectType = Literal[
-    "select_dhw_mode",
-    "select_regulation_mode",
-    "select_schedule",
-]
-SelectOptionsType = Literal[
-    "dhw_modes",
-    "regulation_modes",
-    "available_schedules",
-]
-
 SensorType = Literal[
     "battery",
     "cooling_activation_outdoor_temperature",
@@ -505,6 +488,7 @@ class DeviceData(TypedDict, total=False):
     """The Device Data class, covering the collected and ordered output-data per device."""
 
     # Appliance base data
+    has_actuators: bool
     dev_class: str
     firmware: str | None
     hardware: str

{plugwise-0.35.0 → plugwise-0.35.2}/plugwise/helper.py

@@ -570,15 +570,21 @@ class SmileHelper:
                 # Legacy P1 has no more devices
                 return
 
+        hc_count = 0
         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)
+            # Count amount of heater_central's
+            if appl.pwclass == "heater_central":
+                hc_count += 1
+            # Mark heater_central and thermostat that don't have actuator_functionalities,
+            # could be an orphaned device (Core #81712, #104433)
+            appl.has_actuators = True
             if (
-                appl.pwclass == "thermostat"
+                appl.pwclass in ["heater_central", "thermostat"]
                 and appliance.find("actuator_functionalities/") is None
             ):
-                continue
+                appl.has_actuators = False
 
             appl.location = None
             if (appl_loc := appliance.find("location")) is not None:
@@ -622,6 +628,7 @@ class SmileHelper:
             for key, value in {
                 "firmware": appl.firmware,
                 "hardware": appl.hardware,
+                "has_actuators": appl.has_actuators,
                 "location": appl.location,
                 "mac_address": appl.mac,
                 "model": appl.model,
@@ -634,6 +641,22 @@ class SmileHelper:
                     self.gw_devices[appl.dev_id][appl_key] = value
                     self._count += 1
 
+        # Remove thermostat with empty actuator_functionalities (Core #81712), remove heater_central
+        # with empty actuator_functionalities but only when there are more than one (Core #104433).
+        for dev_id, device in dict(self.gw_devices).items():
+            if device["dev_class"] == "thermostat" or (
+                device["dev_class"] == "heater_central" and hc_count > 1
+            ):
+                if not self.gw_devices[dev_id]["has_actuators"]:
+                    self._count -= len(self.gw_devices[dev_id])
+                    self.gw_devices.pop(dev_id)
+                else:
+                    self.gw_devices[dev_id].pop("has_actuators")
+                    self._count -= 1
+            elif "has_actuators" in self.gw_devices[dev_id]:
+                self.gw_devices[dev_id].pop("has_actuators")
+                self._count -= 1
+
         # For non-legacy P1 collect the connected SmartMeter info
         if self.smile_type == "power":
             self._p1_smartmeter_info_finder(appl)
@@ -1016,6 +1039,10 @@ class SmileHelper:
         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._appliances.find(f'./appliance[@id="{dev_id}"]')
@@ -1032,8 +1059,18 @@ class SmileHelper:
             # Collect availability-status for wireless connected devices to Adam
             self._wireless_availablity(appliance, data)
 
-        if dev_id == self.gateway_id and self.smile(ADAM):
-            self._get_regulation_mode(appliance, data)
+            if dev_id == self.gateway_id and self.smile(ADAM):
+                self._get_regulation_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)
@@ -1507,15 +1544,12 @@ class SmileHelper:
         Obtain the toggle state of a 'toggle' = switch.
         """
         if xml.find("type").text == "heater_central":
-            locator = "./actuator_functionalities/toggle_functionality"
-            if found := xml.findall(locator):
-                for item in found:
-                    if (toggle_type := item.find("type")) is not None:
-                        if toggle_type.text == toggle:
-                            data["switches"][name] = item.find("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
+            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
+                # 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

{plugwise-0.35.0 → plugwise-0.35.2}/plugwise.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: plugwise
-Version: 0.35.0
+Version: 0.35.2
 Summary: Plugwise Smile (Adam/Anna/P1) and Stretch module for Python 3.
 Home-page: https://github.com/plugwise/python-plugwise
 Author: Plugwise device owners

{plugwise-0.35.0 → plugwise-0.35.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name            = "plugwise"
-version         = "0.35.0"
+version         = "0.35.2"
 license         = {file = "LICENSE"}
 description     = "Plugwise Smile (Adam/Anna/P1) and Stretch module for Python 3."
 readme          = "README.md"