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

plugwise/__init__.py

@@ -2,6 +2,7 @@
 
 Plugwise backend module for Home Assistant Core.
 """
+
 from __future__ import annotations
 
 from plugwise.constants import (
@@ -16,7 +17,8 @@ from plugwise.constants import (
     SMILES,
     STATUS,
     SYSTEM,
-    PlugwiseData,
+    GwEntityData,
+    SmileProps,
     ThermoLoc,
 )
 from plugwise.exceptions import (
@@ -27,9 +29,9 @@ from plugwise.exceptions import (
     ResponseError,
     UnsupportedDeviceError,
 )
-from plugwise.helper import SmileComm
 from plugwise.legacy.smile import SmileLegacyAPI
 from plugwise.smile import SmileAPI
+from plugwise.smilecomm import SmileComm
 
 import aiohttp
 from defusedxml import ElementTree as etree
@@ -37,9 +39,7 @@ from packaging.version import Version, parse
 
 
 class Smile(SmileComm):
-    """The Plugwise SmileConnect class."""
-
-    # pylint: disable=too-many-instance-attributes, too-many-public-methods
+    """The main Plugwise Smile API class."""
 
     def __init__(
         self,
@@ -50,20 +50,15 @@ class Smile(SmileComm):
         username: str = DEFAULT_USERNAME,
     ) -> None:
         """Set the constructor for this class."""
-        self._host = host
-        self._password = password
-        self._port = port
         self._timeout = DEFAULT_LEGACY_TIMEOUT
-        self._username = username
-        self._websession = websession
         super().__init__(
-            self._host,
-            self._password,
-            self._port,
+            host,
+            password,
+            port,
             self._timeout,
-            self._username,
-            self._websession,
-         )
+            username,
+            websession,
+        )
 
         self._cooling_present = False
         self._elga = False
@@ -74,10 +69,9 @@ class Smile(SmileComm):
         self._opentherm_device = False
         self._schedule_old_states: dict[str, dict[str, str]] = {}
         self._smile_api: SmileAPI | SmileLegacyAPI
+        self._smile_props: SmileProps = {}
         self._stretch_v2 = False
         self._target_smile: str = NONE
-        self.gateway_id: str = NONE
-        self.smile_fw_version: Version | None = None
         self.smile_hostname: str = NONE
         self.smile_hw_version: str | None = None
         self.smile_legacy = False
@@ -89,8 +83,40 @@ class Smile(SmileComm):
         self.smile_version: Version | None = None
         self.smile_zigbee_mac_address: str | None = None
 
+    @property
+    def cooling_present(self) -> bool:
+        """Return the cooling capability."""
+        if "cooling_present" in self._smile_props:
+            return self._smile_props["cooling_present"]
+        return False
+
+    @property
+    def gateway_id(self) -> str:
+        """Return the gateway-id."""
+        return self._smile_props["gateway_id"]
+
+    @property
+    def heater_id(self) -> str:
+        """Return the heater-id."""
+        if "heater_id" in self._smile_props:
+            return self._smile_props["heater_id"]
+        return NONE
+
+    @property
+    def item_count(self) -> int:
+        """Return the item-count."""
+        return self._smile_props["item_count"]
+
+    @property
+    def reboot(self) -> bool:
+        """Return the reboot capability.
+
+        All non-legacy devices support gateway-rebooting.
+        """
+        return not self.smile_legacy
+
     async def connect(self) -> Version | None:
-        """Connect to Plugwise device and determine its name, type and version."""
+        """Connect to the Plugwise Gateway and determine its name, type, version, and other data."""
         result = await self._request(DOMAIN_OBJECTS)
         # Work-around for Stretch fw 2.7.18
         if not (vendor_names := result.findall("./module/vendor_name")):
@@ -125,52 +151,46 @@ class Smile(SmileComm):
         # Determine smile specifics
         await self._smile_detect(result, dsmrmain)
 
-        self._smile_api = SmileAPI(
-            self._host,
-            self._password,
-            self._request,
-            self._websession,
-            self._cooling_present,
-            self._elga,
-            self._is_thermostat,
-            self._last_active,
-            self._loc_data,
-            self._on_off_device,
-            self._opentherm_device,
-            self._schedule_old_states,
-            self.gateway_id,
-            self.smile_fw_version,
-            self.smile_hostname,
-            self.smile_hw_version,
-            self.smile_mac_address,
-            self.smile_model,
-            self.smile_model_id,
-            self.smile_name,
-            self.smile_type,
-            self.smile_version,
-            self._port,
-            self._username,
-         ) if not self.smile_legacy else SmileLegacyAPI(
-            self._host,
-            self._password,
-            self._request,
-            self._websession,
-            self._is_thermostat,
-            self._loc_data,
-            self._on_off_device,
-            self._opentherm_device,
-            self._stretch_v2,
-            self._target_smile,
-            self.smile_fw_version,
-            self.smile_hostname,
-            self.smile_hw_version,
-            self.smile_mac_address,
-            self.smile_model,
-            self.smile_name,
-            self.smile_type,
-            self.smile_zigbee_mac_address,
-            self._port,
-            self._username,
+        self._smile_api = (
+            SmileAPI(
+                self._cooling_present,
+                self._elga,
+                self._is_thermostat,
+                self._last_active,
+                self._loc_data,
+                self._on_off_device,
+                self._opentherm_device,
+                self._request,
+                self._schedule_old_states,
+                self._smile_props,
+                self.smile_hostname,
+                self.smile_hw_version,
+                self.smile_mac_address,
+                self.smile_model,
+                self.smile_model_id,
+                self.smile_name,
+                self.smile_type,
+                self.smile_version,
+            )
+            if not self.smile_legacy
+            else SmileLegacyAPI(
+                self._is_thermostat,
+                self._loc_data,
+                self._on_off_device,
+                self._opentherm_device,
+                self._request,
+                self._smile_props,
+                self._stretch_v2,
+                self._target_smile,
+                self.smile_hostname,
+                self.smile_hw_version,
+                self.smile_mac_address,
+                self.smile_model,
+                self.smile_name,
+                self.smile_type,
+                self.smile_version,
+                self.smile_zigbee_mac_address,
+            )
         )
 
         # Update all endpoints on first connect
@@ -181,13 +201,13 @@ class Smile(SmileComm):
     async def _smile_detect(self, result: etree, dsmrmain: etree) -> None:
         """Helper-function for connect().
 
-        Detect which type of Smile is connected.
+        Detect which type of Plugwise Gateway is being connected.
         """
         model: str = "Unknown"
         if (gateway := result.find("./gateway")) is not None:
             if (v_model := gateway.find("vendor_model")) is not None:
                 model = v_model.text
-            self.smile_fw_version = parse(gateway.find("firmware_version").text)
+            self.smile_version = parse(gateway.find("firmware_version").text)
             self.smile_hw_version = gateway.find("hardware_version").text
             self.smile_hostname = gateway.find("hostname").text
             self.smile_mac_address = gateway.find("mac_address").text
@@ -195,7 +215,7 @@ class Smile(SmileComm):
         else:
             model = await self._smile_detect_legacy(result, dsmrmain, model)
 
-        if model == "Unknown" or self.smile_fw_version is None:  # pragma: no cover
+        if model == "Unknown" or self.smile_version is None:  # pragma: no cover
             # Corner case check
             LOGGER.error(
                 "Unable to find model or version information, please create"
@@ -203,7 +223,7 @@ class Smile(SmileComm):
             )
             raise UnsupportedDeviceError
 
-        version_major= str(self.smile_fw_version.major)
+        version_major = str(self.smile_version.major)
         self._target_smile = f"{model}_v{version_major}"
         LOGGER.debug("Plugwise identified as %s", self._target_smile)
         if self._target_smile not in SMILES:
@@ -227,7 +247,6 @@ class Smile(SmileComm):
         self.smile_model = "Gateway"
         self.smile_name = SMILES[self._target_smile].smile_name
         self.smile_type = SMILES[self._target_smile].smile_type
-        self.smile_version = self.smile_fw_version
 
         if self.smile_type == "stretch":
             self._stretch_v2 = int(version_major) == 2
@@ -255,7 +274,10 @@ class Smile(SmileComm):
     async def _smile_detect_legacy(
         self, result: etree, dsmrmain: etree, model: str
     ) -> str:
-        """Helper-function for _smile_detect()."""
+        """Helper-function for _smile_detect().
+
+        Detect which type of legacy Plugwise Gateway is being connected.
+        """
         return_model = model
         # Stretch: find the MAC of the zigbee master_controller (= Stick)
         if (network := result.find("./module/protocols/master_controller")) is not None:
@@ -273,7 +295,7 @@ class Smile(SmileComm):
             or network is not None
         ):
             system = await self._request(SYSTEM)
-            self.smile_fw_version = parse(system.find("./gateway/firmware").text)
+            self.smile_version = parse(system.find("./gateway/firmware").text)
             return_model = system.find("./gateway/product").text
             self.smile_hostname = system.find("./gateway/hostname").text
             # If wlan0 contains data it's active, so eth0 should be checked last
@@ -284,7 +306,7 @@ class Smile(SmileComm):
         # P1 legacy:
         elif dsmrmain is not None:
             status = await self._request(STATUS)
-            self.smile_fw_version = parse(status.find("./system/version").text)
+            self.smile_version = parse(status.find("./system/version").text)
             return_model = status.find("./system/product").text
             self.smile_hostname = status.find("./network/hostname").text
             self.smile_mac_address = status.find("./network/mac_address").text
@@ -299,28 +321,19 @@ class Smile(SmileComm):
         self.smile_legacy = True
         return return_model
 
-    async def full_xml_update(self) -> None:
-        """Helper-function used for testing."""
-        await self._smile_api.full_xml_update()
-
-    def get_all_gateway_entities(self) -> None:
-        """Helper-function used for testing."""
-        self._smile_api.get_all_gateway_entities()
-
-    async def async_update(self) -> PlugwiseData:
-        """Update the various entities and their states."""
-        data = PlugwiseData(devices={}, gateway={})
+    async def async_update(self) -> dict[str, GwEntityData]:
+        """Update the Plughwise Gateway entities and their data and states."""
+        data: dict[str, GwEntityData] = {}
         try:
             data = await self._smile_api.async_update()
-            self.gateway_id = data.gateway["gateway_id"]
         except (DataMissingError, KeyError) as err:
             raise PlugwiseError("No Plugwise data received") from err
 
         return data
 
-########################################################################################################
-###  API Set and HA Service-related Functions                                                        ###
-########################################################################################################
+    ########################################################################################################
+    ###  API Set and HA Service-related Functions                                                        ###
+    ########################################################################################################
 
     async def set_select(
         self,
@@ -333,7 +346,9 @@ class Smile(SmileComm):
         try:
             await self._smile_api.set_select(key, loc_id, option, state)
         except ConnectionFailedError as exc:
-            raise ConnectionFailedError(f"Failed to set select option '{option}': {str(exc)}") from exc
+            raise ConnectionFailedError(
+                f"Failed to set select option '{option}': {str(exc)}"
+            ) from exc
 
     async def set_schedule_state(
         self,
@@ -345,8 +360,9 @@ class Smile(SmileComm):
         try:
             await self._smile_api.set_schedule_state(loc_id, state, name)
         except ConnectionFailedError as exc:  # pragma no cover
-            raise ConnectionFailedError(f"Failed to set schedule state: {str(exc)}") from exc  # pragma no cover
-
+            raise ConnectionFailedError(
+                f"Failed to set schedule state: {str(exc)}"
+            ) from exc  # pragma no cover
 
     async def set_preset(self, loc_id: str, preset: str) -> None:
         """Set the given Preset on the relevant Thermostat."""
@@ -360,7 +376,9 @@ class Smile(SmileComm):
         try:
             await self._smile_api.set_temperature(loc_id, items)
         except ConnectionFailedError as exc:
-            raise ConnectionFailedError(f"Failed to set temperature: {str(exc)}") from exc
+            raise ConnectionFailedError(
+                f"Failed to set temperature: {str(exc)}"
+            ) from exc
 
     async def set_number(
         self,
@@ -372,14 +390,18 @@ class Smile(SmileComm):
         try:
             await self._smile_api.set_number(dev_id, key, temperature)
         except ConnectionFailedError as exc:
-            raise ConnectionFailedError(f"Failed to set number '{key}': {str(exc)}") from exc
+            raise ConnectionFailedError(
+                f"Failed to set number '{key}': {str(exc)}"
+            ) from exc
 
     async def set_temperature_offset(self, dev_id: str, offset: float) -> None:
         """Set the Temperature offset for thermostats that support this feature."""
         try:  # pragma no cover
             await self._smile_api.set_offset(dev_id, offset)  # pragma: no cover
         except ConnectionFailedError as exc:  # pragma no cover
-            raise ConnectionFailedError(f"Failed to set temperature offset: {str(exc)}") from exc  # pragma no cover
+            raise ConnectionFailedError(
+                f"Failed to set temperature offset: {str(exc)}"
+            ) from exc  # pragma no cover
 
     async def set_switch_state(
         self, appl_id: str, members: list[str] | None, model: str, state: str
@@ -388,39 +410,51 @@ class Smile(SmileComm):
         try:
             await self._smile_api.set_switch_state(appl_id, members, model, state)
         except ConnectionFailedError as exc:
-            raise ConnectionFailedError(f"Failed to set switch state: {str(exc)}") from exc
+            raise ConnectionFailedError(
+                f"Failed to set switch state: {str(exc)}"
+            ) from exc
 
     async def set_gateway_mode(self, mode: str) -> None:
         """Set the gateway mode."""
         try:  # pragma no cover
             await self._smile_api.set_gateway_mode(mode)  # pragma: no cover
         except ConnectionFailedError as exc:  # pragma no cover
-            raise ConnectionFailedError(f"Failed to set gateway mode: {str(exc)}") from exc  # pragma no cover
+            raise ConnectionFailedError(
+                f"Failed to set gateway mode: {str(exc)}"
+            ) from exc  # pragma no cover
 
     async def set_regulation_mode(self, mode: str) -> None:
         """Set the heating regulation mode."""
         try:  # pragma no cover
             await self._smile_api.set_regulation_mode(mode)  # pragma: no cover
         except ConnectionFailedError as exc:  # pragma no cover
-            raise ConnectionFailedError(f"Failed to set regulation mode: {str(exc)}") from exc  # pragma no cover
+            raise ConnectionFailedError(
+                f"Failed to set regulation mode: {str(exc)}"
+            ) from exc  # pragma no cover
 
     async def set_dhw_mode(self, mode: str) -> None:
         """Set the domestic hot water heating regulation mode."""
         try:  # pragma no cover
             await self._smile_api.set_dhw_mode(mode)  # pragma: no cover
         except ConnectionFailedError as exc:  # pragma no cover
-            raise ConnectionFailedError(f"Failed to set dhw mode: {str(exc)}") from exc  # pragma no cover
+            raise ConnectionFailedError(
+                f"Failed to set dhw mode: {str(exc)}"
+            ) from exc  # pragma no cover
 
     async def delete_notification(self) -> None:
         """Delete the active Plugwise Notification."""
         try:
             await self._smile_api.delete_notification()
         except ConnectionFailedError as exc:
-            raise ConnectionFailedError(f"Failed to delete notification: {str(exc)}") from exc
+            raise ConnectionFailedError(
+                f"Failed to delete notification: {str(exc)}"
+            ) from exc
 
     async def reboot_gateway(self) -> None:
         """Reboot the Plugwise Gateway."""
         try:
             await self._smile_api.reboot_gateway()
         except ConnectionFailedError as exc:
-            raise ConnectionFailedError(f"Failed to reboot gateway: {str(exc)}") from exc
+            raise ConnectionFailedError(
+                f"Failed to reboot gateway: {str(exc)}"
+            ) from exc

plugwise/common.py

@@ -2,25 +2,24 @@
 
 Plugwise Smile protocol helpers.
 """
+
 from __future__ import annotations
 
 from typing import cast
 
 from plugwise.constants import (
     ANNA,
+    NONE,
     SPECIAL_PLUG_TYPES,
     SWITCH_GROUP_TYPES,
     ApplianceType,
     GwEntityData,
     ModuleData,
-    SensorType,
 )
 from plugwise.util import (
-    check_alternative_location,
     check_heater_central,
     check_model,
     get_vendor_name,
-    power_data_local_format,
     return_valid,
 )
 
@@ -28,19 +27,32 @@ from defusedxml import ElementTree as etree
 from munch import Munch
 
 
+def get_zigbee_data(module: etree, module_data: ModuleData, legacy: bool) -> None:
+    """Helper-function for _get_module_data()."""
+    if legacy:
+        # Stretches
+        if (router := module.find("./protocols/network_router")) is not None:
+            module_data["zigbee_mac_address"] = router.find("mac_address").text
+        # Also look for the Circle+/Stealth M+
+        if (coord := module.find("./protocols/network_coordinator")) is not None:
+            module_data["zigbee_mac_address"] = coord.find("mac_address").text
+    # Adam
+    elif (zb_node := module.find("./protocols/zig_bee_node")) is not None:
+        module_data["zigbee_mac_address"] = zb_node.find("mac_address").text
+        module_data["reachable"] = zb_node.find("reachable").text == "true"
+
+
 class SmileCommon:
     """The SmileCommon class."""
 
     def __init__(self) -> None:
         """Init."""
-        self._appliances: etree
+        self._cooling_present: bool
         self._count: int
         self._domain_objects: etree
-        self._cooling_present: bool
-        self._heater_id: str
+        self._heater_id: str = NONE
         self._on_off_device: bool
-        self._opentherm_device: bool
-        self.gw_entities: dict[str, GwEntityData]
+        self.gw_entities: dict[str, GwEntityData] = {}
         self.smile_name: str
         self.smile_type: str
 
@@ -83,21 +95,23 @@ class SmileCommon:
         appl.hardware = module_data["hardware_version"]
         appl.model_id = module_data["vendor_model"] if not legacy else None
         appl.model = (
-            "Generic heater/cooler"
-            if self._cooling_present
-            else "Generic heater"
+            "Generic heater/cooler" if self._cooling_present else "Generic heater"
         )
 
         return appl
 
-    def _appl_thermostat_info(self, appl: Munch, xml_1: etree, xml_2: etree = None) -> Munch:
+    def _appl_thermostat_info(
+        self, appl: Munch, xml_1: etree, xml_2: etree = None
+    ) -> Munch:
         """Helper-function for _appliance_info_finder()."""
         locator = "./logs/point_log[type='thermostat']/thermostat"
         xml_2 = return_valid(xml_2, self._domain_objects)
         module_data = self._get_module_data(xml_1, locator, xml_2)
         appl.vendor_name = module_data["vendor_name"]
         appl.model = module_data["vendor_model"]
-        if appl.model != "ThermoTouch":  # model_id for Anna not present as stand-alone device
+        if (
+            appl.model != "ThermoTouch"
+        ):  # model_id for Anna not present as stand-alone device
             appl.model_id = appl.model
             appl.model = check_model(appl.model, appl.vendor_name)
 
@@ -108,97 +122,6 @@ class SmileCommon:
 
         return appl
 
-    def _collect_power_values(self, data: GwEntityData, loc: Munch, tariff: str, legacy: bool = False) -> None:
-        """Something."""
-        for loc.peak_select in ("nl_peak", "nl_offpeak"):
-            loc.locator = (
-                f'./{loc.log_type}[type="{loc.measurement}"]/period/'
-                f'measurement[@{tariff}="{loc.peak_select}"]'
-            )
-            if legacy:
-                loc.locator = (
-                    f"./{loc.meas_list[0]}_{loc.log_type}/measurement"
-                    f'[@directionality="{loc.meas_list[1]}"][@{tariff}="{loc.peak_select}"]'
-                )
-
-            loc = self._power_data_peak_value(loc, legacy)
-            if not loc.found:
-                continue
-
-            data = self._power_data_energy_diff(
-                loc.measurement, loc.net_string, loc.f_val, data
-            )
-            key = cast(SensorType, loc.key_string)
-            data["sensors"][key] = loc.f_val
-
-    def _count_data_items(self, data: GwEntityData) -> None:
-        """When present, count the binary_sensors, sensors and switches dict-items, don't count the dicts.
-
-        Also, count the remaining single data items, the amount of dicts present have already been pre-subtracted in the previous step.
-        """
-        if "binary_sensors" in data:
-            self._count += len(data["binary_sensors"]) - 1
-        if "sensors" in data:
-            self._count += len(data["sensors"]) - 1
-        if "switches" in data:
-            self._count += len(data["switches"]) - 1
-        self._count += len(data)
-
-    def _power_data_peak_value(self, loc: Munch, legacy: bool) -> Munch:
-        """Helper-function for _power_data_from_location() and _power_data_from_modules()."""
-        loc.found = True
-        if loc.logs.find(loc.locator) is None:
-            loc = check_alternative_location(loc, legacy)
-            if not loc.found:
-                return loc
-
-        if (peak := loc.peak_select.split("_")[1]) == "offpeak":
-            peak = "off_peak"
-        log_found = loc.log_type.split("_")[0]
-        loc.key_string = f"{loc.measurement}_{peak}_{log_found}"
-        if "gas" in loc.measurement or loc.log_type == "point_meter":
-            loc.key_string = f"{loc.measurement}_{log_found}"
-        # Only for P1 Actual -------------------#
-        if "phase" in loc.measurement:
-            loc.key_string = f"{loc.measurement}"
-        # --------------------------------------#
-        loc.net_string = f"net_electricity_{log_found}"
-        val = loc.logs.find(loc.locator).text
-        loc.f_val = power_data_local_format(loc.attrs, loc.key_string, val)
-
-        return loc
-
-    def _power_data_energy_diff(
-        self,
-        measurement: str,
-        net_string: SensorType,
-        f_val: float | int,
-        data: GwEntityData,
-    ) -> GwEntityData:
-        """Calculate differential energy."""
-        if (
-            "electricity" in measurement
-            and "phase" not in measurement
-            and "interval" not in net_string
-        ):
-            diff = 1
-            if "produced" in measurement:
-                diff = -1
-            if net_string not in data["sensors"]:
-                tmp_val: float | int = 0
-            else:
-                tmp_val = data["sensors"][net_string]
-
-            if isinstance(f_val, int):
-                tmp_val += f_val * diff
-            else:
-                tmp_val += float(f_val * diff)
-                tmp_val = float(f"{round(tmp_val, 3):.3f}")
-
-            data["sensors"][net_string] = tmp_val
-
-        return data
-
     def _create_gw_entities(self, appl: Munch) -> None:
         """Helper-function for creating/updating gw_entities."""
         self.gw_entities[appl.entity_id] = {"dev_class": appl.pwclass}
@@ -220,9 +143,7 @@ class SmileCommon:
                 self.gw_entities[appl.entity_id][appl_key] = value
                 self._count += 1
 
-    def _entity_switching_group(
-        self, entity: GwEntityData, data: GwEntityData
-    ) -> None:
+    def _entity_switching_group(self, entity: GwEntityData, data: GwEntityData) -> None:
         """Helper-function for _get_device_zone_data().
 
         Determine switching group device data.
@@ -268,7 +189,9 @@ class SmileCommon:
 
         return switch_groups
 
-    def _get_lock_state(self, xml: etree, data: GwEntityData, stretch_v2: bool = False) -> None:
+    def _get_lock_state(
+        self, xml: etree, data: GwEntityData, stretch_v2: bool = False
+    ) -> None:
         """Helper-function for _get_measurement_data().
 
         Adam & Stretches: obtain the relay-switch lock state.
@@ -319,20 +242,6 @@ class SmileCommon:
                 module_data["vendor_model"] = module.find("vendor_model").text
                 module_data["hardware_version"] = module.find("hardware_version").text
                 module_data["firmware_version"] = module.find("firmware_version").text
-                self._get_zigbee_data(module, module_data, legacy)
+                get_zigbee_data(module, module_data, legacy)
 
         return module_data
-
-    def _get_zigbee_data(self, module: etree, module_data: ModuleData, legacy: bool) -> None:
-        """Helper-function for _get_module_data()."""
-        if legacy:
-            # Stretches
-            if (router := module.find("./protocols/network_router")) is not None:
-                module_data["zigbee_mac_address"] = router.find("mac_address").text
-            # Also look for the Circle+/Stealth M+
-            if (coord := module.find("./protocols/network_coordinator")) is not None:
-                module_data["zigbee_mac_address"] = coord.find("mac_address").text
-        # Adam
-        elif (zb_node := module.find("./protocols/zig_bee_node")) is not None:
-                module_data["zigbee_mac_address"] = zb_node.find("mac_address").text
-                module_data["reachable"] = zb_node.find("reachable").text == "true"