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

plugwise/helper.py

@@ -5,7 +5,6 @@ Plugwise Smile protocol helpers.
 
 from __future__ import annotations
 
-import asyncio
 import datetime as dt
 from typing import cast
 
@@ -38,29 +37,20 @@ from plugwise.constants import (
     ActuatorData,
     ActuatorDataType,
     ActuatorType,
-    GatewayData,
     GwEntityData,
     SensorType,
     ThermoLoc,
     ToggleNameType,
 )
-from plugwise.exceptions import (
-    ConnectionFailedError,
-    InvalidAuthentication,
-    InvalidXMLError,
-    ResponseError,
-)
 from plugwise.util import (
     check_model,
+    collect_power_values,
     common_match_cases,
-    escape_illegal_xml_characters,
+    count_data_items,
     format_measure,
     skip_obsolete_measurements,
 )
 
-# This way of importing aiohttp is because of patch/mocking in testing (aiohttp timeouts)
-from aiohttp import BasicAuth, ClientError, ClientResponse, ClientSession, ClientTimeout
-
 # Time related
 from dateutil import tz
 from dateutil.parser import parse
@@ -78,204 +68,25 @@ def search_actuator_functionalities(appliance: etree, actuator: str) -> etree |
     return None
 
 
-class SmileComm:
-    """The SmileComm class."""
-
-    def __init__(
-        self,
-        host: str,
-        password: str,
-        port: int,
-        timeout: int,
-        username: str,
-        websession: ClientSession | None,
-    ) -> None:
-        """Set the constructor for this class."""
-        if not websession:
-            aio_timeout = ClientTimeout(total=timeout)
-
-            async def _create_session() -> ClientSession:
-                return ClientSession(timeout=aio_timeout)  # pragma: no cover
-
-            loop = asyncio.get_event_loop()
-            if loop.is_running():
-                self._websession = ClientSession(timeout=aio_timeout)
-            else:
-                self._websession = loop.run_until_complete(
-                    _create_session()
-                )  # pragma: no cover
-        else:
-            self._websession = websession
-
-        # Quickfix IPv6 formatting, not covering
-        if host.count(":") > 2:  # pragma: no cover
-            host = f"[{host}]"
-
-        self._auth = BasicAuth(username, password=password)
-        self._endpoint = f"http://{host}:{str(port)}"
-
-    async def _request(
-        self,
-        command: str,
-        retry: int = 3,
-        method: str = "get",
-        data: str | None = None,
-        headers: dict[str, str] | None = None,
-    ) -> etree:
-        """Get/put/delete data from a give URL."""
-        resp: ClientResponse
-        url = f"{self._endpoint}{command}"
-        use_headers = headers
-
-        try:
-            match method:
-                case "delete":
-                    resp = await self._websession.delete(url, auth=self._auth)
-                case "get":
-                    # Work-around for Stretchv2, should not hurt the other smiles
-                    use_headers = {"Accept-Encoding": "gzip"}
-                    resp = await self._websession.get(
-                        url, headers=use_headers, auth=self._auth
-                    )
-                case "post":
-                    use_headers = {"Content-type": "text/xml"}
-                    resp = await self._websession.post(
-                        url,
-                        headers=use_headers,
-                        data=data,
-                        auth=self._auth,
-                    )
-                case "put":
-                    use_headers = {"Content-type": "text/xml"}
-                    resp = await self._websession.put(
-                        url,
-                        headers=use_headers,
-                        data=data,
-                        auth=self._auth,
-                    )
-        except (
-            ClientError
-        ) as exc:  # ClientError is an ancestor class of ServerTimeoutError
-            if retry < 1:
-                LOGGER.warning(
-                    "Failed sending %s %s to Plugwise Smile, error: %s",
-                    method,
-                    command,
-                    exc,
-                )
-                raise ConnectionFailedError from exc
-            return await self._request(command, retry - 1)
-
-        if resp.status == 504:
-            if retry < 1:
-                LOGGER.warning(
-                    "Failed sending %s %s to Plugwise Smile, error: %s",
-                    method,
-                    command,
-                    "504 Gateway Timeout",
-                )
-                raise ConnectionFailedError
-            return await self._request(command, retry - 1)
-
-        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."""
-        match resp.status:
-            case 200:
-                # Cornercases for server not responding with 202
-                if method in ("post", "put"):
-                    return
-            case 202:
-                # Command accepted gives empty body with status 202
-                return
-            case 401:
-                msg = (
-                    "Invalid Plugwise login, please retry with the correct credentials."
-                )
-                LOGGER.error("%s", msg)
-                raise InvalidAuthentication
-            case 405:
-                msg = "405 Method not allowed."
-                LOGGER.error("%s", msg)
-                raise ConnectionFailedError
-
-        if not (result := await resp.text()) or (
-            "<error>" in result and "Not started" not 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()
-
-
 class SmileHelper(SmileCommon):
     """The SmileHelper class."""
 
     def __init__(self) -> None:
         """Set the constructor for this class."""
-        self._cooling_present: bool
-        self._count: int
-        self._dhw_allowed_modes: list[str] = []
-        self._domain_objects: etree
         self._endpoint: str
         self._elga: bool
-        self._gw_allowed_modes: list[str] = []
-        self._heater_id: str
-        self._home_location: str
         self._is_thermostat: bool
         self._last_active: dict[str, str | None]
-        self._last_modified: dict[str, str] = {}
         self._loc_data: dict[str, ThermoLoc]
-        self._notifications: dict[str, dict[str, str]] = {}
-        self._on_off_device: bool
-        self._opentherm_device: bool
-        self._reg_allowed_modes: list[str] = []
         self._schedule_old_states: dict[str, dict[str, str]]
-        self._status: etree
-        self._stretch_v2: bool
-        self._system: etree
-        self._thermo_locs: dict[str, ThermoLoc] = {}
-        ###################################################################
-        # '_cooling_enabled' can refer to the state of the Elga heatpump
-        # connected to an Anna. For Elga, 'elga_status_code' in (8, 9)
-        # means cooling mode is available, next to heating mode.
-        # 'elga_status_code' = 8 means cooling is active, 9 means idle.
-        #
-        # '_cooling_enabled' cam refer to the state of the Loria or
-        # Thermastage heatpump connected to an Anna. For these,
-        # 'cooling_enabled' = on means set to cooling mode, instead of to
-        # heating mode.
-        # 'cooling_state' = on means cooling is active.
-        ###################################################################
-        self._cooling_active = False
-        self._cooling_enabled = False
-
-        self.gateway_id: str
-        self.gw_data: GatewayData = {}
-        self.gw_entities: dict[str, GwEntityData] = {}
-        self.smile_fw_version: version.Version | None
+        self._gateway_id: str = NONE
+        self._zones: dict[str, GwEntityData]
+        self.gw_entities: dict[str, GwEntityData]
         self.smile_hw_version: str | None
         self.smile_mac_address: str | None
         self.smile_model: str
         self.smile_model_id: str | None
-        self.smile_name: str
-        self.smile_type: str
         self.smile_version: version.Version | None
-        self.smile_zigbee_mac_address: str | None
-        self.therms_with_offset_func: list[str] = []
-        self._zones: dict[str, GwEntityData] = {}
         SmileCommon.__init__(self)
 
     def _all_appliances(self) -> None:
@@ -311,10 +122,10 @@ class SmileHelper(SmileCommon):
             appl.location = None
             if (appl_loc := appliance.find("location")) is not None:
                 appl.location = appl_loc.attrib["id"]
-            # Don't assign the _home_location to thermostat-devices without a location,
+            # Don't assign the _home_loc_id to thermostat-devices without a location,
             # they are not active
             elif appl.pwclass not in THERMOSTAT_CLASSES:
-                appl.location = self._home_location
+                appl.location = self._home_loc_id
 
             # Don't show orphaned thermostat-types
             if appl.pwclass in THERMOSTAT_CLASSES and appl.location is None:
@@ -350,22 +161,16 @@ class SmileHelper(SmileCommon):
         switched to maintain backward compatibility with existing implementations.
         """
         appl = Munch()
-        loc_id = next(iter(self._loc_data.keys()))
-        if (
-            location := self._domain_objects.find(f'./location[@id="{loc_id}"]')
-        ) is None:
-            return
-
         locator = MODULE_LOCATOR
-        module_data = self._get_module_data(location, locator)
+        module_data = self._get_module_data(self._home_location, locator)
         if not module_data["contents"]:
             LOGGER.error("No module data found for SmartMeter")  # pragma: no cover
             return  # pragma: no cover
         appl.available = None
-        appl.entity_id = self.gateway_id
+        appl.entity_id = self._gateway_id
         appl.firmware = module_data["firmware_version"]
         appl.hardware = module_data["hardware_version"]
-        appl.location = loc_id
+        appl.location = self._home_loc_id
         appl.mac = None
         appl.model = module_data["vendor_model"]
         appl.model_id = None  # don't use model_id for SmartMeter
@@ -375,8 +180,8 @@ class SmileHelper(SmileCommon):
         appl.zigbee_mac = None
 
         # Replace the entity_id of the gateway by the smartmeter location_id
-        self.gw_entities[loc_id] = self.gw_entities.pop(self.gateway_id)
-        self.gateway_id = loc_id
+        self.gw_entities[self._home_loc_id] = self.gw_entities.pop(self._gateway_id)
+        self._gateway_id = self._home_loc_id
 
         self._create_gw_entities(appl)
 
@@ -398,10 +203,14 @@ class SmileHelper(SmileCommon):
         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}
+            if loc.name != "Home":
+                continue
+
+            self._home_loc_id = loc.loc_id
+            self._home_location = self._domain_objects.find(
+                f"./location[@id='{loc.loc_id}']"
+            )
 
     def _appliance_info_finder(self, appl: Munch, appliance: etree) -> Munch:
         """Collect info for all appliances found."""
@@ -445,8 +254,8 @@ class SmileHelper(SmileCommon):
 
     def _appl_gateway_info(self, appl: Munch, appliance: etree) -> Munch:
         """Helper-function for _appliance_info_finder()."""
-        self.gateway_id = appliance.attrib["id"]
-        appl.firmware = str(self.smile_fw_version)
+        self._gateway_id = appliance.attrib["id"]
+        appl.firmware = str(self.smile_version)
         appl.hardware = self.smile_hw_version
         appl.mac = self.smile_mac_address
         appl.model = self.smile_model
@@ -485,15 +294,9 @@ class SmileHelper(SmileCommon):
         ) is not None and (modes := search.find("allowed_modes")) is not None:
             for mode in modes:
                 mode_list.append(mode.text)
-                self._check_cooling_mode(mode.text)
 
         return mode_list
 
-    def _check_cooling_mode(self, mode: str) -> None:
-        """Check if cooling mode is present and update state."""
-        if mode == "cooling":
-            self._cooling_present = True
-
     def _get_appliances_with_offset_functionality(self) -> list[str]:
         """Helper-function collecting all appliance that have offset_functionality."""
         therm_list: list[str] = []
@@ -532,7 +335,7 @@ class SmileHelper(SmileCommon):
         # !! DON'T CHANGE below two if-lines, will break stuff !!
         if self.smile_type == "power":
             if entity["dev_class"] == "smartmeter":
-                data.update(self._power_data_from_location(entity["location"]))
+                data.update(self._power_data_from_location())
 
             return data
 
@@ -574,21 +377,20 @@ class SmileHelper(SmileCommon):
 
         return data
 
-    def _power_data_from_location(self, loc_id: str) -> GwEntityData:
+    def _power_data_from_location(self) -> GwEntityData:
         """Helper-function for smile.py: _get_entity_data().
 
-        Collect the power-data based on Location ID, from LOCATIONS.
+        Collect the power-data from the Home location.
         """
         data: GwEntityData = {"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')
+        loc.logs = self._home_location.find("./logs")
         for loc.measurement, loc.attrs in P1_MEASUREMENTS.items():
             for loc.log_type in log_list:
-                self._collect_power_values(data, loc, t_string)
+                collect_power_values(data, loc, t_string)
 
         self._count += len(data["sensors"])
         return data
@@ -624,7 +426,7 @@ class SmileHelper(SmileCommon):
                     appl_i_loc.text, ENERGY_WATT_HOUR
                 )
 
-        self._count_data_items(data)
+        self._count = count_data_items(self._count, data)
 
     def _get_toggle_state(
         self, xml: etree, toggle: str, name: ToggleNameType, data: GwEntityData
@@ -647,7 +449,7 @@ class SmileHelper(SmileCommon):
                 msg_id = notification.attrib["id"]
                 msg_type = notification.find("type").text
                 msg = notification.find("message").text
-                self._notifications.update({msg_id: {msg_type: msg}})
+                self._notifications[msg_id] = {msg_type: msg}
                 LOGGER.debug("Plugwise notifications: %s", self._notifications)
             except AttributeError:  # pragma: no cover
                 LOGGER.debug(
@@ -724,7 +526,7 @@ class SmileHelper(SmileCommon):
 
         Collect the requested gateway mode.
         """
-        if not (self.smile(ADAM) and entity_id == self.gateway_id):
+        if not (self.smile(ADAM) and entity_id == self._gateway_id):
             return None
 
         if (search := search_actuator_functionalities(appliance, key)) is not None:
@@ -764,31 +566,14 @@ class SmileHelper(SmileCommon):
             self._count += 1
 
     def _get_gateway_outdoor_temp(self, entity_id: str, data: GwEntityData) -> None:
-        """Adam & Anna: the Smile outdoor_temperature is present in DOMAIN_OBJECTS and LOCATIONS.
-
-        Available under the Home location.
-        """
-        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}})
+        """Adam & Anna: the Smile outdoor_temperature is present in the Home location."""
+        if self._is_thermostat and entity_id == self._gateway_id:
+            locator = "./logs/point_log[type='outdoor_temperature']/period/measurement"
+            if (found := self._home_location.find(locator)) is not None:
+                value = format_measure(found.text, NONE)
+                data.update({"sensors": {"outdoor_temperature": value}})
                 self._count += 1
 
-    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
-
     def _process_c_heating_state(self, data: GwEntityData) -> None:
         """Helper-function for _get_measurement_data().
 
@@ -840,7 +625,11 @@ class SmileHelper(SmileCommon):
             self._update_loria_cooling(data)
 
     def _update_elga_cooling(self, data: GwEntityData) -> None:
-        """# Anna+Elga: base cooling_state on the elga-status-code."""
+        """# Anna+Elga: base cooling_state on the elga-status-code.
+
+        For Elga, 'elga_status_code' in (8, 9) means cooling is enabled.
+        'elga_status_code' = 8 means cooling is active, 9 means idle.
+        """
         if data["thermostat_supports_cooling"]:
             # Techneco Elga has cooling-capability
             self._cooling_present = True
@@ -862,7 +651,11 @@ class SmileHelper(SmileCommon):
         self._count -= 1
 
     def _update_loria_cooling(self, data: GwEntityData) -> None:
-        """Loria/Thermastage: base cooling-related on cooling_state and modulation_level."""
+        """Loria/Thermastage: base cooling-related on cooling_state and modulation_level.
+
+        For the Loria or Thermastage heatpump connected to an Anna cooling-enabled is
+        indicated via the Cooling Enable switch in the Plugwise App.
+        """
         # For Loria/Thermastage it's not clear if cooling_enabled in xml shows the correct status,
         # setting it specifically:
         self._cooling_enabled = data["binary_sensors"]["cooling_enabled"] = data[
@@ -987,11 +780,9 @@ class SmileHelper(SmileCommon):
         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.
         """
-        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)
+        locator = f'location[@id="{loc_id}"]/actuator_functionalities/thermostat_functionality[type="thermostat"]/control_state'
+        if (ctrl_state := self._domain_objects.find(locator)) is not None:
+            return str(ctrl_state.text)
 
         # Handle missing control_state in regulation_mode off for firmware >= 3.2.0 (issue #776)
         # In newer firmware versions, default to "off" when control_state is not present

plugwise/legacy/data.py

@@ -7,7 +7,7 @@ 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
 
@@ -17,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().