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

plugwise/legacy/helper.py

@@ -30,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,
@@ -63,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)
 
@@ -115,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
@@ -161,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
 
@@ -174,11 +158,11 @@ class SmileLegacyHelper(SmileCommon):
                 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}
 
@@ -187,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,
@@ -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,7 +342,7 @@ 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
@@ -396,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().
 

plugwise/legacy/smile.py

@@ -11,8 +11,6 @@ from typing import Any
 
 from plugwise.constants import (
     APPLIANCES,
-    DEFAULT_PORT,
-    DEFAULT_USERNAME,
     DOMAIN_OBJECTS,
     LOCATIONS,
     LOGGER,
@@ -20,46 +18,40 @@ from plugwise.constants import (
     OFF,
     REQUIRE_APPLIANCES,
     RULES,
-    GatewayData,
     GwEntityData,
-    PlugwiseData,
+    SmileProps,
     ThermoLoc,
 )
 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
@@ -67,59 +59,55 @@ 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] = {}
             try:
                 await self.full_xml_update()
                 self.get_all_gateway_entities()
@@ -129,15 +117,14 @@ class SmileLegacyAPI(SmileLegacyData):
                 raise DataMissingError(
                     "No (full) Plugwise legacy data received"
                 ) from err
-        # Otherwise perform an incremental update
         else:
             try:
-                self._domain_objects = await self.request(DOMAIN_OBJECTS)
+                self._domain_objects = await self._request(DOMAIN_OBJECTS)
                 match self._target_smile:
                     case "smile_v2":
-                        self._modules = await self.request(MODULES)
+                        self._modules = await self._request(MODULES)
                     case self._target_smile if self._target_smile in REQUIRE_APPLIANCES:
-                        self._appliances = await self.request(APPLIANCES)
+                        self._appliances = await self._request(APPLIANCES)
 
                 self._update_gw_entities()
                 # Detect failed data-retrieval
@@ -145,11 +132,9 @@ class SmileLegacyAPI(SmileLegacyData):
             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                                                        ###
@@ -309,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

plugwise/smile.py

@@ -13,8 +13,6 @@ from plugwise.constants import (
     ADAM,
     ANNA,
     APPLIANCES,
-    DEFAULT_PORT,
-    DEFAULT_USERNAME,
     DOMAIN_OBJECTS,
     GATEWAY_REBOOT,
     LOCATIONS,
@@ -23,15 +21,13 @@ from plugwise.constants import (
     NOTIFICATIONS,
     OFF,
     RULES,
-    GatewayData,
     GwEntityData,
-    PlugwiseData,
+    SmileProps,
     ThermoLoc,
 )
 from plugwise.data import SmileData
 from plugwise.exceptions import ConnectionFailedError, DataMissingError, PlugwiseError
 
-import aiohttp
 from defusedxml import ElementTree as etree
 
 # Dict as class
@@ -46,10 +42,6 @@ class SmileAPI(SmileData):
 
     def __init__(
         self,
-        host: str,
-        password: str,
-        request: Callable[..., Awaitable[Any]],
-        websession: aiohttp.ClientSession,
         _cooling_present: bool,
         _elga: bool,
         _is_thermostat: bool,
@@ -57,9 +49,9 @@ class SmileAPI(SmileData):
         _loc_data: dict[str, ThermoLoc],
         _on_off_device: bool,
         _opentherm_device: bool,
+        _request: Callable[..., Awaitable[Any]],
         _schedule_old_states: dict[str, dict[str, str]],
-        gateway_id: str,
-        smile_fw_version: Version | None,
+        _smile_props: SmileProps,
         smile_hostname: str | None,
         smile_hw_version: str | None,
         smile_mac_address: str | None,
@@ -68,23 +60,18 @@ class SmileAPI(SmileData):
         smile_name: str,
         smile_type: str,
         smile_version: Version | None,
-        port: int = DEFAULT_PORT,
-        username: str = DEFAULT_USERNAME,
     ) -> None:
         """Set the constructor for this class."""
-        self._cooling_enabled = False
         self._cooling_present = _cooling_present
         self._elga = _elga
-        self._heater_id: str
         self._is_thermostat = _is_thermostat
         self._last_active = _last_active
         self._loc_data = _loc_data
         self._on_off_device = _on_off_device
         self._opentherm_device = _opentherm_device
+        self._request = _request
         self._schedule_old_states = _schedule_old_states
-        self.gateway_id = gateway_id
-        self.request = request
-        self.smile_fw_version = smile_fw_version
+        self._smile_props = _smile_props
         self.smile_hostname = smile_hostname
         self.smile_hw_version = smile_hw_version
         self.smile_mac_address = smile_mac_address
@@ -93,48 +80,49 @@ class SmileAPI(SmileData):
         self.smile_name = smile_name
         self.smile_type = smile_type
         self.smile_version = smile_version
+        self.therms_with_offset_func: list[str] = []
         SmileData.__init__(self)
 
     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)
+        """Perform a first fetch of the Plugwise server XML data."""
+        self._domain_objects = await self._request(DOMAIN_OBJECTS)
         self._get_plugwise_notifications()
 
     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 configuration,
-        then regularly run async_update() to refresh the entity data.
+        First, collect all the connected entities and their initial data.
+        If a thermostat-gateway, collect a list of thermostats with offset-capability.
+        Collect and add switching- and/or pump-group entities.
+        Finally, collect the data and states for each entity.
         """
-        # Gather all the entities and their initial data
         self._all_appliances()
         if self._is_thermostat:
-            if self.smile(ADAM):
-                self._scan_thermostats()
-            # Collect a list of thermostats with offset-capability
             self.therms_with_offset_func = (
                 self._get_appliances_with_offset_functionality()
             )
+            if self.smile(ADAM):
+                self._scan_thermostats()
 
-        # 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."""
-        self.gw_data: GatewayData = {}
-        self.gw_entities: dict[str, GwEntityData] = {}
-        self._zones: dict[str, GwEntityData] = {}
+    async def async_update(self) -> dict[str, GwEntityData]:
+        """Perform an full update: re-collect all gateway entities and their data and states.
+
+        Any change in the connected entities will be detected immediately.
+        """
+        self._zones = {}
+        self.gw_entities = {}
         try:
             await self.full_xml_update()
             self.get_all_gateway_entities()
-            # Set self._cooling_enabled - required for set_temperature,
+            # Set self._cooling_enabled - required for set_temperature(),
             # also, check for a failed data-retrieval
-            if "heater_id" in self.gw_data:
-                heat_cooler = self.gw_entities[self.gw_data["heater_id"]]
+            if "heater_id" in self._smile_props:
+                heat_cooler = self.gw_entities[self._smile_props["heater_id"]]
                 if (
                     "binary_sensors" in heat_cooler
                     and "cooling_enabled" in heat_cooler["binary_sensors"]
@@ -143,14 +131,11 @@ class SmileAPI(SmileData):
                         "cooling_enabled"
                     ]
             else:  # cover failed data-retrieval for P1
-                _ = self.gw_entities[self.gateway_id]["location"]
+                _ = self.gw_entities[self._smile_props["gateway_id"]]["location"]
         except KeyError as err:
             raise DataMissingError("No Plugwise actual data received") from err
 
-        return PlugwiseData(
-            devices=self.gw_entities,
-            gateway=self.gw_data,
-        )
+        return self.gw_entities
 
     ########################################################################################################
     ###  API Set and HA Service-related Functions                                                        ###
@@ -274,7 +259,7 @@ class SmileAPI(SmileData):
             vacation_time = time_2 + "T23:00:00.000Z"
             valid = f"<valid_from>{vacation_time}</valid_from><valid_to>{end_time}</valid_to>"
 
-        uri = f"{APPLIANCES};id={self.gateway_id}/gateway_mode_control"
+        uri = f"{APPLIANCES};id={self._smile_props['gateway_id']}/gateway_mode_control"
         data = f"<gateway_mode_control_functionality><mode>{mode}</mode>{valid}</gateway_mode_control_functionality>"
 
         await self.call_request(uri, method="put", data=data)
@@ -476,6 +461,6 @@ class SmileAPI(SmileData):
         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

plugwise/smilecomm.py

@@ -0,0 +1,148 @@
+"""Use of this source code is governed by the MIT license found in the LICENSE file.
+
+Plugwise Smile communication protocol helpers.
+"""
+
+from __future__ import annotations
+
+from plugwise.constants import LOGGER
+from plugwise.exceptions import (
+    ConnectionFailedError,
+    InvalidAuthentication,
+    InvalidXMLError,
+    ResponseError,
+)
+from plugwise.util import escape_illegal_xml_characters
+
+# This way of importing aiohttp is because of patch/mocking in testing (aiohttp timeouts)
+from aiohttp import BasicAuth, ClientError, ClientResponse, ClientSession, ClientTimeout
+from defusedxml import ElementTree as etree
+
+
+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)
+            self._websession = ClientSession(timeout=aio_timeout)
+        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)}"  # Sensitive
+
+    async def _request(
+        self,
+        command: str,
+        retry: int = 3,
+        method: str = "get",
+        data: str | None = None,
+    ) -> etree:
+        """Get/put/delete data from a give URL."""
+        resp: ClientResponse
+        url = f"{self._endpoint}{command}"
+        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
+                    headers = {"Accept-Encoding": "gzip"}
+                    resp = await self._websession.get(
+                        url, headers=headers, auth=self._auth
+                    )
+                case "post":
+                    headers = {"Content-type": "text/xml"}
+                    resp = await self._websession.post(
+                        url,
+                        headers=headers,
+                        data=data,
+                        auth=self._auth,
+                    )
+                case "put":
+                    headers = {"Content-type": "text/xml"}
+                    resp = await self._websession.put(
+                        url,
+                        headers=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()