Merge pull request #812 from plugwise/pw-v1.7.0

Link to plugwise v1.7.0 and adapt

Author: bouwew

CHANGELOG.md

@@ -2,11 +2,12 @@
 
 Versions from 0.40 and up
 
-## Ongoing
+## v0.56.0
 
 - Internal: Fixes for the CI process
 - Add test-coverage for persistent_notification-use in binary_sensor
 - Config_flow: restore showing provided user_input when an error occurs
+- Link to plugwise [v1.7.0](https://github.com/plugwise/python-plugwise/releases/tag/v1.7.0) and adapt
 
 ## v0.55.5
 

custom_components/plugwise/__init__.py

@@ -132,7 +132,7 @@ async def async_migrate_sensor_entities(
 
     # Migrate opentherm_outdoor_temperature
     # to opentherm_outdoor_air_temperature sensor
-    for device_id, device in coordinator.data.devices.items():
+    for device_id, device in coordinator.data.items():
         if device["dev_class"] != "heater_central":
             continue
 

custom_components/plugwise/binary_sensor.py

@@ -32,7 +32,6 @@
     FLAME_STATE,
     HEATING_STATE,
     LOGGER,  # pw-beta
-    NOTIFICATIONS,
     PLUGWISE_NOTIFICATION,
     SECONDARY_BOILER_STATE,
     SEVERITIES,
@@ -133,7 +132,7 @@ def _add_entities() -> None:
         # pw-beta alternative for debugging
         entities: list[PlugwiseBinarySensorEntity] = []
         for device_id in coordinator.new_devices:
-            device = coordinator.data.devices[device_id]
+            device = coordinator.data[device_id]
             if not (binary_sensors := device.get(BINARY_SENSORS)):
                 continue
             for description in PLUGWISE_BINARY_SENSORS:
@@ -188,7 +187,8 @@ def extra_state_attributes(self) -> Mapping[str, Any] | None:
         # not all severities including those without content as empty lists
         attrs: dict[str, list[str]] = {}  # pw-beta Re-evaluate against Core
         self._notification = {}  # pw-beta
-        if notify := self.coordinator.data.gateway[NOTIFICATIONS]:
+        gateway_id = self.coordinator.api.gateway_id
+        if notify := self.coordinator.data[gateway_id]["notifications"]:
             for notify_id, details in notify.items():  # pw-beta uses notify_id
                 for msg_type, msg in details.items():
                     msg_type = msg_type.lower()

custom_components/plugwise/button.py

@@ -9,7 +9,6 @@
 
 from . import PlugwiseConfigEntry
 from .const import (
-    GATEWAY_ID,
     LOGGER,  # pw-betea
     REBOOT,
 )
@@ -28,16 +27,15 @@ async def async_setup_entry(
     """Set up Plugwise buttons from a config entry."""
     coordinator = entry.runtime_data
 
-    gateway = coordinator.data.gateway
     # async_add_entities(
     #     PlugwiseButtonEntity(coordinator, device_id)
     #     for device_id in coordinator.data.devices
     #     if device_id == gateway[GATEWAY_ID] and REBOOT in gateway
     # )
     # pw-beta alternative for debugging
     entities: list[PlugwiseButtonEntity] = []
-    for device_id, device in coordinator.data.devices.items():
-        if device_id == gateway[GATEWAY_ID] and REBOOT in gateway:
+    for device_id, device in coordinator.data.items():
+        if device_id == coordinator.api.gateway_id and coordinator.api.reboot:
             entities.append(PlugwiseButtonEntity(coordinator, device_id))
             LOGGER.debug("Add %s reboot button", device["name"])
     async_add_entities(entities)

custom_components/plugwise/climate.py

@@ -33,10 +33,8 @@
     CLIMATE_MODE,
     CONF_HOMEKIT_EMULATION,  # pw-beta homekit emulation
     CONTROL_STATE,
-    COOLING_PRESENT,
     DEV_CLASS,
     DOMAIN,
-    GATEWAY_ID,
     LOCATION,
     LOGGER,
     LOWER_BOUND,
@@ -45,7 +43,6 @@
     RESOLUTION,
     SELECT_REGULATION_MODE,
     SENSORS,
-    SMILE_NAME,
     TARGET_TEMP,
     TARGET_TEMP_HIGH,
     TARGET_TEMP_LOW,
@@ -77,9 +74,9 @@ def _add_entities() -> None:
             return
 
         entities: list[PlugwiseClimateEntity] = []
-        gateway_name = coordinator.data.gateway[SMILE_NAME]
+        gateway_name = coordinator.api.smile_name
         for device_id in coordinator.new_devices:
-            device = coordinator.data.devices[device_id]
+            device = coordinator.data[device_id]
             if gateway_name == "Adam":
                 if device[DEV_CLASS] == "climate":
                     entities.append(
@@ -123,10 +120,8 @@ def __init__(
         """Set up the Plugwise API."""
         super().__init__(coordinator, device_id)
 
-        self._devices = coordinator.data.devices
-        self._gateway = coordinator.data.gateway
-        gateway_id: str = self._gateway[GATEWAY_ID]
-        self._gateway_data = self._devices[gateway_id]
+        gateway_id: str = coordinator.api.gateway_id
+        self._gateway_data = coordinator.data[gateway_id]
         self._homekit_enabled = homekit_enabled  # pw-beta homekit emulation
 
         self._location = device_id
@@ -144,8 +139,8 @@ def __init__(
         # Determine supported features
         self._attr_supported_features = ClimateEntityFeature.TARGET_TEMPERATURE
         if (
-            self._gateway[COOLING_PRESENT]
-            and self._gateway[SMILE_NAME] != "Adam"
+            self.coordinator.api.cooling_present
+            and coordinator.api.smile_name != "Adam"
         ):
             self._attr_supported_features = (
                 ClimateEntityFeature.TARGET_TEMPERATURE_RANGE
@@ -228,7 +223,7 @@ def hvac_modes(self) -> list[HVACMode]:
         if AVAILABLE_SCHEDULES in self.device:
             hvac_modes.append(HVACMode.AUTO)
 
-        if self._gateway[COOLING_PRESENT]:
+        if self.coordinator.api.cooling_present:
             if REGULATION_MODES in self._gateway_data:
                 if self._gateway_data[SELECT_REGULATION_MODE] == HVACAction.COOLING:
                     hvac_modes.append(HVACMode.COOL)

custom_components/plugwise/const.py

@@ -36,7 +36,6 @@
 DHW_STATE: Final = "dhw_state"
 FLAME_STATE: Final = "flame_state"
 HEATING_STATE: Final = "heating_state"
-NOTIFICATIONS: Final ="notifications"
 PLUGWISE_NOTIFICATION: Final = "plugwise_notification"
 SECONDARY_BOILER_STATE: Final = "secondary_boiler_state"
 
@@ -70,11 +69,9 @@
 # Entity constants
 AVAILABLE: Final = "available"
 FIRMWARE: Final = "firmware"
-GATEWAY_ID: Final = "gateway_id"
 HARDWARE: Final = "hardware"
 MODEL: Final = "model"
 MODEL_ID: Final = "model_id"
-SMILE_NAME: Final = "smile_name"
 VENDOR: Final = "vendor"
 
 # Number constants

custom_components/plugwise/coordinator.py

@@ -2,7 +2,7 @@
 
 from datetime import timedelta
 
-from plugwise import PlugwiseData, Smile
+from plugwise import GwEntityData, Smile
 from plugwise.exceptions import (
     ConnectionFailedError,
     InvalidAuthentication,
@@ -28,10 +28,10 @@
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 from packaging.version import Version
 
-from .const import DEFAULT_SCAN_INTERVAL, DOMAIN, GATEWAY_ID, LOGGER
+from .const import DEFAULT_SCAN_INTERVAL, DOMAIN, LOGGER
 
 
-class PlugwiseDataUpdateCoordinator(DataUpdateCoordinator[PlugwiseData]):
+class PlugwiseDataUpdateCoordinator(DataUpdateCoordinator[dict[str, GwEntityData]]):
     """Class to manage fetching Plugwise data from single endpoint."""
 
     _connected: bool = False
@@ -78,7 +78,6 @@ async def _connect(self) -> None:
         version = await self.api.connect()
         self._connected = isinstance(version, Version)
         if self._connected:
-            self.api.get_all_gateway_entities()
             self.update_interval = DEFAULT_SCAN_INTERVAL.get(
                 self.api.smile_type, timedelta(seconds=60)
             )  # pw-beta options scan-interval
@@ -89,9 +88,8 @@ async def _connect(self) -> None:
 
         LOGGER.debug("DUC update interval: %s", self.update_interval)  # pw-beta options
 
-    async def _async_update_data(self) -> PlugwiseData:
+    async def _async_update_data(self) -> dict[str, GwEntityData]:
         """Fetch data from Plugwise."""
-        data = PlugwiseData(devices={}, gateway={})
         try:
             if not self._connected:
                 await self._connect()
@@ -122,31 +120,34 @@ async def _async_update_data(self) -> PlugwiseData:
                 translation_domain=DOMAIN,
                 translation_key="unsupported_firmware",
             ) from err
-        else:
-            LOGGER.debug(f"{self.api.smile_name} data: %s", data)
-            await self.async_add_remove_devices(data, self.config_entry)
 
+        LOGGER.debug(f"{self.api.smile_name} data: %s", data)
+        await self._async_add_remove_devices(data, self.config_entry)
         return data
 
-    async def async_add_remove_devices(self, data: PlugwiseData, entry: ConfigEntry) -> None:
+    async def _async_add_remove_devices(
+        self, data: dict[str, GwEntityData], entry: ConfigEntry
+    ) -> None:
         """Add new Plugwise devices, remove non-existing devices."""
         # Check for new or removed devices
-        self.new_devices = set(data.devices) - self._current_devices
-        removed_devices = self._current_devices - set(data.devices)
-        self._current_devices = set(data.devices)
+        self.new_devices = set(data) - self._current_devices
+        removed_devices = self._current_devices - set(data)
+        self._current_devices = set(data)
 
         if removed_devices:
-            await self.async_remove_devices(data, entry)
+            await self._async_remove_devices(data, entry)
 
-    async def async_remove_devices(self, data: PlugwiseData, entry: ConfigEntry) -> None:
+    async def _async_remove_devices(
+        self, data: dict[str, GwEntityData], entry: ConfigEntry
+    ) -> None:
         """Clean registries when removed devices found."""
         device_reg = dr.async_get(self.hass)
         device_list = dr.async_entries_for_config_entry(
             device_reg, self.config_entry.entry_id
         )
 
         # First find the Plugwise via_device
-        gateway_device = device_reg.async_get_device({(DOMAIN, data.gateway[GATEWAY_ID])})
+        gateway_device = device_reg.async_get_device({(DOMAIN, self.api.gateway_id)})
         if gateway_device is not None:
             via_device_id = gateway_device.id
 
@@ -156,7 +157,7 @@ async def async_remove_devices(self, data: PlugwiseData, entry: ConfigEntry) ->
                 if identifier[0] == DOMAIN:
                     if (
                         device_entry.via_device_id == via_device_id
-                        and identifier[1] not in data.devices
+                        and identifier[1] not in data
                     ):
                         device_reg.async_update_device(
                             device_entry.id, remove_config_entry_id=entry.entry_id

custom_components/plugwise/diagnostics.py

@@ -14,7 +14,4 @@ async def async_get_config_entry_diagnostics(
 ) -> dict[str, Any]:
     """Return diagnostics for a config entry."""
     coordinator = entry.runtime_data
-    return {
-        "devices": coordinator.data.devices,
-        "gateway": coordinator.data.gateway,
-    }
+    return coordinator.data

custom_components/plugwise/entity.py

@@ -16,12 +16,10 @@
     AVAILABLE,
     DOMAIN,
     FIRMWARE,
-    GATEWAY_ID,
     HARDWARE,
     MAC_ADDRESS,
     MODEL,
     MODEL_ID,
-    SMILE_NAME,
     VENDOR,
     ZIGBEE_MAC_ADDRESS,
 )
@@ -48,7 +46,7 @@ def __init__(
         if entry := self.coordinator.config_entry:
             configuration_url = f"http://{entry.data[CONF_HOST]}"
 
-        data = coordinator.data.devices[device_id]
+        data = coordinator.data[device_id]
         connections = set()
         if mac := data.get(MAC_ADDRESS):
             connections.add((CONNECTION_NETWORK_MAC, mac))
@@ -62,18 +60,18 @@ def __init__(
             manufacturer=data.get(VENDOR),
             model=data.get(MODEL),
             model_id=data.get(MODEL_ID),
-            name=coordinator.data.gateway[SMILE_NAME],
+            name=coordinator.api.smile_name,
             sw_version=data.get(FIRMWARE),
             hw_version=data.get(HARDWARE),
         )
 
-        if device_id != coordinator.data.gateway[GATEWAY_ID]:
+        if device_id != coordinator.api.gateway_id:
             self._attr_device_info.update(
                 {
                     ATTR_NAME: data.get(ATTR_NAME),
                     ATTR_VIA_DEVICE: (
                         DOMAIN,
-                        str(self.coordinator.data.gateway[GATEWAY_ID]),
+                        str(self.coordinator.api.gateway_id),
                     ),
                 }
             )
@@ -84,12 +82,12 @@ def available(self) -> bool:
         return (
             # Upstream: Do not change the AVAILABLE line below: some Plugwise devices and zones
             # Upstream: do not provide their availability-status!
-            self._dev_id in self.coordinator.data.devices
+            self._dev_id in self.coordinator.data
             and (AVAILABLE not in self.device or self.device[AVAILABLE] is True)
             and super().available
         )
 
     @property
     def device(self) -> GwEntityData:
         """Return data for this device."""
-        return self.coordinator.data.devices[self._dev_id]
+        return self.coordinator.data[self._dev_id]

custom_components/plugwise/manifest.json

@@ -7,7 +7,7 @@
   "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["plugwise"],
-  "requirements": ["plugwise==1.6.4"],
-  "version": "0.55.5",
+  "requirements": ["plugwise==1.7.0"],
+  "version": "0.56.0",
   "zeroconf": ["_plugwise._tcp.local."]
 }