Adapt code

Author: bouwew

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.device_zones.items():
+    for device_id, device in coordinator.data.entities.items():
         if device["dev_class"] != "heater_central":
             continue
 

custom_components/plugwise/binary_sensor.py

@@ -112,7 +112,7 @@ async def async_setup_entry(
     @callback
     def _add_entities() -> None:
         """Add Entities."""
-        if not coordinator.new_device_zones:
+        if not coordinator.new_pw_entities:
             return
 
         # Upstream consts to HA
@@ -130,16 +130,16 @@ def _add_entities() -> None:
 
         # pw-beta alternative for debugging
         entities: list[PlugwiseBinarySensorEntity] = []
-        for device_id in coordinator.new_device_zones:
-            device = coordinator.data.device_zones[device_id]
-            if not (binary_sensors := device.get(BINARY_SENSORS)):
+        for pw_entity_id in coordinator.new_pw_entities:
+            pw_entity = coordinator.data.entities[pw_entity_id]
+            if not (binary_sensors := pw_entity.get(BINARY_SENSORS)):
                 continue
             for description in PLUGWISE_BINARY_SENSORS:
                 if description.key not in binary_sensors:
                     continue
-                entities.append(PlugwiseBinarySensorEntity(coordinator, device_id, description))
+                ha_entities.append(PlugwiseBinarySensorEntity(coordinator, pw_entity, description))
                 LOGGER.debug(
-                    "Add %s %s binary sensor", device["name"], description.translation_key
+                    "Add %s %s binary sensor", pw_entity["name"], description.translation_key
                 )
         async_add_entities(entities)
 
@@ -155,13 +155,13 @@ class PlugwiseBinarySensorEntity(PlugwiseEntity, BinarySensorEntity):
     def __init__(
         self,
         coordinator: PlugwiseDataUpdateCoordinator,
-        device_id: str,
+        pw_entity_id: str,
         description: PlugwiseBinarySensorEntityDescription,
     ) -> None:
         """Initialise the binary_sensor."""
-        super().__init__(coordinator, device_id)
+        super().__init__(coordinator, pw_entity_id)
         self.entity_description = description
-        self._attr_unique_id = f"{device_id}-{description.key}"
+        self._attr_unique_id = f"{pw_entity_id}-{description.key}"
         self._notification: dict[str, str] = {}  # pw-beta
 
     @property
@@ -174,12 +174,12 @@ def is_on(self) -> bool:
                     self.hass, message, "Plugwise Notification:", f"{DOMAIN}.{notify_id}"
                 )
 
-        return self.device_zone[BINARY_SENSORS][self.entity_description.key]
+        return self.pw_entity[BINARY_SENSORS][self.entity_description.key]
 
     @property
     def extra_state_attributes(self) -> Mapping[str, Any] | None:
         """Return entity specific state attributes."""
-        if self.entity_description.key != PLUGWISE_NOTIFICATION:  # Upstream const
+        if self.entity_dscription.key != PLUGWISE_NOTIFICATION:  # Upstream const
             return None
 
         # pw-beta adjustment with attrs is to only represent severities *with* content

custom_components/plugwise/button.py

@@ -36,10 +36,10 @@ async def async_setup_entry(
     # )
     # pw-beta alternative for debugging
     entities: list[PlugwiseButtonEntity] = []
-    for device_id, device in coordinator.data.device_zones.items():
-        if device_id == gateway[GATEWAY_ID] and REBOOT in gateway:
-            entities.append(PlugwiseButtonEntity(coordinator, device_id))
-            LOGGER.debug("Add %s reboot button", device["name"])
+    for pw_entity_id, pw_entity in coordinator.data.entities.items():
+        if pw_entity_id == gateway[GATEWAY_ID] and REBOOT in gateway:
+            entities.append(PlugwiseButtonEntity(coordinator, pw_entity_id))
+            LOGGER.debug("Add %s reboot button", pw_entity["name"])
     async_add_entities(entities)
 
 
@@ -52,12 +52,12 @@ class PlugwiseButtonEntity(PlugwiseEntity, ButtonEntity):
     def __init__(
         self,
         coordinator: PlugwiseDataUpdateCoordinator,
-        device_id: str,
+        pw_entity_id: str,
     ) -> None:
         """Initialize the button."""
-        super().__init__(coordinator, device_id)
+        super().__init__(coordinator, pw_entity_id)
         self._attr_translation_key = REBOOT
-        self._attr_unique_id = f"{device_id}-reboot"
+        self._attr_unique_id = f"{pw_entity_id}-reboot"
 
     @plugwise_command
     async def async_press(self) -> None:

custom_components/plugwise/climate.py

@@ -76,33 +76,33 @@ async def async_setup_entry(
     @callback
     def _add_entities() -> None:
         """Add Entities during init and runtime."""
-        if not coordinator.new_device_zones:
+        if not coordinator.new_pw_entities:
             return
 
-        climate_present = False
+        thermostat_zone_present = False
         entities: list[PlugwiseClimateEntity] = []
-        for devzone_id in coordinator.new_device_zones:
-            devzone = coordinator.data.device_zones[devzone_id]
-            if devzone[DEV_CLASS] == "climate":
-                climate_present = True
-                thermostat = coordinator.data.device_zones[devzone_id]
+        for pw_entity_id in coordinator.new_pw_entities:
+            pw_entity = coordinator.data.entities[pw_entity_id]
+            if pw_entity[DEV_CLASS] == "climate":
+                thermostat_zone_present = True
+                thermostat = coordinator.data.entities[pw_entity_id]
                 entities.append(
                     PlugwiseClimateEntity(
-                        coordinator, devzone_id, homekit_enabled
+                        coordinator, pw_entity_id, homekit_enabled
                     )  # pw-beta homekit emulation
                 )
                 LOGGER.debug("Add climate %s", thermostat[ATTR_NAME])
 
-        if not climate_present:
-            for device_id in coordinator.new_device_zones:
-                device = coordinator.data.device_zones[device_id]
-                if device[DEV_CLASS] in MASTER_THERMOSTATS:
+        if not thermostat_zone_present:
+            for pw_entity_id in coordinator.new_pw_entities:
+                pw_entity = coordinator.data.entities[pw_entity_id]
+                if pw_entity[DEV_CLASS] in MASTER_THERMOSTATS:
                     entities.append(
                         PlugwiseClimateEntity(
-                            coordinator, device_id, homekit_enabled
+                            coordinator, pw_entity_id, homekit_enabled
                         )  # pw-beta homekit emulation
                     )
-                    LOGGER.debug("Add climate %s", device[ATTR_NAME])
+                    LOGGER.debug("Add climate %s", pw_entity[ATTR_NAME])
 
         async_add_entities(entities)
 
@@ -125,28 +125,28 @@ class PlugwiseClimateEntity(PlugwiseEntity, ClimateEntity):
     def __init__(
         self,
         coordinator: PlugwiseDataUpdateCoordinator,
-        device_id: str,
+        pw_entity_id: str,
         homekit_enabled: bool,  # pw-beta homekit emulation
     ) -> None:
         """Set up the Plugwise API."""
-        super().__init__(coordinator, device_id)
+        super().__init__(coordinator, pw_entity_id)
 
         self._homekit_enabled = homekit_enabled  # pw-beta homekit emulation
 
-        self._location = device_id
-        if (location := self.device_zone.get(LOCATION)) is not None:
+        self._location = pw_entity_id
+        if (location := self.pw_entity.get(LOCATION)) is not None:
             self._location = location
 
         gateway_id: str = coordinator.data.gateway[GATEWAY_ID]
-        self.gateway_data = coordinator.data.device_zones[gateway_id]
+        self.gateway_data = coordinator.data.entities[gateway_id]
 
-        self._attr_max_temp = min(self.device_zone[THERMOSTAT][UPPER_BOUND], 35.0)
-        self._attr_min_temp = self.device_zone[THERMOSTAT][LOWER_BOUND]
+        self._attr_max_temp = min(self.pw_entity[THERMOSTAT][UPPER_BOUND], 35.0)
+        self._attr_min_temp = self.pw_entity[THERMOSTAT][LOWER_BOUND]
         # Ensure we don't drop below 0.1
         self._attr_target_temperature_step = max(
-            self.device_zone[THERMOSTAT][RESOLUTION], 0.1
+            self.pw_entity[THERMOSTAT][RESOLUTION], 0.1
         )
-        self._attr_unique_id = f"{device_id}-climate"
+        self._attr_unique_id = f"{pw_entity_id}-climate"
 
         # Determine supported features
         self.cdr_gateway = coordinator.data.gateway
@@ -162,7 +162,7 @@ def __init__(
             self._attr_supported_features |= (
                 ClimateEntityFeature.TURN_OFF | ClimateEntityFeature.TURN_ON
             )
-        if presets := self.device_zone["preset_modes"]:  # can be NONE
+        if presets := self.pw_entity["preset_modes"]:  # can be NONE
             self._attr_supported_features |= ClimateEntityFeature.PRESET_MODE
         self._attr_preset_modes = presets
 
@@ -183,7 +183,7 @@ def _previous_action_mode(self, coordinator: PlugwiseDataUpdateCoordinator) -> N
     @property
     def current_temperature(self) -> float:
         """Return the current temperature."""
-        return self.device_zone[SENSORS][ATTR_TEMPERATURE]
+        return self.pw_entity[SENSORS][ATTR_TEMPERATURE]
 
     @property
     def target_temperature(self) -> float:
@@ -192,29 +192,29 @@ def target_temperature(self) -> float:
         Connected to the HVACMode combination of AUTO-HEAT.
         """
 
-        return self.device_zone[THERMOSTAT][TARGET_TEMP]
+        return self.pw_entity[THERMOSTAT][TARGET_TEMP]
 
     @property
     def target_temperature_high(self) -> float:
         """Return the temperature we try to reach in case of cooling.
 
         Connected to the HVACMode combination of AUTO-HEAT_COOL.
         """
-        return self.device_zone[THERMOSTAT][TARGET_TEMP_HIGH]
+        return self.pw_entity[THERMOSTAT][TARGET_TEMP_HIGH]
 
     @property
     def target_temperature_low(self) -> float:
         """Return the heating temperature we try to reach in case of heating.
 
         Connected to the HVACMode combination AUTO-HEAT_COOL.
         """
-        return self.device_zone[THERMOSTAT][TARGET_TEMP_LOW]
+        return self.pw_entity[THERMOSTAT][TARGET_TEMP_LOW]
 
     @property
     def hvac_mode(self) -> HVACMode:
         """Return HVAC operation ie. auto, cool, heat, heat_cool, or off mode."""
         if (
-            mode := self.device_zone[CLIMATE_MODE]
+            mode := self.pw_entity[CLIMATE_MODE]
         ) is None or mode not in self.hvac_modes:  # pw-beta add to Core
             return HVACMode.HEAT  # pragma: no cover
         # pw-beta homekit emulation
@@ -233,7 +233,7 @@ def hvac_modes(self) -> list[HVACMode]:
         ):
             hvac_modes.append(HVACMode.OFF)
 
-        if AVAILABLE_SCHEDULES in self.device_zone:
+        if AVAILABLE_SCHEDULES in self.pw_entity:
             hvac_modes.append(HVACMode.AUTO)
 
         if self.cdr_gateway[COOLING_PRESENT]:
@@ -256,14 +256,14 @@ def hvac_action(self) -> HVACAction:  # pw-beta add to Core
         self._previous_action_mode(self.coordinator)
 
         # Adam provides the hvac_action for each thermostat
-        if (control_state := self.device_zone.get(CONTROL_STATE)) in (HVACAction.COOLING, HVACAction.HEATING, HVACAction.PREHEATING):
+        if (control_state := self.pw_entity.get(CONTROL_STATE)) in (HVACAction.COOLING, HVACAction.HEATING, HVACAction.PREHEATING):
             return cast(HVACAction, control_state)
         if control_state == HVACMode.OFF:
             return HVACAction.IDLE
 
         # Anna
         heater: str = self.coordinator.data.gateway["heater_id"]
-        heater_data = self.coordinator.data.device_zones[heater]
+        heater_data = self.coordinator.data.entities[heater]
         if heater_data[BINARY_SENSORS][HEATING_STATE]:
             return HVACAction.HEATING
         if heater_data[BINARY_SENSORS].get(COOLING_STATE, False):
@@ -274,7 +274,7 @@ def hvac_action(self) -> HVACAction:  # pw-beta add to Core
     @property
     def preset_mode(self) -> str | None:
         """Return the current preset mode."""
-        return self.device_zone[ACTIVE_PRESET]
+        return self.pw_entity[ACTIVE_PRESET]
 
     @plugwise_command
     async def async_set_temperature(self, **kwargs: Any) -> None:

custom_components/plugwise/coordinator.py

@@ -69,16 +69,16 @@ def __init__(
             username=self.config_entry.data[CONF_USERNAME],
             websession=async_get_clientsession(hass, verify_ssl=False),
         )
-        self._current_device_zones: set[str] = set()
-        self.new_device_zones: set[str] = set()
+        self._current_pw_entities: set[str] = set()
+        self.new_pw_entities: set[str] = set()
         self.update_interval = update_interval
 
     async def _connect(self) -> None:
         """Connect to the Plugwise Smile."""
         version = await self.api.connect()
         self._connected = isinstance(version, Version)
         if self._connected:
-            self.api.get_all_device_zones()
+            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
@@ -91,7 +91,7 @@ async def _connect(self) -> None:
 
     async def _async_update_data(self) -> PlugwiseData:
         """Fetch data from Plugwise."""
-        data = PlugwiseData(device_zones={}, gateway={})
+        data = PlugwiseData(entities={}, gateway={})
         try:
             if not self._connected:
                 await self._connect()
@@ -110,24 +110,24 @@ async def _async_update_data(self) -> PlugwiseData:
             raise ConfigEntryError("Device with unsupported firmware") from err
         else:
             LOGGER.debug(f"{self.api.smile_name} data: %s", data)
-            await self.async_add_remove_devices_zones(data, self.config_entry)
+            await self.async_add_remove_plugise_entities(data, self.config_entry)
 
         return data
 
-    async def async_add_remove_devices_zones(self, data: PlugwiseData, entry: ConfigEntry) -> None:
-        """Add new Plugwise devices, remove non-existing devices."""
-        # Check for new or removed devices
-        self.new_device_zones = set(data.device_zones) - self._current_device_zones
-        removed_device_zones = self._current_device_zones - set(data.device_zones)
-        self._current_device_zones = set(data.device_zones)
+    async def async_add_remove_plugwise_entities(self, data: PlugwiseData, entry: ConfigEntry) -> None:
+        """Add new Plugwise entities, remove non-existing entities."""
+        # Check for new or removed entities
+        self.new_pw_entities = set(data.entities) - self._current_pw_entities
+        removed_pw_entities = self._current_pw_entities - set(data.entities)
+        self._current_pw_entities = set(data.entities)
 
-        if removed_device_zones:
-            await self.async_remove_device_zones(data, entry)
+        if removed_pw_entities:
+            await self.async_remove_plugwise_entities(data, entry)
 
-    async def async_remove_device_zones(self, data: PlugwiseData, entry: ConfigEntry) -> None:
-        """Clean registries when removed devices or zones found."""
+    async def async_remove_plugwise_entities(self, data: PlugwiseData, entry: ConfigEntry) -> None:
+        """Clean registries when removed Plugwise entities."""
         device_reg = dr.async_get(self.hass)
-        device_zone_list = dr.async_entries_for_config_entry(
+        pw_entities_list = dr.async_entries_for_config_entry(
             device_reg, self.config_entry.entry_id
         )
 
@@ -137,7 +137,7 @@ async def async_remove_device_zones(self, data: PlugwiseData, entry: ConfigEntry
             via_device_id = gateway_device.id
 
         # Then remove the connected orphaned device(s)
-        for device_entry in device_zone_list:
+        for device_entry in pw_entities_list:
             for identifier in device_entry.identifiers:
                 if identifier[0] == DOMAIN:
                     if (

custom_components/plugwise/diagnostics.py

@@ -15,6 +15,6 @@ async def async_get_config_entry_diagnostics(
     """Return diagnostics for a config entry."""
     coordinator = entry.runtime_data
     return {
-        "devices": coordinator.data.device_zones,
+        "entities": coordinator.data.entities,
         "gateway": coordinator.data.gateway,
     }