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

plugwise/legacy/data.py

@@ -2,11 +2,12 @@
 
 Plugwise Smile protocol data-collection helpers for legacy devices.
 """
+
 from __future__ import annotations
 
 # Dict as class
 # Version detection
-from plugwise.constants import NONE, OFF, GwEntityData
+from plugwise.constants import NONE, OFF, GwEntityData, SmileProps
 from plugwise.legacy.helper import SmileLegacyHelper
 from plugwise.util import remove_empty_platform_dicts
 
@@ -16,25 +17,20 @@ class SmileLegacyData(SmileLegacyHelper):
 
     def __init__(self) -> None:
         """Init."""
+        self._smile_props: SmileProps
         SmileLegacyHelper.__init__(self)
 
     def _all_entity_data(self) -> None:
         """Helper-function for get_all_gateway_entities().
 
-        Collect data for each entity and add to self.gw_data and self.gw_entities.
+        Collect data for each entity and add to self._smile_props and self.gw_entities.
         """
         self._update_gw_entities()
-        self.gw_data.update(
-            {
-                "gateway_id": self.gateway_id,
-                "item_count": self._count,
-                "smile_name": self.smile_name,
-            }
-        )
+        self._smile_props["gateway_id"] = self.gateway_id
+        self._smile_props["item_count"] = self._count
+        self._smile_props["smile_name"] = self.smile_name
         if self._is_thermostat:
-            self.gw_data.update(
-                {"heater_id": self._heater_id, "cooling_present": False}
-            )
+            self._smile_props["heater_id"] = self._heater_id
 
     def _update_gw_entities(self) -> None:
         """Helper-function for _all_entity_data() and async_update().
@@ -63,6 +59,7 @@ class SmileLegacyData(SmileLegacyHelper):
 
         # Thermostat data (presets, temperatures etc)
         self._climate_data(entity, data)
+        self._get_anna_control_state(data)
 
         return data
 
@@ -91,3 +88,14 @@ class SmileLegacyData(SmileLegacyHelper):
         self._count += 1
         if sel_schedule in (NONE, OFF):
             data["climate_mode"] = "heat"
+
+    def _get_anna_control_state(self, data: GwEntityData) -> None:
+        """Set the thermostat control_state based on the opentherm/onoff device state."""
+        data["control_state"] = "idle"
+        for entity in self.gw_entities.values():
+            if entity["dev_class"] != "heater_central":
+                continue
+
+            binary_sensors = entity["binary_sensors"]
+            if binary_sensors["heating_state"]:
+                data["control_state"] = "heating"

plugwise/legacy/helper.py

@@ -2,6 +2,7 @@
 
 Plugwise Smile protocol helpers.
 """
+
 from __future__ import annotations
 
 from typing import cast
@@ -29,13 +30,14 @@ from plugwise.constants import (
     ActuatorDataType,
     ActuatorType,
     ApplianceType,
-    GatewayData,
     GwEntityData,
     SensorType,
     ThermoLoc,
 )
 from plugwise.util import (
+    collect_power_values,
     common_match_cases,
+    count_data_items,
     format_measure,
     skip_obsolete_measurements,
     version_to_model,
@@ -62,32 +64,15 @@ class SmileLegacyHelper(SmileCommon):
     def __init__(self) -> None:
         """Set the constructor for this class."""
         self._appliances: etree
-        self._count: int
-        self._domain_objects: etree
-        self._heater_id: str
-        self._home_location: str
         self._is_thermostat: bool
-        self._last_modified: dict[str, str] = {}
         self._loc_data: dict[str, ThermoLoc]
         self._locations: etree
         self._modules: etree
-        self._notifications: dict[str, dict[str, str]] = {}
-        self._on_off_device: bool
-        self._opentherm_device: bool
-        self._outdoor_temp: float
-        self._status: etree
         self._stretch_v2: bool
-        self._system: etree
-
-        self.gateway_id: str
-        self.gw_data: GatewayData = {}
         self.gw_entities: dict[str, GwEntityData] = {}
-        self.smile_fw_version: Version | None
-        self.smile_hw_version: str | None
         self.smile_mac_address: str | None
         self.smile_model: str
-        self.smile_name: str
-        self.smile_type: str
+        self.smile_version: Version | None
         self.smile_zigbee_mac_address: str | None
         SmileCommon.__init__(self)
 
@@ -114,7 +99,7 @@ class SmileLegacyHelper(SmileCommon):
             ):
                 continue  # pragma: no cover
 
-            appl.location = self._home_location
+            appl.location = self._home_loc_id
             appl.entity_id = appliance.attrib["id"]
             appl.name = appliance.find("name").text
             # Extend device_class name when a Circle/Stealth is type heater_central -- Pw-Beta Issue #739
@@ -160,7 +145,7 @@ class SmileLegacyHelper(SmileCommon):
 
         # Legacy Anna without outdoor_temp and Stretches have no locations, create fake location-data
         if not (locations := self._locations.findall("./location")):
-            self._home_location = FAKE_LOC
+            self._home_loc_id = FAKE_LOC
             self._loc_data[FAKE_LOC] = {"name": "Home"}
             return
 
@@ -169,18 +154,15 @@ class SmileLegacyHelper(SmileCommon):
             loc.loc_id = location.attrib["id"]
             # Filter the valid single location for P1 legacy: services not empty
             locator = "./services"
-            if (
-                self.smile_type == "power"
-                and len(location.find(locator)) == 0
-            ):
+            if self.smile_type == "power" and len(location.find(locator)) == 0:
                 continue
 
             if loc.name == "Home":
-                self._home_location = loc.loc_id
+                self._home_loc_id = loc.loc_id
             # Replace location-name for P1 legacy, can contain privacy-related info
             if self.smile_type == "power":
                 loc.name = "Home"
-                self._home_location = loc.loc_id
+                self._home_loc_id = loc.loc_id
 
             self._loc_data[loc.loc_id] = {"name": loc.name}
 
@@ -189,15 +171,15 @@ class SmileLegacyHelper(SmileCommon):
 
         Use the home_location or FAKE_APPL as entity id.
         """
-        self.gateway_id = self._home_location
+        self.gateway_id = self._home_loc_id
         if self.smile_type == "power":
             self.gateway_id = FAKE_APPL
 
         self.gw_entities[self.gateway_id] = {"dev_class": "gateway"}
         self._count += 1
         for key, value in {
-            "firmware": str(self.smile_fw_version),
-            "location": self._home_location,
+            "firmware": str(self.smile_version),
+            "location": self._home_loc_id,
             "mac_address": self.smile_mac_address,
             "model": self.smile_model,
             "name": self.smile_name,
@@ -212,15 +194,15 @@ class SmileLegacyHelper(SmileCommon):
     def _appliance_info_finder(self, appliance: etree, appl: Munch) -> Munch:
         """Collect entity info (Smile/Stretch, Thermostats, OpenTherm/On-Off): firmware, model and vendor name."""
         match appl.pwclass:
-        # Collect thermostat entity info
+            # Collect thermostat entity info
             case _ as dev_class if dev_class in THERMOSTAT_CLASSES:
                 return self._appl_thermostat_info(appl, appliance, self._modules)
-        # Collect heater_central entity info
+            # Collect heater_central entity info
             case "heater_central":
                 return self._appl_heater_central_info(
                     appl, appliance, True, self._appliances, self._modules
                 )  # True means legacy device
-        # Collect info from Stretches
+            # Collect info from Stretches
             case _:
                 return self._energy_entity_info_finder(appliance, appl)
 
@@ -231,7 +213,9 @@ class SmileLegacyHelper(SmileCommon):
         """
         if self.smile_type in ("power", "stretch"):
             locator = "./services/electricity_point_meter"
-            module_data = self._get_module_data(appliance, locator, self._modules, legacy=True)
+            module_data = self._get_module_data(
+                appliance, locator, self._modules, legacy=True
+            )
             appl.zigbee_mac = module_data["zigbee_mac_address"]
             # Filter appliance without zigbee_mac, it's an orphaned device
             if appl.zigbee_mac is None and self.smile_type != "power":
@@ -272,7 +256,7 @@ class SmileLegacyHelper(SmileCommon):
         Collect the appliance-data based on entity_id.
         """
         data: GwEntityData = {"binary_sensors": {}, "sensors": {}, "switches": {}}
-        # Get P1 smartmeter data from LOCATIONS or MODULES
+        # Get P1 smartmeter data from MODULES
         entity = self.gw_entities[entity_id]
         # !! DON'T CHANGE below two if-lines, will break stuff !!
         if self.smile_type == "power":
@@ -294,14 +278,13 @@ class SmileLegacyHelper(SmileCommon):
             if appliance.find("type").text in ACTUATOR_CLASSES:
                 self._get_actuator_functionalities(appliance, entity, 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
+        # Anna: the Smile outdoor_temperature is present in the Home location
+        # For some Anna's LOCATIONS is empty, falling back to domain_objects!
         if self._is_thermostat and entity_id == self.gateway_id:
-            outdoor_temperature = self._object_value(
-                self._home_location, "outdoor_temperature"
-            )
-            if outdoor_temperature is not None:
-                data.update({"sensors": {"outdoor_temperature": outdoor_temperature}})
+            locator = f"./location[@id='{self._home_loc_id}']/logs/point_log[type='outdoor_temperature']/period/measurement"
+            if (found := self._domain_objects.find(locator)) is not None:
+                value = format_measure(found.text, NONE)
+                data.update({"sensors": {"outdoor_temperature": value}})
                 self._count += 1
 
         if "c_heating_state" in data:
@@ -326,7 +309,7 @@ class SmileLegacyHelper(SmileCommon):
             loc.meas_list = loc.measurement.split("_")
             for loc.logs in mod_logs:
                 for loc.log_type in mod_list:
-                    self._collect_power_values(data, loc, t_string, legacy=True)
+                    collect_power_values(data, loc, t_string, legacy=True)
 
         self._count += len(data["sensors"])
         return data
@@ -359,13 +342,10 @@ class SmileLegacyHelper(SmileCommon):
                     appl_i_loc.text, ENERGY_WATT_HOUR
                 )
 
-        self._count_data_items(data)
+        self._count = count_data_items(self._count, data)
 
     def _get_actuator_functionalities(
-        self,
-        xml: etree,
-        entity: GwEntityData,
-        data: GwEntityData
+        self, xml: etree, entity: GwEntityData, data: GwEntityData
     ) -> None:
         """Helper-function for _get_measurement_data()."""
         for item in ACTIVE_ACTUATORS:
@@ -399,20 +379,6 @@ class SmileLegacyHelper(SmileCommon):
                 act_item = cast(ActuatorType, item)
                 data[act_item] = temp_dict
 
-    def _object_value(self, obj_id: str, measurement: str) -> float | int | None:
-        """Helper-function for smile.py: _get_entity_data().
-
-        Obtain the value/state for the given object from a location in DOMAIN_OBJECTS
-        """
-        val: float | int | None = None
-        search = self._domain_objects
-        locator = f'./location[@id="{obj_id}"]/logs/point_log[type="{measurement}"]/period/measurement'
-        if (found := search.find(locator)) is not None:
-            val = format_measure(found.text, NONE)
-            return val
-
-        return val
-
     def _preset(self) -> str | None:
         """Helper-function for smile.py: _climate_data().
 
@@ -458,7 +424,9 @@ class SmileLegacyHelper(SmileCommon):
             active = result.text == "on"
 
         # Show an empty schedule as no schedule found
-        directives = search.find(f'./rule[@id="{rule_id}"]/directives/when/then') is not None
+        directives = (
+            search.find(f'./rule[@id="{rule_id}"]/directives/when/then') is not None
+        )
         if directives and name is not None:
             available = [name, OFF]
             selected = name if active else OFF

plugwise/legacy/smile.py

@@ -2,6 +2,7 @@
 
 Plugwise backend module for Home Assistant Core - covering the legacy P1, Anna, and Stretch devices.
 """
+
 from __future__ import annotations
 
 from collections.abc import Awaitable, Callable
@@ -10,8 +11,6 @@ from typing import Any
 
 from plugwise.constants import (
     APPLIANCES,
-    DEFAULT_PORT,
-    DEFAULT_USERNAME,
     DOMAIN_OBJECTS,
     LOCATIONS,
     LOGGER,
@@ -19,46 +18,40 @@ from plugwise.constants import (
     OFF,
     REQUIRE_APPLIANCES,
     RULES,
-    GatewayData,
     GwEntityData,
-    PlugwiseData,
+    SmileProps,
     ThermoLoc,
 )
-from plugwise.exceptions import ConnectionFailedError, PlugwiseError
+from plugwise.exceptions import ConnectionFailedError, DataMissingError, PlugwiseError
 from plugwise.legacy.data import SmileLegacyData
 
-import aiohttp
 from munch import Munch
 from packaging.version import Version
 
 
 class SmileLegacyAPI(SmileLegacyData):
-    """The Plugwise SmileLegacyAPI class."""
+    """The Plugwise SmileLegacyAPI helper class for actual Plugwise legacy devices."""
 
     # pylint: disable=too-many-instance-attributes, too-many-public-methods
 
     def __init__(
         self,
-        host: str,
-        password: str,
-        request: Callable[..., Awaitable[Any]],
-        websession: aiohttp.ClientSession,
         _is_thermostat: bool,
         _loc_data: dict[str, ThermoLoc],
         _on_off_device: bool,
         _opentherm_device: bool,
+        _request: Callable[..., Awaitable[Any]],
+        _smile_props: SmileProps,
         _stretch_v2: bool,
         _target_smile: str,
-        smile_fw_version: Version | None,
         smile_hostname: str,
         smile_hw_version: str | None,
         smile_mac_address: str | None,
         smile_model: str,
         smile_name: str,
         smile_type: str,
+        smile_version: Version | None,
         smile_zigbee_mac_address: str | None,
-        port: int = DEFAULT_PORT,
-        username: str = DEFAULT_USERNAME,
     ) -> None:
         """Set the constructor for this class."""
         self._cooling_present = False
@@ -66,81 +59,86 @@ class SmileLegacyAPI(SmileLegacyData):
         self._loc_data = _loc_data
         self._on_off_device = _on_off_device
         self._opentherm_device = _opentherm_device
+        self._request = _request
+        self._smile_props = _smile_props
         self._stretch_v2 = _stretch_v2
         self._target_smile = _target_smile
-        self.request = request
-        self.smile_fw_version = smile_fw_version
         self.smile_hostname = smile_hostname
         self.smile_hw_version = smile_hw_version
         self.smile_mac_address = smile_mac_address
         self.smile_model = smile_model
         self.smile_name = smile_name
         self.smile_type = smile_type
+        self.smile_version = smile_version
         self.smile_zigbee_mac_address = smile_zigbee_mac_address
         SmileLegacyData.__init__(self)
 
+        self._first_update = True
         self._previous_day_number: str = "0"
 
     async def full_xml_update(self) -> None:
-        """Perform a first fetch of all XML data, needed for initialization."""
-        self._domain_objects = await self.request(DOMAIN_OBJECTS)
-        self._locations = await self.request(LOCATIONS)
-        self._modules = await self.request(MODULES)
+        """Perform a first fetch of the Plugwise server XML data."""
+        self._domain_objects = await self._request(DOMAIN_OBJECTS)
+        self._locations = await self._request(LOCATIONS)
+        self._modules = await self._request(MODULES)
         # P1 legacy has no appliances
         if self.smile_type != "power":
-            self._appliances = await self.request(APPLIANCES)
+            self._appliances = await self._request(APPLIANCES)
 
     def get_all_gateway_entities(self) -> None:
-        """Collect the gateway entities from the received raw XML-data.
+        """Collect the Plugwise gateway entities and their data and states from the received raw XML-data.
 
-        Run this functions once to gather the initial device configuration,
-        then regularly run async_update() to refresh the device data.
+        First, collect all the connected entities and their initial data.
+        Collect and add switching- and/or pump-group entities.
+        Finally, collect the data and states for each entity.
         """
-        # Gather all the devices and their initial data
         self._all_appliances()
-
-        # Collect and add switching- and/or pump-group devices
         if group_data := self._get_group_switches():
             self.gw_entities.update(group_data)
 
-        # Collect the remaining data for all entities
         self._all_entity_data()
 
-    async def async_update(self) -> PlugwiseData:
-        """Perform an incremental update for updating the various device states."""
-        # Perform a full update at day-change
+    async def async_update(self) -> dict[str, GwEntityData]:
+        """Perform an full update update at day-change: re-collect all gateway entities and their data and states.
+
+        Otherwise perform an incremental update: only collect the entities updated data and states.
+        """
         day_number = dt.datetime.now().strftime("%w")
-        if (
-            day_number  # pylint: disable=consider-using-assignment-expr
-            != self._previous_day_number
-        ):
+        if self._first_update or day_number != self._previous_day_number:
             LOGGER.info(
                 "Performing daily full-update, reload the Plugwise integration when a single entity becomes unavailable."
             )
-            self.gw_data: GatewayData = {}
-            self.gw_entities: dict[str, GwEntityData] = {}
-            await self.full_xml_update()
-            self.get_all_gateway_entities()
-        # Otherwise perform an incremental update
+            try:
+                await self.full_xml_update()
+                self.get_all_gateway_entities()
+                # Detect failed data-retrieval
+                _ = self.gw_entities[self.gateway_id]["location"]
+            except KeyError as err:  # pragma: no cover
+                raise DataMissingError(
+                    "No (full) Plugwise legacy data received"
+                ) from err
         else:
-            self._domain_objects = await self.request(DOMAIN_OBJECTS)
-            match self._target_smile:
-                case "smile_v2":
-                    self._modules = await self.request(MODULES)
-                case self._target_smile if self._target_smile in REQUIRE_APPLIANCES:
-                    self._appliances = await self.request(APPLIANCES)
-
-            self._update_gw_entities()
-
+            try:
+                self._domain_objects = await self._request(DOMAIN_OBJECTS)
+                match self._target_smile:
+                    case "smile_v2":
+                        self._modules = await self._request(MODULES)
+                    case self._target_smile if self._target_smile in REQUIRE_APPLIANCES:
+                        self._appliances = await self._request(APPLIANCES)
+
+                self._update_gw_entities()
+                # Detect failed data-retrieval
+                _ = self.gw_entities[self.gateway_id]["location"]
+            except KeyError as err:  # pragma: no cover
+                raise DataMissingError("No legacy Plugwise data received") from err
+
+        self._first_update = False
         self._previous_day_number = day_number
-        return PlugwiseData(
-            devices=self.gw_entities,
-            gateway=self.gw_data,
-        )
+        return self.gw_entities
 
-########################################################################################################
-###  API Set and HA Service-related Functions                                                        ###
-########################################################################################################
+    ########################################################################################################
+    ###  API Set and HA Service-related Functions                                                        ###
+    ########################################################################################################
 
     async def delete_notification(self) -> None:
         """Set-function placeholder for legacy devices."""
@@ -181,12 +179,16 @@ class SmileLegacyAPI(SmileLegacyData):
     async def set_regulation_mode(self, mode: str) -> None:
         """Set-function placeholder for legacy devices."""
 
-    async def set_select(self, key: str, loc_id: str, option: str, state: str | None) -> None:
+    async def set_select(
+        self, key: str, loc_id: str, option: str, state: str | None
+    ) -> None:
         """Set the thermostat schedule option."""
         # schedule name corresponds to select option
         await self.set_schedule_state("dummy", state, option)
 
-    async def set_schedule_state(self, _: str, state: str | None, name: str | None) -> None:
+    async def set_schedule_state(
+        self, _: str, state: str | None, name: str | None
+    ) -> None:
         """Activate/deactivate the Schedule.
 
         Determined from - DOMAIN_OBJECTS.
@@ -205,7 +207,9 @@ class SmileLegacyAPI(SmileLegacyData):
                 schedule_rule_id = rule.attrib["id"]
 
         if schedule_rule_id is None:
-            raise PlugwiseError("Plugwise: no schedule with this name available.")  # pragma: no cover
+            raise PlugwiseError(
+                "Plugwise: no schedule with this name available."
+            )  # pragma: no cover
 
         new_state = "false"
         if state == "on":
@@ -290,6 +294,6 @@ class SmileLegacyAPI(SmileLegacyData):
         method: str = kwargs["method"]
         data: str | None = kwargs.get("data")
         try:
-            await self.request(uri, method=method, data=data)
+            await self._request(uri, method=method, data=data)
         except ConnectionFailedError as exc:
             raise ConnectionFailedError from exc