Update naming

Author: bouwew

plugwise/__init__.py

@@ -298,17 +298,17 @@ async def _smile_detect_legacy(
         self.smile_legacy = True
         return return_model
 
-    async def full_update_device(self) -> None:
+    async def full_xml_update(self) -> None:
         """Helper-function used for testing."""
-        await self._smile_api.full_update_device()
+        await self._smile_api.full_xml_update()
 
-    def get_all_device_zones(self) -> None:
+    def get_all_gateway_entities(self) -> None:
         """Helper-function used for testing."""
-        self._smile_api.get_all_device_zones()
+        self._smile_api.get_all_gateway_entities()
 
     async def async_update(self) -> PlugwiseData:
-        """Perform an incremental update for updating the various device states."""
-        data = PlugwiseData(device_zones={}, gateway={})
+        """Update the various entities and their states."""
+        data = PlugwiseData(entities={}, gateway={})
         try:
             data = await self._smile_api.async_update()
             self.gateway_id = data.gateway["gateway_id"]

plugwise/common.py

@@ -11,8 +11,8 @@
     SPECIAL_PLUG_TYPES,
     SWITCH_GROUP_TYPES,
     ApplianceType,
-    DeviceZoneData,
-    ModelData,
+    GwEntityData,
+    ModuleData,
     SensorType,
 )
 from plugwise.util import (
@@ -40,7 +40,7 @@ def __init__(self) -> None:
         self._heater_id: str
         self._on_off_device: bool
         self._opentherm_device: bool
-        self.gw_device_zones: dict[str, DeviceZoneData]
+        self.gw_entities: dict[str, GwEntityData]
         self.smile_name: str
         self.smile_type: str
 
@@ -108,7 +108,7 @@ def _appl_thermostat_info(self, appl: Munch, xml_1: etree, xml_2: etree = None)
 
         return appl
 
-    def _collect_power_values(self, data: DeviceZoneData, loc: Munch, tariff: str, legacy: bool = False) -> None:
+    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 = (
@@ -160,8 +160,8 @@ def _power_data_energy_diff(
         measurement: str,
         net_string: SensorType,
         f_val: float | int,
-        direct_data: DeviceZoneData,
-    ) -> DeviceZoneData:
+        data: GwEntityData,
+    ) -> GwEntityData:
         """Calculate differential energy."""
         if (
             "electricity" in measurement
@@ -174,21 +174,21 @@ def _power_data_energy_diff(
             if net_string not in direct_data["sensors"]:
                 tmp_val: float | int = 0
             else:
-                tmp_val = direct_data["sensors"][net_string]
+                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}")
 
-            direct_data["sensors"][net_string] = tmp_val
+            data["sensors"][net_string] = tmp_val
 
-        return direct_data
+        return data
 
-    def _create_gw_device_zones(self, appl: Munch) -> None:
-        """Helper-function for creating/updating gw_device_zones."""
-        self.gw_device_zones[appl.dev_id] = {"dev_class": appl.pwclass}
+    def _create_gw_entities(self, appl: Munch) -> None:
+        """Helper-function for creating/updating gw_entities."""
+        self.gw_entities[appl.dev_id] = {"dev_class": appl.pwclass}
         self._count += 1
         for key, value in {
             "available": appl.available,
@@ -204,30 +204,30 @@ def _create_gw_device_zones(self, appl: Munch) -> None:
         }.items():
             if value is not None or key == "location":
                 appl_key = cast(ApplianceType, key)
-                self.gw_device_zones[appl.dev_id][appl_key] = value
+                self.gw_entities[appl.dev_id][appl_key] = value
                 self._count += 1
 
-    def _device_data_switching_group(
-        self, device: DeviceZoneData, data: DeviceZoneData
+    def _entity_switching_group(
+        self, entity: GwEntityData, data: GwEntityData
     ) -> None:
         """Helper-function for _get_device_zone_data().
 
         Determine switching group device data.
         """
-        if device["dev_class"] in SWITCH_GROUP_TYPES:
+        if entity["dev_class"] in SWITCH_GROUP_TYPES:
             counter = 0
-            for member in device["members"]:
-                if self.gw_device_zones[member]["switches"].get("relay"):
+            for member in entity["members"]:
+                if self.gw_entities[member]["switches"].get("relay"):
                     counter += 1
             data["switches"]["relay"] = counter != 0
             self._count += 1
 
-    def _get_group_switches(self) -> dict[str, DeviceZoneData]:
-        """Helper-function for smile.py: get_all_device_zones().
+    def _get_group_switches(self) -> dict[str, GwEntityData]:
+        """Helper-function for smile.py: get_all_gateway_entities().
 
         Collect switching- or pump-group info.
         """
-        switch_groups: dict[str, DeviceZoneData] = {}
+        switch_groups: dict[str, GwEntityData] = {}
         # P1 and Anna don't have switchgroups
         if self.smile_type == "power" or self.smile(ANNA):
             return switch_groups
@@ -240,25 +240,21 @@ def _get_group_switches(self) -> dict[str, DeviceZoneData]:
             group_appliances = group.findall("appliances/appliance")
             for item in group_appliances:
                 # Check if members are not orphaned - stretch
-                if item.attrib["id"] in self.gw_device_zones:
+                if item.attrib["id"] in self.gw_entities:
                     members.append(item.attrib["id"])
 
             if group_type in SWITCH_GROUP_TYPES and members:
-                switch_groups.update(
-                    {
-                        group_id: {
-                            "dev_class": group_type,
-                            "model": "Switchgroup",
-                            "name": group_name,
-                            "members": members,
-                        },
-                    },
-                )
+                switch_groups[group_id] = {
+                    "dev_class": group_type,
+                    "model": "Switchgroup",
+                    "name": group_name,
+                    "members": members,
+                }
                 self._count += 4
 
         return switch_groups
 
-    def _get_lock_state(self, xml: etree, data: DeviceZoneData, 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.
@@ -280,12 +276,12 @@ def _get_module_data(
         locator: str,
         xml_2: etree = None,
         legacy: bool = False,
-    ) -> ModelData:
+    ) -> ModuleData:
         """Helper-function for _energy_device_info_finder() and _appliance_info_finder().
 
         Collect requested info from MODULES.
         """
-        model_data: ModelData = {
+        module_data: ModuleData = {
             "contents": False,
             "firmware_version": None,
             "hardware_version": None,
@@ -304,25 +300,25 @@ def _get_module_data(
             search = return_valid(xml_2, self._domain_objects)
             module = search.find(loc)
             if module is not None:  # pylint: disable=consider-using-assignment-expr
-                model_data["contents"] = True
-                get_vendor_name(module, model_data)
-                model_data["vendor_model"] = module.find("vendor_model").text
-                model_data["hardware_version"] = module.find("hardware_version").text
-                model_data["firmware_version"] = module.find("firmware_version").text
-                self._get_zigbee_data(module, model_data, legacy)
+                module_data["contents"] = True
+                get_vendor_name(module, module_data)
+                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)
 
-        return model_data
+        return module_data
 
-    def _get_zigbee_data(self, module: etree, model_data: ModelData, legacy: bool) -> None:
-        """Helper-function for _get_model_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:
-                model_data["zigbee_mac_address"] = router.find("mac_address").text
+                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:
-                model_data["zigbee_mac_address"] = coord.find("mac_address").text
+                module_data["zigbee_mac_address"] = coord.find("mac_address").text
         # Adam
         elif (zb_node := module.find("./protocols/zig_bee_node")) is not None:
-                model_data["zigbee_mac_address"] = zb_node.find("mac_address").text
-                model_data["reachable"] = zb_node.find("reachable").text == "true"
+                module_data["zigbee_mac_address"] = zb_node.find("mac_address").text
+                module_data["reachable"] = zb_node.find("reachable").text == "true"

plugwise/constants.py

@@ -405,8 +405,8 @@ class GatewayData(TypedDict, total=False):
     smile_name: str
 
 
-class ModelData(TypedDict):
-    """The ModelData class."""
+class ModuleData(TypedDict):
+    """The Module data class."""
 
     contents: bool
     firmware_version: str | None
@@ -516,8 +516,8 @@ class ActuatorData(TypedDict, total=False):
     upper_bound: float
 
 
-class DeviceZoneData(TypedDict, total=False):
-    """The DeviceZone data class.
+class GwEntityData(TypedDict, total=False):
+    """The Gateway Entity data class.
 
     Covering the collected output-data per device or location.
     """
@@ -582,5 +582,6 @@ class DeviceZoneData(TypedDict, total=False):
 class PlugwiseData:
     """Plugwise data provided as output."""
 
+    entities: dict[str, GwEntityData]
     gateway: GatewayData
-    device_zones: dict[str, DeviceZoneData]
+