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

plugwise/__init__.py

@@ -17,7 +17,8 @@ from plugwise.constants import (
     SMILES,
     STATUS,
     SYSTEM,
-    PlugwiseData,
+    GwEntityData,
+    SmileProps,
     ThermoLoc,
 )
 from plugwise.exceptions import (
@@ -28,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
@@ -38,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,
@@ -51,19 +50,14 @@ 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
@@ -75,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
@@ -90,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")):
@@ -128,10 +153,6 @@ class Smile(SmileComm):
 
         self._smile_api = (
             SmileAPI(
-                self._host,
-                self._password,
-                self._request,
-                self._websession,
                 self._cooling_present,
                 self._elga,
                 self._is_thermostat,
@@ -139,9 +160,9 @@ class Smile(SmileComm):
                 self._loc_data,
                 self._on_off_device,
                 self._opentherm_device,
+                self._request,
                 self._schedule_old_states,
-                self.gateway_id,
-                self.smile_fw_version,
+                self._smile_props,
                 self.smile_hostname,
                 self.smile_hw_version,
                 self.smile_mac_address,
@@ -150,31 +171,25 @@ class Smile(SmileComm):
                 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._request,
+                self._smile_props,
                 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_version,
                 self.smile_zigbee_mac_address,
-                self._port,
-                self._username,
             )
         )
 
@@ -186,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
@@ -200,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"
@@ -208,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:
@@ -232,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
@@ -260,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:
@@ -278,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
@@ -289,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
@@ -304,20 +321,11 @@ 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
 

plugwise/common.py

@@ -9,19 +9,17 @@ 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,
 )
 
@@ -29,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
 
@@ -111,99 +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}
@@ -324,22 +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"

plugwise/constants.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 from collections import namedtuple
-from dataclasses import dataclass
 import logging
 from typing import Final, Literal, TypedDict, get_args
 
@@ -394,14 +393,13 @@ ZONE_THERMOSTATS: Final[tuple[str, ...]] = (
 )
 
 
-class GatewayData(TypedDict, total=False):
-    """The Gateway Data class."""
+class SmileProps(TypedDict, total=False):
+    """The SmileProps Data class."""
 
     cooling_present: bool
     gateway_id: str
     heater_id: str
     item_count: int
-    notifications: dict[str, dict[str, str]]
     reboot: bool
     smile_name: str
 
@@ -552,6 +550,7 @@ class GwEntityData(TypedDict, total=False):
 
     # Gateway
     gateway_modes: list[str]
+    notifications: dict[str, dict[str, str]]
     regulation_modes: list[str]
     select_gateway_mode: str
     select_regulation_mode: str
@@ -577,11 +576,3 @@ class GwEntityData(TypedDict, total=False):
     switches: SmileSwitches
     temperature_offset: ActuatorData
     thermostat: ActuatorData
-
-
-@dataclass
-class PlugwiseData:
-    """Plugwise data provided as output."""
-
-    devices: dict[str, GwEntityData]
-    gateway: GatewayData

plugwise/data.py

@@ -16,6 +16,7 @@ from plugwise.constants import (
     OFF,
     ActuatorData,
     GwEntityData,
+    SmileProps,
 )
 from plugwise.helper import SmileHelper
 from plugwise.util import remove_empty_platform_dicts
@@ -26,31 +27,27 @@ class SmileData(SmileHelper):
 
     def __init__(self) -> None:
         """Init."""
+        self._smile_props: SmileProps
+        self._zones: dict[str, GwEntityData] = {}
         SmileHelper.__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()
         if self.smile(ADAM):
             self._update_zones()
             self.gw_entities.update(self._zones)
 
-        self.gw_data.update(
-            {
-                "gateway_id": self.gateway_id,
-                "item_count": self._count,
-                "notifications": self._notifications,
-                "reboot": True,
-                "smile_name": self.smile_name,
-            }
-        )
+        self._smile_props["gateway_id"] = self._gateway_id
+        self._smile_props["item_count"] = self._count
+        self._smile_props["reboot"] = True
+        self._smile_props["smile_name"] = self.smile_name
         if self._is_thermostat:
-            self.gw_data.update(
-                {"heater_id": self._heater_id, "cooling_present": self._cooling_present}
-            )
+            self._smile_props["heater_id"] = self._heater_id
+            self._smile_props["cooling_present"] = self._cooling_present
 
     def _update_zones(self) -> None:
         """Helper-function for _all_entity_data() and async_update().
@@ -69,7 +66,7 @@ class SmileData(SmileHelper):
         mac_list: list[str] = []
         for entity_id, entity in self.gw_entities.items():
             data = self._get_entity_data(entity_id)
-            if entity_id == self.gateway_id:
+            if entity_id == self._gateway_id:
                 mac_list = self._detect_low_batteries()
                 self._add_or_update_notifications(entity_id, entity, data)
 
@@ -123,14 +120,15 @@ class SmileData(SmileHelper):
     ) -> None:
         """Helper-function adding or updating the Plugwise notifications."""
         if (
-            entity_id == self.gateway_id
+            entity_id == self._gateway_id
             and (self._is_thermostat or self.smile_type == "power")
         ) or (
             "binary_sensors" in entity
             and "plugwise_notification" in entity["binary_sensors"]
         ):
             data["binary_sensors"]["plugwise_notification"] = bool(self._notifications)
-            self._count += 1
+            data["notifications"] = self._notifications
+            self._count += 2
 
     def _update_for_cooling(self, entity: GwEntityData) -> None:
         """Helper-function for adding/updating various cooling-related values."""
@@ -305,7 +303,7 @@ class SmileData(SmileHelper):
 
     def check_reg_mode(self, mode: str) -> bool:
         """Helper-function for device_data_climate()."""
-        gateway = self.gw_entities[self.gateway_id]
+        gateway = self.gw_entities[self._gateway_id]
         return (
             "regulation_modes" in gateway and gateway["select_regulation_mode"] == mode
         )
@@ -313,6 +311,7 @@ class SmileData(SmileHelper):
     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"
+        self._count += 1
         for entity in self.gw_entities.values():
             if entity["dev_class"] != "heater_central":
                 continue