plugwise 1.5.1a3__py3-none-any.whl → 1.6.0__py3-none-any.whl

plugwise/legacy/data.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 
 # Dict as class
 # Version detection
-from plugwise.constants import NONE, OFF, DeviceData
+from plugwise.constants import NONE, OFF, GwEntityData
 from plugwise.legacy.helper import SmileLegacyHelper
 from plugwise.util import remove_empty_platform_dicts
 
@@ -18,12 +18,12 @@ class SmileLegacyData(SmileLegacyHelper):
         """Init."""
         SmileLegacyHelper.__init__(self)
 
-    def _all_device_data(self) -> None:
-        """Helper-function for get_all_devices().
+    def _all_entity_data(self) -> None:
+        """Helper-function for get_all_gateway_entities().
 
-        Collect data for each device and add to self.gw_data and self.gw_devices.
+        Collect data for each entity and add to self.gw_data and self.gw_entities.
         """
-        self._update_gw_devices()
+        self._update_gw_entities()
         self.gw_data.update(
             {
                 "gateway_id": self.gateway_id,
@@ -36,40 +36,40 @@ class SmileLegacyData(SmileLegacyHelper):
                 {"heater_id": self._heater_id, "cooling_present": False}
             )
 
-    def _update_gw_devices(self) -> None:
-        """Helper-function for _all_device_data() and async_update().
+    def _update_gw_entities(self) -> None:
+        """Helper-function for _all_entity_data() and async_update().
 
-        Collect data for each device and add to self.gw_devices.
+        Collect data for each entity and add to self.gw_entities.
         """
-        for device_id, device in self.gw_devices.items():
-            data = self._get_device_data(device_id)
-            device.update(data)
-            remove_empty_platform_dicts(device)
+        for entity_id, entity in self.gw_entities.items():
+            data = self._get_entity_data(entity_id)
+            entity.update(data)
+            remove_empty_platform_dicts(entity)
 
-    def _get_device_data(self, dev_id: str) -> DeviceData:
-        """Helper-function for _all_device_data() and async_update().
+    def _get_entity_data(self, entity_id: str) -> GwEntityData:
+        """Helper-function for _all_entity_data() and async_update().
 
-        Provide device-data, based on Location ID (= dev_id), from APPLIANCES.
+        Provide entity-data, based on Location ID (= entity_id), from APPLIANCES.
         """
-        device = self.gw_devices[dev_id]
-        data = self._get_measurement_data(dev_id)
+        entity = self.gw_entities[entity_id]
+        data = self._get_measurement_data(entity_id)
 
         # Switching groups data
-        self._device_data_switching_group(device, data)
+        self._entity_switching_group(entity, data)
 
         # Skip obtaining data when not a thermostat
-        if device["dev_class"] != "thermostat":
+        if entity["dev_class"] != "thermostat":
             return data
 
         # Thermostat data (presets, temperatures etc)
-        self._device_data_climate(device, data)
+        self._climate_data(entity, data)
 
         return data
 
-    def _device_data_climate(self, device: DeviceData, data: DeviceData) -> None:
-        """Helper-function for _get_device_data().
+    def _climate_data(self, entity: GwEntityData, data: GwEntityData) -> None:
+        """Helper-function for _get_entity_data().
 
-        Determine climate-control device data.
+        Determine climate-control entity data.
         """
         # Presets
         data["preset_modes"] = None

plugwise/legacy/helper.py

@@ -29,8 +29,8 @@ from plugwise.constants import (
     ActuatorDataType,
     ActuatorType,
     ApplianceType,
-    DeviceData,
     GatewayData,
+    GwEntityData,
     SensorType,
     ThermoLoc,
 )
@@ -68,6 +68,7 @@ class SmileLegacyHelper(SmileCommon):
         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]] = {}
@@ -80,8 +81,7 @@ class SmileLegacyHelper(SmileCommon):
 
         self.gateway_id: str
         self.gw_data: GatewayData = {}
-        self.gw_devices: dict[str, DeviceData] = {}
-        self.loc_data: dict[str, ThermoLoc]
+        self.gw_entities: dict[str, GwEntityData] = {}
         self.smile_fw_version: Version | None
         self.smile_hw_version: str | None
         self.smile_mac_address: str | None
@@ -115,7 +115,7 @@ class SmileLegacyHelper(SmileCommon):
                 continue  # pragma: no cover
 
             appl.location = self._home_location
-            appl.dev_id = appliance.attrib["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
             if (
@@ -125,6 +125,7 @@ class SmileLegacyHelper(SmileCommon):
                 appl.pwclass = "heater_central_plug"
 
             appl.model = appl.pwclass.replace("_", " ").title()
+            appl.available = None
             appl.model_id = None
             appl.firmware = None
             appl.hardware = None
@@ -138,20 +139,20 @@ class SmileLegacyHelper(SmileCommon):
                 continue
 
             # Skip orphaned heater_central (Core Issue #104433)
-            if appl.pwclass == "heater_central" and appl.dev_id != self._heater_id:
+            if appl.pwclass == "heater_central" and appl.entity_id != self._heater_id:
                 continue  # pragma: no cover
 
-            self._create_gw_devices(appl)
+            self._create_gw_entities(appl)
 
         # Place the gateway and optional heater_central devices as 1st and 2nd
         for dev_class in ("heater_central", "gateway"):
-            for dev_id, device in dict(self.gw_devices).items():
-                if device["dev_class"] == dev_class:
-                    tmp_device = device
-                    self.gw_devices.pop(dev_id)
-                    cleared_dict = self.gw_devices
-                    add_to_front = {dev_id: tmp_device}
-                    self.gw_devices = {**add_to_front, **cleared_dict}
+            for entity_id, entity in dict(self.gw_entities).items():
+                if entity["dev_class"] == dev_class:
+                    tmp_entity = entity
+                    self.gw_entities.pop(entity_id)
+                    cleared_dict = self.gw_entities
+                    add_to_front = {entity_id: tmp_entity}
+                    self.gw_entities = {**add_to_front, **cleared_dict}
 
     def _all_locations(self) -> None:
         """Collect all locations."""
@@ -160,7 +161,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.loc_data[FAKE_LOC] = {"name": "Home"}
+            self._loc_data[FAKE_LOC] = {"name": "Home"}
             return
 
         for location in locations:
@@ -181,18 +182,18 @@ class SmileLegacyHelper(SmileCommon):
                 loc.name = "Home"
                 self._home_location = loc.loc_id
 
-            self.loc_data[loc.loc_id] = {"name": loc.name}
+            self._loc_data[loc.loc_id] = {"name": loc.name}
 
     def _create_legacy_gateway(self) -> None:
-        """Create the (missing) gateway devices for legacy Anna, P1 and Stretch.
+        """Create the (missing) gateway entities for legacy Anna, P1 and Stretch.
 
-        Use the home_location or FAKE_APPL as device id.
+        Use the home_location or FAKE_APPL as entity id.
         """
         self.gateway_id = self._home_location
         if self.smile_type == "power":
             self.gateway_id = FAKE_APPL
 
-        self.gw_devices[self.gateway_id] = {"dev_class": "gateway"}
+        self.gw_entities[self.gateway_id] = {"dev_class": "gateway"}
         self._count += 1
         for key, value in {
             "firmware": str(self.smile_fw_version),
@@ -205,34 +206,32 @@ class SmileLegacyHelper(SmileCommon):
         }.items():
             if value is not None:
                 gw_key = cast(ApplianceType, key)
-                self.gw_devices[self.gateway_id][gw_key] = value
+                self.gw_entities[self.gateway_id][gw_key] = value
                 self._count += 1
 
     def _appliance_info_finder(self, appliance: etree, appl: Munch) -> Munch:
-        """Collect device info (Smile/Stretch, Thermostats, OpenTherm/On-Off): firmware, model and vendor name."""
+        """Collect entity info (Smile/Stretch, Thermostats, OpenTherm/On-Off): firmware, model and vendor name."""
         match appl.pwclass:
-        # Collect thermostat device info
+        # Collect thermostat entity info
             case _ as dev_class if dev_class in THERMOSTAT_CLASSES:
                 return self._appl_thermostat_info(appl, appliance, self._modules)
-        # Collect heater_central device info
+        # Collect heater_central entity info
             case "heater_central":
                 return self._appl_heater_central_info(
                     appl, appliance, True, self._appliances, self._modules
                 )  # True means legacy device
         # Collect info from Stretches
             case _:
-                return self._energy_device_info_finder(appliance, appl)
+                return self._energy_entity_info_finder(appliance, appl)
 
-    def _energy_device_info_finder(self, appliance: etree, appl: Munch) -> Munch:
+    def _energy_entity_info_finder(self, appliance: etree, appl: Munch) -> Munch:
         """Helper-function for _appliance_info_finder().
 
-        Collect energy device info (Smartmeter, Circle, Stealth, etc.): firmware, model and vendor name.
+        Collect energy entity info (Smartmeter, Circle, Stealth, etc.): firmware, model and vendor name.
         """
         if self.smile_type in ("power", "stretch"):
             locator = "./services/electricity_point_meter"
-            mod_type = "electricity_point_meter"
-
-            module_data = self._get_module_data(appliance, locator, mod_type, self._modules, legacy=True)
+            module_data = self._get_module_data(appliance, locator, self._modules, legacy=True)
             appl.zigbee_mac = module_data["zigbee_mac_address"]
             # Filter appliance without zigbee_mac, it's an orphaned device
             if appl.zigbee_mac is None and self.smile_type != "power":
@@ -252,8 +251,9 @@ class SmileLegacyHelper(SmileCommon):
 
     def _p1_smartmeter_info_finder(self, appl: Munch) -> None:
         """Collect P1 DSMR Smartmeter info."""
-        loc_id = next(iter(self.loc_data.keys()))
-        appl.dev_id = loc_id
+        loc_id = next(iter(self._loc_data.keys()))
+        appl.available = None
+        appl.entity_id = loc_id
         appl.location = loc_id
         appl.mac = None
         appl.model = self.smile_model
@@ -262,41 +262,41 @@ class SmileLegacyHelper(SmileCommon):
         appl.pwclass = "smartmeter"
         appl.zigbee_mac = None
         location = self._locations.find(f'./location[@id="{loc_id}"]')
-        appl = self._energy_device_info_finder(location, appl)
+        appl = self._energy_entity_info_finder(location, appl)
 
-        self._create_gw_devices(appl)
+        self._create_gw_entities(appl)
 
-    def _get_measurement_data(self, dev_id: str) -> DeviceData:
-        """Helper-function for smile.py: _get_device_data().
+    def _get_measurement_data(self, entity_id: str) -> GwEntityData:
+        """Helper-function for smile.py: _get_entity_data().
 
-        Collect the appliance-data based on device id.
+        Collect the appliance-data based on entity_id.
         """
-        data: DeviceData = {"binary_sensors": {}, "sensors": {}, "switches": {}}
+        data: GwEntityData = {"binary_sensors": {}, "sensors": {}, "switches": {}}
         # Get P1 smartmeter data from LOCATIONS or MODULES
-        device = self.gw_devices[dev_id]
+        entity = self.gw_entities[entity_id]
         # !! DON'T CHANGE below two if-lines, will break stuff !!
         if self.smile_type == "power":
-            if device["dev_class"] == "smartmeter":
+            if entity["dev_class"] == "smartmeter":
                 data.update(self._power_data_from_modules())
 
             return data
 
         measurements = DEVICE_MEASUREMENTS
-        if self._is_thermostat and dev_id == self._heater_id:
+        if self._is_thermostat and entity_id == self._heater_id:
             measurements = HEATER_CENTRAL_MEASUREMENTS
 
         if (
-            appliance := self._appliances.find(f'./appliance[@id="{dev_id}"]')
+            appliance := self._appliances.find(f'./appliance[@id="{entity_id}"]')
         ) is not None:
             self._appliance_measurements(appliance, data, measurements)
             self._get_lock_state(appliance, data, self._stretch_v2)
 
             if appliance.find("type").text in ACTUATOR_CLASSES:
-                self._get_actuator_functionalities(appliance, device, data)
+                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
-        if self._is_thermostat and dev_id == self.gateway_id:
+        if self._is_thermostat and entity_id == self.gateway_id:
             outdoor_temperature = self._object_value(
                 self._home_location, "outdoor_temperature"
             )
@@ -310,12 +310,12 @@ class SmileLegacyHelper(SmileCommon):
 
         return data
 
-    def _power_data_from_modules(self) -> DeviceData:
-        """Helper-function for smile.py: _get_device_data().
+    def _power_data_from_modules(self) -> GwEntityData:
+        """Helper-function for smile.py: _get_entity_data().
 
         Collect the power-data from MODULES (P1 legacy only).
         """
-        direct_data: DeviceData = {"sensors": {}}
+        data: GwEntityData = {"sensors": {}}
         loc = Munch()
         mod_list: list[str] = ["interval_meter", "cumulative_meter", "point_meter"]
         t_string = "tariff_indicator"
@@ -326,15 +326,15 @@ 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(direct_data, loc, t_string, legacy=True)
+                    self._collect_power_values(data, loc, t_string, legacy=True)
 
-        self._count += len(direct_data["sensors"])
-        return direct_data
+        self._count += len(data["sensors"])
+        return data
 
     def _appliance_measurements(
         self,
         appliance: etree,
-        data: DeviceData,
+        data: GwEntityData,
         measurements: dict[str, DATA | UOM],
     ) -> None:
         """Helper-function for _get_measurement_data() - collect appliance measurement data."""
@@ -359,21 +359,20 @@ class SmileLegacyHelper(SmileCommon):
                     appl_i_loc.text, ENERGY_WATT_HOUR
                 )
 
-        self._count += len(data["binary_sensors"])
-        self._count += len(data["sensors"])
-        self._count += len(data["switches"])
-        # Don't count the above top-level dicts, only the remaining single items
-        self._count += len(data) - 3
+        self._count_data_items(data)
 
     def _get_actuator_functionalities(
-        self, xml: etree, device: DeviceData, data: DeviceData
+        self,
+        xml: etree,
+        entity: GwEntityData,
+        data: GwEntityData
     ) -> None:
         """Helper-function for _get_measurement_data()."""
         for item in ACTIVE_ACTUATORS:
             # Skip max_dhw_temperature, not initially valid,
             # skip thermostat for thermo_sensors
             if item == "max_dhw_temperature" or (
-                item == "thermostat" and device["dev_class"] == "thermo_sensor"
+                item == "thermostat" and entity["dev_class"] == "thermo_sensor"
             ):
                 continue
 
@@ -401,7 +400,7 @@ class SmileLegacyHelper(SmileCommon):
                 data[act_item] = temp_dict
 
     def _object_value(self, obj_id: str, measurement: str) -> float | int | None:
-        """Helper-function for smile.py: _get_device_data() and _device_data_anna().
+        """Helper-function for smile.py: _get_entity_data().
 
         Obtain the value/state for the given object from a location in DOMAIN_OBJECTS
         """
@@ -415,7 +414,7 @@ class SmileLegacyHelper(SmileCommon):
         return val
 
     def _preset(self) -> str | None:
-        """Helper-function for smile.py: device_data_climate().
+        """Helper-function for smile.py: _climate_data().
 
         Collect the active preset based on the active rule.
         """

plugwise/legacy/smile.py

@@ -19,8 +19,8 @@ from plugwise.constants import (
     OFF,
     REQUIRE_APPLIANCES,
     RULES,
-    DeviceData,
     GatewayData,
+    GwEntityData,
     PlugwiseData,
     ThermoLoc,
 )
@@ -44,11 +44,11 @@ class SmileLegacyAPI(SmileLegacyData):
         request: Callable[..., Awaitable[Any]],
         websession: aiohttp.ClientSession,
         _is_thermostat: bool,
+        _loc_data: dict[str, ThermoLoc],
         _on_off_device: bool,
         _opentherm_device: bool,
         _stretch_v2: bool,
         _target_smile: str,
-        loc_data: dict[str, ThermoLoc],
         smile_fw_version: Version | None,
         smile_hostname: str,
         smile_hw_version: str | None,
@@ -61,15 +61,13 @@ class SmileLegacyAPI(SmileLegacyData):
         username: str = DEFAULT_USERNAME,
     ) -> None:
         """Set the constructor for this class."""
-        SmileLegacyData.__init__(self)
-
         self._cooling_present = False
         self._is_thermostat = _is_thermostat
+        self._loc_data = _loc_data
         self._on_off_device = _on_off_device
         self._opentherm_device = _opentherm_device
         self._stretch_v2 = _stretch_v2
         self._target_smile = _target_smile
-        self.loc_data = loc_data
         self.request = request
         self.smile_fw_version = smile_fw_version
         self.smile_hostname = smile_hostname
@@ -79,10 +77,11 @@ class SmileLegacyAPI(SmileLegacyData):
         self.smile_name = smile_name
         self.smile_type = smile_type
         self.smile_zigbee_mac_address = smile_zigbee_mac_address
+        SmileLegacyData.__init__(self)
 
         self._previous_day_number: str = "0"
 
-    async def full_update_device(self) -> None:
+    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)
@@ -91,8 +90,8 @@ class SmileLegacyAPI(SmileLegacyData):
         if self.smile_type != "power":
             self._appliances = await self.request(APPLIANCES)
 
-    def get_all_devices(self) -> None:
-        """Determine the evices present from the obtained XML-data.
+    def get_all_gateway_entities(self) -> None:
+        """Collect the gateway entities 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.
@@ -102,10 +101,10 @@ class SmileLegacyAPI(SmileLegacyData):
 
         # Collect and add switching- and/or pump-group devices
         if group_data := self._get_group_switches():
-            self.gw_devices.update(group_data)
+            self.gw_entities.update(group_data)
 
-        # Collect the remaining data for all devices
-        self._all_device_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."""
@@ -119,9 +118,9 @@ class SmileLegacyAPI(SmileLegacyData):
                 "Performing daily full-update, reload the Plugwise integration when a single entity becomes unavailable."
             )
             self.gw_data: GatewayData = {}
-            self.gw_devices: dict[str, DeviceData] = {}
-            await self.full_update_device()
-            self.get_all_devices()
+            self.gw_entities: dict[str, GwEntityData] = {}
+            await self.full_xml_update()
+            self.get_all_gateway_entities()
         # Otherwise perform an incremental update
         else:
             self._domain_objects = await self.request(DOMAIN_OBJECTS)
@@ -131,10 +130,13 @@ class SmileLegacyAPI(SmileLegacyData):
                 case self._target_smile if self._target_smile in REQUIRE_APPLIANCES:
                     self._appliances = await self.request(APPLIANCES)
 
-            self._update_gw_devices()
+            self._update_gw_entities()
 
         self._previous_day_number = day_number
-        return PlugwiseData(self.gw_data, self.gw_devices)
+        return PlugwiseData(
+            devices=self.gw_entities,
+            gateway=self.gw_data,
+        )
 
 ########################################################################################################
 ###  API Set and HA Service-related Functions                                                        ###

plugwise/smile.py

@@ -22,8 +22,8 @@ from plugwise.constants import (
     NOTIFICATIONS,
     OFF,
     RULES,
-    DeviceData,
     GatewayData,
+    GwEntityData,
     PlugwiseData,
     ThermoLoc,
 )
@@ -53,11 +53,11 @@ class SmileAPI(SmileData):
         _elga: bool,
         _is_thermostat: bool,
         _last_active: dict[str, str | None],
+        _loc_data: dict[str, ThermoLoc],
         _on_off_device: bool,
         _opentherm_device: bool,
         _schedule_old_states: dict[str, dict[str, str]],
         gateway_id: str,
-        loc_data: dict[str, ThermoLoc],
         smile_fw_version: Version | None,
         smile_hostname: str | None,
         smile_hw_version: str | None,
@@ -70,17 +70,17 @@ class SmileAPI(SmileData):
         username: str = DEFAULT_USERNAME,
     ) -> None:
         """Set the constructor for this class."""
-        SmileData.__init__(self)
-
+        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._schedule_old_states = _schedule_old_states
         self.gateway_id = gateway_id
-        self.loc_data = loc_data
         self.request = request
         self.smile_fw_version = smile_fw_version
         self.smile_hostname = smile_hostname
@@ -90,22 +90,21 @@ class SmileAPI(SmileData):
         self.smile_model_id = smile_model_id
         self.smile_name = smile_name
         self.smile_type = smile_type
+        SmileData.__init__(self)
 
-        self._heater_id: str
-        self._cooling_enabled = False
 
-    async def full_update_device(self) -> None:
+    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._get_plugwise_notifications()
 
-    def get_all_devices(self) -> None:
-        """Determine the evices present from the obtained XML-data.
+    def get_all_gateway_entities(self) -> None:
+        """Collect the gateway entities 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.
+        Run this functions once to gather the initial configuration,
+        then regularly run async_update() to refresh the entity data.
         """
-        # Gather all the devices and their initial data
+        # Gather all the entities and their initial data
         self._all_appliances()
         if self._is_thermostat:
             if self.smile(ADAM):
@@ -117,20 +116,21 @@ class SmileAPI(SmileData):
 
         # Collect and add switching- and/or pump-group devices
         if group_data := self._get_group_switches():
-            self.gw_devices.update(group_data)
+            self.gw_entities.update(group_data)
 
-        # Collect the remaining data for all devices
-        self._all_device_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_devices: dict[str, DeviceData] = {}
+        self.gw_entities: dict[str, GwEntityData] = {}
+        self._zones: dict[str, GwEntityData] = {}
         try:
-            await self.full_update_device()
-            self.get_all_devices()
+            await self.full_xml_update()
+            self.get_all_gateway_entities()
             if "heater_id" in self.gw_data:
-                heat_cooler = self.gw_devices[self.gw_data["heater_id"]]
+                heat_cooler = self.gw_entities[self.gw_data["heater_id"]]
                 if (
                     "binary_sensors" in heat_cooler
                     and "cooling_enabled" in heat_cooler["binary_sensors"]
@@ -139,7 +139,10 @@ class SmileAPI(SmileData):
         except KeyError as err:
             raise DataMissingError("No Plugwise data received") from err
 
-        return PlugwiseData(self.gw_data, self.gw_devices)
+        return PlugwiseData(
+            devices=self.gw_entities,
+            gateway=self.gw_data,
+        )
 
 ########################################################################################################
 ###  API Set and HA Service-related Functions                                                        ###

plugwise/util.py

@@ -22,8 +22,8 @@ from plugwise.constants import (
     TEMP_CELSIUS,
     UOM,
     BinarySensorType,
-    DeviceData,
-    ModelData,
+    GwEntityData,
+    ModuleData,
     SensorType,
     SpecialType,
     SwitchType,
@@ -115,14 +115,14 @@ def check_model(name: str | None, vendor_name: str | None) -> str | None:
     if name is not None and "lumi.plug" in name:
         return "Aqara Smart Plug"
 
-    return name  # pragma: no cover
+    return None
 
 
 def common_match_cases(
     measurement: str,
     attrs: DATA | UOM,
     location: etree,
-    data: DeviceData,
+    data: GwEntityData,
 ) -> None:
     """Helper-function for common match-case execution."""
     value = location.text in ("on", "true")
@@ -173,15 +173,13 @@ def format_measure(measure: str, unit: str) -> float | int:
             result = float(f"{round(float_measure, 1):.1f}")
         elif abs(float_measure) < 10:
             result = float(f"{round(float_measure, 2):.2f}")
-        elif abs(float_measure) >= 10 and abs(float_measure) < 100:
+        elif abs(float_measure) >= 10:
             result = float(f"{round(float_measure, 1):.1f}")
-        elif abs(float_measure) >= 100:
-            result = int(round(float_measure))
 
     return result
 
 
-def get_vendor_name(module: etree, model_data: ModelData) -> ModelData:
+def get_vendor_name(module: etree, model_data: ModuleData) -> ModuleData:
     """Helper-function for _get_model_data()."""
     if (vendor_name := module.find("vendor_name").text) is not None:
         model_data["vendor_name"] = vendor_name
@@ -204,7 +202,7 @@ def power_data_local_format(
     return format_measure(val, attrs_uom)
 
 
-def remove_empty_platform_dicts(data: DeviceData) -> None:
+def remove_empty_platform_dicts(data: GwEntityData) -> None:
     """Helper-function for removing any empty platform dicts."""
     if not data["binary_sensors"]:
         data.pop("binary_sensors")

{plugwise-1.5.1a3.dist-info → plugwise-1.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: plugwise
-Version: 1.5.1a3
+Version: 1.6.0
 Summary: Plugwise Smile (Adam/Anna/P1) and Stretch module for Python 3.
 Home-page: https://github.com/plugwise/python-plugwise
 Author: Plugwise device owners