Diff to HTML by rtfpessoa

Files changed (15) hide show

/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/__init__.py +44 -91
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/binary_sensor.py +100 -70
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/climate.py +237 -117
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/config_flow.py +143 -185
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/const.py +101 -36
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/coordinator.py +167 -69
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/diagnostics.py +4 -15
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/entity.py +49 -38
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/manifest.json +7 -5
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/number.py +127 -78
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/select.py +122 -70
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/sensor.py +413 -33
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/strings.json +255 -153
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/switch.py +106 -28
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/util.py +179 -11

/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/__init__.py RENAMED Viewed

@@ -1,121 +1,68 @@
 """Plugwise platform for Home Assistant Core."""
-from __future__ import annotations
 from typing import Any
-import voluptuous as vol
-from homeassistant.components.number import DOMAIN as NUMBER_DOMAIN
-from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import Platform
-from homeassistant.core import HomeAssistant, ServiceCall, callback
 from homeassistant.helpers import device_registry as dr, entity_registry as er
-from plugwise.exceptions import PlugwiseError
-from .const import (
-    CONF_REFRESH_INTERVAL,  # pw-beta options
-    COORDINATOR,
-    DOMAIN,
-    LOGGER,
-    PLATFORMS_GATEWAY,
-    SERVICE_DELETE,
-    UNDO_UPDATE_LISTENER,
-)
-from .coordinator import PlugwiseDataUpdateCoordinator
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
-    """Set up Plugwise Smiles from a config entry."""
     await er.async_migrate_entries(hass, entry.entry_id, async_migrate_entity_entry)
-    cooldown = 1.5  # pw-beta frontend refresh-interval
-    if (
-        custom_refresh := entry.options.get(CONF_REFRESH_INTERVAL)
-    ) is not None:  # pragma: no cover
-        cooldown = custom_refresh
-    LOGGER.debug("DUC cooldown interval: %s", cooldown)
-    coordinator = PlugwiseDataUpdateCoordinator(
-        hass, entry, cooldown
-    )  # pw-beta - cooldown, update_interval as extra
     await coordinator.async_config_entry_first_refresh()
-    # Migrate a changed sensor unique_id
     migrate_sensor_entities(hass, coordinator)
-    undo_listener = entry.add_update_listener(_update_listener)  # pw-beta
-    hass.data.setdefault(DOMAIN, {})[entry.entry_id] = {
-        COORDINATOR: coordinator,  # pw-beta
-        UNDO_UPDATE_LISTENER: undo_listener,  # pw-beta
-    }
     device_registry = dr.async_get(hass)
     device_registry.async_get_or_create(
         config_entry_id=entry.entry_id,
         identifiers={(DOMAIN, str(coordinator.api.gateway_id))},
         manufacturer="Plugwise",
-        model=coordinator.api.smile_model,
-        name=coordinator.api.smile_name,
-        sw_version=coordinator.api.smile_version[0],
-    )
-    async def delete_notification(
-        call: ServiceCall,
-    ) -> None:  # pragma: no cover  # pw-beta: HA service - delete_notification
-        """Service: delete the Plugwise Notification."""
-        LOGGER.debug(
-            "Service delete PW Notification called for %s",
-            coordinator.api.smile_name,
-        )
-        try:
-            await coordinator.api.delete_notification()
-            LOGGER.debug("PW Notification deleted")
-        except PlugwiseError:
-            LOGGER.debug(
-                "Failed to delete the Plugwise Notification for %s",
-                coordinator.api.smile_name,
-            )
-    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS_GATEWAY)
-    for component in PLATFORMS_GATEWAY:  # pw-beta
-        if component == Platform.BINARY_SENSOR:
-            hass.services.async_register(
-                DOMAIN, SERVICE_DELETE, delete_notification, schema=vol.Schema({})
-            )
-    return True
-async def _update_listener(
-    hass: HomeAssistant, entry: ConfigEntry
-) -> None:  # pragma: no cover  # pw-beta
-    """Handle options update."""
-    await hass.config_entries.async_reload(entry.entry_id)
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
-    """Unload a config entry."""
-    if unload_ok := await hass.config_entries.async_unload_platforms(
-        entry, PLATFORMS_GATEWAY
-    ):
-        hass.data[DOMAIN].pop(entry.entry_id)
-    return unload_ok
 @callback
 def async_migrate_entity_entry(entry: er.RegistryEntry) -> dict[str, Any] | None:
     """Migrate Plugwise entity entries.
-    - Migrates unique ID from old relay switches to the new unique ID
     """
-    if entry.domain == SWITCH_DOMAIN and entry.unique_id.endswith("-"):
         return {"new_unique_id": entry.unique_id.replace("-plug", "-relay")}
-    if entry.domain == NUMBER_DOMAIN and entry.unique_id.endswith("-domestic_hot_water_setpoint"):
-        return {"new_unique_id": entry.unique_id.replace("-domestic_hot_water_setpoint", "-max_dhw_temperature")}
     # No migration needed
     return None
@@ -127,10 +74,10 @@
     """Migrate Sensors if needed."""
     ent_reg = er.async_get(hass)
-    # Migrate opentherm_outdoor_temperature to  # pw-beta add to Core
-    # opentherm_outdoor_air_temperature sensor
-    for device_id, device in coordinator.data.devices.items():
-        if device["dev_class"] != "heater_central":  # pw-beta add to Core
             continue
         old_unique_id = f"{device_id}-outdoor_temperature"
@@ -138,4 +85,10 @@
             Platform.SENSOR, DOMAIN, old_unique_id
         ):
             new_unique_id = f"{device_id}-outdoor_air_temperature"
             ent_reg.async_update_entity(entity_id, new_unique_id=new_unique_id)

 """Plugwise platform for Home Assistant Core."""
 from typing import Any
 from homeassistant.const import Platform
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import device_registry as dr, entity_registry as er
+from .const import DEV_CLASS, DOMAIN, LOGGER, PLATFORMS
+from .coordinator import PlugwiseConfigEntry, PlugwiseDataUpdateCoordinator
+async def async_setup_entry(hass: HomeAssistant, entry: PlugwiseConfigEntry) -> None:
+    """Set up Plugwise components from a config entry."""
     await er.async_migrate_entries(hass, entry.entry_id, async_migrate_entity_entry)
+    coordinator = PlugwiseDataUpdateCoordinator(hass, entry)
     await coordinator.async_config_entry_first_refresh()
     migrate_sensor_entities(hass, coordinator)
+    entry.runtime_data = coordinator
     device_registry = dr.async_get(hass)
     device_registry.async_get_or_create(
         config_entry_id=entry.entry_id,
         identifiers={(DOMAIN, str(coordinator.api.gateway_id))},
         manufacturer="Plugwise",
+        model=coordinator.api.smile.model,
+        model_id=coordinator.api.smile.model_id,
+        name=coordinator.api.smile.name,
+        sw_version=str(coordinator.api.smile.version),
+    )  # required for adding the entity-less P1 Gateway
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+async def async_unload_entry(hass: HomeAssistant, entry: PlugwiseConfigEntry) -> None:
+    """Unload the Plugwise components."""
+    await hass.config_entries.async_unload_platforms_or_raise(entry, PLATFORMS)
 @callback
 def async_migrate_entity_entry(entry: er.RegistryEntry) -> dict[str, Any] | None:
     """Migrate Plugwise entity entries.
+    Migrates old unique ID's from old binary_sensors and
+    switches to the new unique ID's.
     """
+    if entry.domain == Platform.BINARY_SENSOR and entry.unique_id.endswith(
+        "-slave_boiler_state"
+    ):
+        return {
+            "new_unique_id": entry.unique_id.replace(
+                "-slave_boiler_state", "-secondary_boiler_state"
+            )
+        }
+    if entry.domain == Platform.SENSOR and entry.unique_id.endswith(
+        "-relative_humidity"
+    ):
+        return {
+            "new_unique_id": entry.unique_id.replace("-relative_humidity", "-humidity")
+        }
+    if entry.domain == Platform.SWITCH and entry.unique_id.endswith("-plug"):
         return {"new_unique_id": entry.unique_id.replace("-plug", "-relay")}
     # No migration needed
     return None
     """Migrate Sensors if needed."""
     ent_reg = er.async_get(hass)
+    # Migrating opentherm_outdoor_temperature
+    # to opentherm_outdoor_air_temperature sensor
+    for device_id, device in coordinator.data.items():
+        if device[DEV_CLASS] != "heater_central":
             continue
         old_unique_id = f"{device_id}-outdoor_temperature"
             Platform.SENSOR, DOMAIN, old_unique_id
         ):
             new_unique_id = f"{device_id}-outdoor_air_temperature"
+            LOGGER.debug(
+                "Migrating entity %s from old unique ID '%s' to new unique ID '%s'",
+                entity_id,
+                old_unique_id,
+                new_unique_id,
+            )
             ent_reg.async_update_entity(entity_id, new_unique_id=new_unique_id)

/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/binary_sensor.py RENAMED Viewed

@@ -1,54 +1,109 @@
 """Plugwise Binary Sensor component for Home Assistant."""
-from __future__ import annotations
 from collections.abc import Mapping
-from typing import Any
-from homeassistant.components.binary_sensor import BinarySensorEntity
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-from .const import (
-    COORDINATOR,  # pw-beta
-    DOMAIN,
-    LOGGER,
-    SEVERITIES,
 )
-from .coordinator import PlugwiseDataUpdateCoordinator
 from .entity import PlugwiseEntity
-from .models import PW_BINARY_SENSOR_TYPES, PlugwiseBinarySensorEntityDescription
 PARALLEL_UPDATES = 0
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: ConfigEntry,
-    async_add_entities: AddEntitiesCallback,
 ) -> None:
-    """Set up Plugwise binary sensor based on config_entry."""
-    coordinator: PlugwiseDataUpdateCoordinator = hass.data[DOMAIN][
-        config_entry.entry_id
-    ][COORDINATOR]
-    entities: list[PlugwiseBinarySensorEntity] = []
-    for device_id, device in coordinator.data.devices.items():
-        if not (binary_sensors := device.get("binary_sensors")):
-            continue
-        for description in PW_BINARY_SENSOR_TYPES:
-            if description.key not in binary_sensors:
-                continue
-            entities.append(
-                PlugwiseBinarySensorEntity(
-                    coordinator,
-                    device_id,
-                    description,
-                )
-            )
-            LOGGER.debug("Add %s binary sensor", description.key)
-    async_add_entities(entities)
 class PlugwiseBinarySensorEntity(PlugwiseEntity, BinarySensorEntity):
@@ -66,53 +121,28 @@
         super().__init__(coordinator, device_id)
         self.entity_description = description
         self._attr_unique_id = f"{device_id}-{description.key}"
-        self._notification: dict[str, str] = {}  # pw-beta
     @property
     def is_on(self) -> bool:
         """Return true if the binary sensor is on."""
-        # pw-beta: show Plugwise notifications as HA persistent notifications
-        if self._notification:
-            for notify_id, message in self._notification.items():
-                self.hass.components.persistent_notification.async_create(
-                    message, "Plugwise Notification:", f"{DOMAIN}.{notify_id}"
-                )
-        # return self.device["binary_sensors"][self.entity_description.key]  # type: ignore [literal-required]
-        return self.entity_description.value_fn(self.device["binary_sensors"])
-    @property
-    def icon(self) -> str | None:
-        """Return the icon to use in the frontend, if any."""
-        if (icon_off := self.entity_description.icon_off) and self.is_on is False:
-            return icon_off
-        return self.entity_description.icon
     @property
     def extra_state_attributes(self) -> Mapping[str, Any] | None:
         """Return entity specific state attributes."""
         if self.entity_description.key != "plugwise_notification":
             return None
-        # pw-beta adjustment with attrs is to only represent severities *with* content
-        # 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"]:
-            for notify_id, details in notify.items():  # pw-beta uses notify_id
                 for msg_type, msg in details.items():
                     msg_type = msg_type.lower()
                     if msg_type not in SEVERITIES:
-                        msg_type = "other"  # pragma: no cover
-                    if (
-                        f"{msg_type}_msg" not in attrs
-                    ):  # pw-beta Re-evaluate against Core
-                        attrs[f"{msg_type}_msg"] = []
                     attrs[f"{msg_type}_msg"].append(msg)
-                    self._notification[
-                        notify_id
-                    ] = f"{msg_type.title()}: {msg}"  # pw-beta
         return attrs

 """Plugwise Binary Sensor component for Home Assistant."""
 from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Any, override
+from plugwise.constants import BinarySensorType
+from homeassistant.components.binary_sensor import (
+    BinarySensorDeviceClass,
+    BinarySensorEntity,
+    BinarySensorEntityDescription,
 )
+from homeassistant.const import EntityCategory
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from .coordinator import PlugwiseConfigEntry, PlugwiseDataUpdateCoordinator
 from .entity import PlugwiseEntity
+SEVERITIES = ["other", "info", "warning", "error"]
+# Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
+@dataclass(frozen=True)
+class PlugwiseBinarySensorEntityDescription(BinarySensorEntityDescription):
+    """Describes a Plugwise binary sensor entity."""
+    key: BinarySensorType
+BINARY_SENSORS: tuple[PlugwiseBinarySensorEntityDescription, ...] = (
+    PlugwiseBinarySensorEntityDescription(
+        key="low_battery",
+        device_class=BinarySensorDeviceClass.BATTERY,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    PlugwiseBinarySensorEntityDescription(
+        key="compressor_state",
+        translation_key="compressor_state",
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    PlugwiseBinarySensorEntityDescription(
+        key="cooling_enabled",
+        translation_key="cooling_enabled",
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    PlugwiseBinarySensorEntityDescription(
+        key="dhw_state",
+        translation_key="dhw_state",
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    PlugwiseBinarySensorEntityDescription(
+        key="flame_state",
+        translation_key="flame_state",
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    PlugwiseBinarySensorEntityDescription(
+        key="heating_state",
+        translation_key="heating_state",
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    PlugwiseBinarySensorEntityDescription(
+        key="cooling_state",
+        translation_key="cooling_state",
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    PlugwiseBinarySensorEntityDescription(
+        key="secondary_boiler_state",
+        translation_key="secondary_boiler_state",
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    PlugwiseBinarySensorEntityDescription(
+        key="plugwise_notification",
+        translation_key="plugwise_notification",
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+)
 async def async_setup_entry(
     hass: HomeAssistant,
+    entry: PlugwiseConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
+    """Set up the Smile binary_sensors from a config entry."""
+    coordinator = entry.runtime_data
+    @callback
+    def _add_entities() -> None:
+        """Add Entities."""
+        if not coordinator.new_devices:
+            return
+        async_add_entities(
+            PlugwiseBinarySensorEntity(coordinator, device_id, description)
+            for device_id in coordinator.new_devices
+            if (binary_sensors := coordinator.data[device_id].get("binary_sensors"))
+            for description in BINARY_SENSORS
+            if description.key in binary_sensors
+        )
+    _add_entities()
+    entry.async_on_unload(coordinator.async_add_listener(_add_entities))
 class PlugwiseBinarySensorEntity(PlugwiseEntity, BinarySensorEntity):
         super().__init__(coordinator, device_id)
         self.entity_description = description
         self._attr_unique_id = f"{device_id}-{description.key}"
     @property
+    @override
     def is_on(self) -> bool:
         """Return true if the binary sensor is on."""
+        return self.device["binary_sensors"][self.entity_description.key]
     @property
+    @override
     def extra_state_attributes(self) -> Mapping[str, Any] | None:
         """Return entity specific state attributes."""
         if self.entity_description.key != "plugwise_notification":
             return None
+        attrs: dict[str, list[str]] = {f"{severity}_msg": [] for severity in SEVERITIES}
+        gateway_id = self.coordinator.api.gateway_id
+        if notify := self.coordinator.data[gateway_id]["notifications"]:
+            for details in notify.values():
                 for msg_type, msg in details.items():
                     msg_type = msg_type.lower()
                     if msg_type not in SEVERITIES:
+                        msg_type = "other"
                     attrs[f"{msg_type}_msg"].append(msg)
         return attrs

/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/climate.py RENAMED Viewed

@@ -1,7 +1,7 @@
 """Plugwise Climate component for Home Assistant."""
-from __future__ import annotations
-from typing import Any
 from homeassistant.components.climate import (
     ATTR_HVAC_MODE,
@@ -12,102 +12,164 @@
     HVACAction,
     HVACMode,
 )
-from homeassistant.components.climate.const import (
-    PRESET_AWAY,  # pw-beta homekit emulation
-    PRESET_HOME,  # pw-beta homekit emulation
-)
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
-from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-from .const import (
-    CONF_HOMEKIT_EMULATION,  # pw-beta homekit emulation
-    COORDINATOR,  # pw-beta
-    DOMAIN,
-    MASTER_THERMOSTATS,
-)
-from .coordinator import PlugwiseDataUpdateCoordinator
 from .entity import PlugwiseEntity
 from .util import plugwise_command
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: ConfigEntry,
-    async_add_entities: AddEntitiesCallback,
 ) -> None:
     """Set up the Smile Thermostats from a config entry."""
-    coordinator: PlugwiseDataUpdateCoordinator = hass.data[DOMAIN][
-        config_entry.entry_id
-    ][COORDINATOR]
-    homekit_enabled: bool = config_entry.options.get(
-        CONF_HOMEKIT_EMULATION, False
-    )  # pw-beta homekit emulation
-    async_add_entities(
-        PlugwiseClimateEntity(
-            coordinator, device_id, homekit_enabled
-        )  # pw-beta homekit emulation
-        for device_id, device in coordinator.data.devices.items()
-        if device["dev_class"] in MASTER_THERMOSTATS
-    )
-class PlugwiseClimateEntity(PlugwiseEntity, ClimateEntity):
-    """Representation of an Plugwise thermostat."""
-    _attr_has_entity_name = True
-    _attr_temperature_unit = UnitOfTemperature.CELSIUS
     _attr_translation_key = DOMAIN
     def __init__(
         self,
         coordinator: PlugwiseDataUpdateCoordinator,
         device_id: str,
-        homekit_enabled: bool,  # pw-beta homekit emulation
     ) -> None:
         """Set up the Plugwise API."""
         super().__init__(coordinator, device_id)
-        self._homekit_enabled = homekit_enabled  # pw-beta homekit emulation
-        self._homekit_mode: str | None = None  # pw-beta homekit emulation
-        self._attr_unique_id = f"{device_id}-climate"
         # Determine supported features
         self._attr_supported_features = ClimateEntityFeature.TARGET_TEMPERATURE
-        if self.coordinator.data.gateway["cooling_present"]:
             self._attr_supported_features = (
                 ClimateEntityFeature.TARGET_TEMPERATURE_RANGE
             )
         if presets := self.device.get("preset_modes"):
             self._attr_supported_features |= ClimateEntityFeature.PRESET_MODE
             self._attr_preset_modes = presets
-        # Determine hvac modes and current hvac mode
-        self._attr_hvac_modes = [HVACMode.HEAT]
-        if self.coordinator.data.gateway["cooling_present"]:
-            self._attr_hvac_modes = [HVACMode.HEAT_COOL]
-        if self.device["available_schedules"] != ["None"]:
-            self._attr_hvac_modes.append(HVACMode.AUTO)
-        if self._homekit_enabled:  # pw-beta homekit emulation
-            self._attr_hvac_modes.append(HVACMode.OFF)  # pragma: no cover
         self._attr_min_temp = self.device["thermostat"]["lower_bound"]
-        self._attr_max_temp = self.device["thermostat"]["upper_bound"]
-        # Fix unpractical resolution provided by Plugwise
         self._attr_target_temperature_step = max(
-            self.device["thermostat"]["resolution"], 0.5
         )
     @property
-    def current_temperature(self) -> float:
         """Return the current temperature."""
-        return self.device["sensors"]["temperature"]
     @property
-    def target_temperature(self) -> float:
         """Return the temperature we try to reach.
         Connected to the HVACMode combination of AUTO-HEAT.
@@ -116,7 +178,8 @@
         return self.device["thermostat"]["setpoint"]
     @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.
@@ -124,7 +187,8 @@
         return self.device["thermostat"]["setpoint_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.
@@ -132,54 +196,68 @@
         return self.device["thermostat"]["setpoint_low"]
     @property
     def hvac_mode(self) -> HVACMode:
-        """Return HVAC operation ie. auto, heat, heat_cool, or off mode."""
         if (
-            mode := self.device["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
-        if self._homekit_enabled and self._homekit_mode == HVACMode.OFF:
-            mode = HVACMode.OFF  # pragma: no cover
         return HVACMode(mode)
     @property
-    def hvac_action(self) -> HVACAction:  # pw-beta add to Core
         """Return the current running hvac operation if supported."""
-        # When control_state is present, prefer this data
-        if (control_state := self.device.get("control_state")) == "cooling":
-            return HVACAction.COOLING
-        # Support preheating state as heating,
-        # until preheating is added as a separate state
-        if control_state in ["heating", "preheating"]:
-            return HVACAction.HEATING
-        if control_state == "off":
-            return HVACAction.IDLE
-        heater: str | None = self.coordinator.data.gateway["heater_id"]
-        if heater is not None:
-            heater_data = self.coordinator.data.devices[heater]
-            if heater_data["binary_sensors"]["heating_state"]:
-                return HVACAction.HEATING
-            if heater_data["binary_sensors"].get("cooling_state", False):
-                return HVACAction.COOLING
         return HVACAction.IDLE
     @property
     def preset_mode(self) -> str | None:
         """Return the current preset mode."""
-        return self.device["active_preset"]
     @plugwise_command
     async def async_set_temperature(self, **kwargs: Any) -> None:
         """Set new target temperature."""
-        if ATTR_HVAC_MODE in kwargs:  # pw-beta add to Core
-            await self.async_set_hvac_mode(
-                kwargs[ATTR_HVAC_MODE]
-            )  # pw-beta add to Core
         data: dict[str, Any] = {}
         if ATTR_TEMPERATURE in kwargs:
             data["setpoint"] = kwargs.get(ATTR_TEMPERATURE)
@@ -188,38 +266,80 @@
         if ATTR_TARGET_TEMP_LOW in kwargs:
             data["setpoint_low"] = kwargs.get(ATTR_TARGET_TEMP_LOW)
-        for temperature in data.values():
-            if temperature is None or not (
-                self._attr_min_temp <= temperature <= self._attr_max_temp
-            ):
-                raise ValueError("Invalid temperature change requested")
-        await self.coordinator.api.set_temperature(self.device["location"], data)
     @plugwise_command
     async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
-        """Set the hvac mode."""
-        if hvac_mode not in self.hvac_modes:
-            raise HomeAssistantError("Unsupported hvac_mode")
-        await self.coordinator.api.set_schedule_state(
-            self.device["location"],
-            self.device["last_used"],
-            "on" if hvac_mode == HVACMode.AUTO else "off",
         )
-        # pw-beta: feature request - mimic HomeKit behavior
-        self._homekit_mode = hvac_mode
-        if self._homekit_enabled:
-            if self._homekit_mode == HVACMode.OFF:  # pragma: no cover
-                await self.async_set_preset_mode(PRESET_AWAY)  # pragma: no cover
-            if (
-                self._homekit_mode in [HVACMode.HEAT, HVACMode.COOL, HVACMode.HEAT_COOL]
-                and self.device["active_preset"] == PRESET_AWAY
-            ):  # pragma: no cover
-                await self.async_set_preset_mode(PRESET_HOME)  # pragma: no cover
     @plugwise_command
     async def async_set_preset_mode(self, preset_mode: str) -> None:
         """Set the preset mode."""
-        await self.coordinator.api.set_preset(self.device["location"], preset_mode)

 """Plugwise Climate component for Home Assistant."""
+from dataclasses import asdict, dataclass
+from typing import Any, override
 from homeassistant.components.climate import (
     ATTR_HVAC_MODE,
     HVACAction,
     HVACMode,
 )
+from homeassistant.const import ATTR_TEMPERATURE, STATE_OFF, STATE_ON, UnitOfTemperature
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.restore_state import ExtraStoredData, RestoreEntity
+from .const import DOMAIN, MASTER_THERMOSTATS
+from .coordinator import PlugwiseConfigEntry, PlugwiseDataUpdateCoordinator
 from .entity import PlugwiseEntity
 from .util import plugwise_command
+ERROR_NO_SCHEDULE = "set_schedule_first"
+PARALLEL_UPDATES = 0
+def _check_for_schedule(active: bool, last_active: str) -> None:
+    """Raise a HAError when no thermostat schedule has been set."""
+    # last_active can be stored as None from before the plugwise v1.14.3 bump
+    if not active and last_active == STATE_OFF:
+        raise HomeAssistantError(
+            translation_domain=DOMAIN,
+            translation_key=ERROR_NO_SCHEDULE,
+        )
+@dataclass
+class PlugwiseClimateExtraStoredData(ExtraStoredData):
+    """Object to hold extra stored data."""
+    last_active_schedule: str | None
+    previous_action_mode: str | None
+    @override
+    def as_dict(self) -> dict[str, Any]:
+        """Return a dict representation of the text data."""
+        return asdict(self)
+    @classmethod
+    def from_dict(cls, restored: dict[str, Any]) -> PlugwiseClimateExtraStoredData:
+        """Initialize a stored data object from a dict."""
+        return cls(
+            last_active_schedule=restored.get("last_active_schedule"),
+            previous_action_mode=restored.get("previous_action_mode"),
+        )
 async def async_setup_entry(
     hass: HomeAssistant,
+    entry: PlugwiseConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the Smile Thermostats from a config entry."""
+    coordinator = entry.runtime_data
+    @callback
+    def _add_entities() -> None:
+        """Add Entities."""
+        if not coordinator.new_devices:
+            return
+        if coordinator.api.smile.name == "Adam":
+            async_add_entities(
+                PlugwiseClimateEntity(coordinator, device_id)
+                for device_id in coordinator.new_devices
+                if coordinator.data[device_id]["dev_class"] == "climate"
+            )
+        else:
+            async_add_entities(
+                PlugwiseClimateEntity(coordinator, device_id)
+                for device_id in coordinator.new_devices
+                if coordinator.data[device_id]["dev_class"] in MASTER_THERMOSTATS
+            )
+    _add_entities()
+    entry.async_on_unload(coordinator.async_add_listener(_add_entities))
+class PlugwiseClimateEntity(PlugwiseEntity, ClimateEntity, RestoreEntity):
+    """Representation of a Plugwise thermostat."""
+    _attr_name = None
+    _attr_native_temperature_unit = UnitOfTemperature.CELSIUS
     _attr_translation_key = DOMAIN
     def __init__(
         self,
         coordinator: PlugwiseDataUpdateCoordinator,
         device_id: str,
     ) -> None:
         """Set up the Plugwise API."""
         super().__init__(coordinator, device_id)
+        # Legacy format, kept as migrating existing unique IDs is not worth the risk
+        self._attr_unique_id = f"{device_id}-climate"  # pylint: disable=home-assistant-entity-unique-id-redundant-platform
+        self._api = coordinator.api
+        gateway_id: str = self._api.gateway_id
+        self._gateway_data = coordinator.data[gateway_id]
+        self._last_active_schedule = STATE_OFF
+        self._location = device_id
+        if (location := self.device.get("location")) is not None:
+            self._location = location
+        self._previous_action_mode = HVACAction.HEATING.value
         # Determine supported features
         self._attr_supported_features = ClimateEntityFeature.TARGET_TEMPERATURE
+        if self._api.cooling_present and self._api.smile.name != "Adam":
             self._attr_supported_features = (
                 ClimateEntityFeature.TARGET_TEMPERATURE_RANGE
             )
+        if HVACMode.OFF in self.hvac_modes:
+            self._attr_supported_features |= (
+                ClimateEntityFeature.TURN_OFF | ClimateEntityFeature.TURN_ON
+            )
         if presets := self.device.get("preset_modes"):
             self._attr_supported_features |= ClimateEntityFeature.PRESET_MODE
             self._attr_preset_modes = presets
         self._attr_min_temp = self.device["thermostat"]["lower_bound"]
+        self._attr_max_temp = min(self.device["thermostat"]["upper_bound"], 35.0)
+        # Ensure we don't drop below 0.1
         self._attr_target_temperature_step = max(
+            self.device["thermostat"]["resolution"], 0.1
+        )
+    @override
+    async def async_added_to_hass(self) -> None:
+        """Run when entity about to be added."""
+        await super().async_added_to_hass()
+        if extra_data := await self.async_get_last_extra_data():
+            plugwise_extra_data = PlugwiseClimateExtraStoredData.from_dict(
+                extra_data.as_dict()
+            )
+            self._last_active_schedule = (
+                plugwise_extra_data.last_active_schedule or STATE_OFF
+            )
+            self._previous_action_mode = (
+                plugwise_extra_data.previous_action_mode or HVACAction.HEATING.value
+            )
+    @property
+    @override
+    def extra_restore_state_data(self) -> PlugwiseClimateExtraStoredData:
+        """Return text specific state data to be restored."""
+        return PlugwiseClimateExtraStoredData(
+            last_active_schedule=self._last_active_schedule,
+            previous_action_mode=self._previous_action_mode,
         )
     @property
+    @override
+    def native_current_temperature(self) -> float | None:
         """Return the current temperature."""
+        return self.device["sensors"].get("temperature")
     @property
+    @override
+    def native_target_temperature(self) -> float:
         """Return the temperature we try to reach.
         Connected to the HVACMode combination of AUTO-HEAT.
         return self.device["thermostat"]["setpoint"]
     @property
+    @override
+    def native_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["thermostat"]["setpoint_high"]
     @property
+    @override
+    def native_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["thermostat"]["setpoint_low"]
     @property
+    @override
     def hvac_mode(self) -> HVACMode:
+        """Return HVAC operation ie. auto, cool, heat, heat_cool, or off mode."""
         if (
+            mode := self.device.get("climate_mode")
+        ) is None or mode not in self.hvac_modes:
+            return HVACMode.HEAT
         return HVACMode(mode)
     @property
+    @override
+    def hvac_modes(self) -> list[HVACMode]:
+        """Return a list of available HVACModes."""
+        hvac_modes: list[HVACMode] = []
+        if "regulation_modes" in self._gateway_data:
+            hvac_modes.append(HVACMode.OFF)
+        if self.device["available_schedules"] != [STATE_OFF]:
+            hvac_modes.append(HVACMode.AUTO)
+        if self._api.cooling_present:
+            if "regulation_modes" in self._gateway_data:
+                if "heating" in self._gateway_data["regulation_modes"]:
+                    hvac_modes.append(HVACMode.HEAT)
+                if "cooling" in self._gateway_data["regulation_modes"]:
+                    hvac_modes.append(HVACMode.COOL)
+            else:
+                hvac_modes.append(HVACMode.HEAT_COOL)
+        else:
+            hvac_modes.append(HVACMode.HEAT)
+        return hvac_modes
+    @property
+    @override
+    def hvac_action(self) -> HVACAction:
         """Return the current running hvac operation if supported."""
+        # Keep track of the previous hvac_action mode.
+        # When no cooling available, _previous_action_mode is always heating
+        if (
+            "regulation_modes" in self._gateway_data
+            and HVACAction.COOLING.value in self._gateway_data["regulation_modes"]
+        ):
+            mode = self._gateway_data["select_regulation_mode"]
+            if mode in (HVACAction.COOLING.value, HVACAction.HEATING.value):
+                self._previous_action_mode = mode
+        if (action := self.device.get("control_state")) is not None:
+            return HVACAction(action)
         return HVACAction.IDLE
     @property
+    @override
     def preset_mode(self) -> str | None:
         """Return the current preset mode."""
+        return self.device.get("active_preset")
     @plugwise_command
+    @override
     async def async_set_temperature(self, **kwargs: Any) -> None:
         """Set new target temperature."""
         data: dict[str, Any] = {}
         if ATTR_TEMPERATURE in kwargs:
             data["setpoint"] = kwargs.get(ATTR_TEMPERATURE)
         if ATTR_TARGET_TEMP_LOW in kwargs:
             data["setpoint_low"] = kwargs.get(ATTR_TARGET_TEMP_LOW)
+        if mode := kwargs.get(ATTR_HVAC_MODE):
+            await self.async_set_hvac_mode(mode)
+        await self._api.set_temperature(self._location, data)
+    def _regulation_mode_for_hvac(self, hvac_mode: HVACMode) -> str:
+        """Return the API regulation value for a manual HVAC mode, or None.
+        The function inputs are limited to the HVACModes HEAT and COOL.
+        """
+        if hvac_mode == HVACMode.HEAT:
+            mode = HVACAction.HEATING.value
+        if hvac_mode == HVACMode.COOL:
+            mode = HVACAction.COOLING.value
+        return mode
     @plugwise_command
+    @override
     async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
+        """Set the HVAC mode (off, heat, cool, heat_cool, or auto/schedule)."""
+        # Early exit if no mode change
+        if hvac_mode == self.hvac_mode:
+            return
+        # Adam only: set to HVACMode.OFF
+        if hvac_mode == HVACMode.OFF:
+            await self._api.set_regulation_mode(hvac_mode.value)
+            return
+        current_schedule = self.device["select_schedule"]
+        schedule_is_active = current_schedule != STATE_OFF
+        desired_schedule = (
+            current_schedule if schedule_is_active else self._last_active_schedule
         )
+        # Adam only: transition from HVACMode.OFF
+        if self.hvac_mode == HVACMode.OFF:
+            if hvac_mode == HVACMode.AUTO:
+                _check_for_schedule(schedule_is_active, self._last_active_schedule)
+                await self._api.set_schedule_state(
+                    self._location,
+                    desired_schedule,
+                    STATE_ON,
+                )
+                await self._api.set_regulation_mode(self._previous_action_mode)
+                return
+            # Transition to manual mode
+            if schedule_is_active:
+                await self._api.set_schedule_state(
+                    self._location,
+                    current_schedule,
+                    STATE_OFF,
+                )
+                self._last_active_schedule = current_schedule
+            regulation = self._regulation_mode_for_hvac(hvac_mode)
+            await self._api.set_regulation_mode(regulation)
+            return
+        # Common - transition from auto = schedule off
+        if self.hvac_mode == HVACMode.AUTO:
+            await self._api.set_schedule_state(
+                self._location,
+                current_schedule,
+                STATE_OFF,
+            )
+            self._last_active_schedule = current_schedule
+            return
+        # Common - transition to auto = schedule on
+        _check_for_schedule(schedule_is_active, self._last_active_schedule)
+        await self._api.set_schedule_state(self._location, desired_schedule, STATE_ON)
     @plugwise_command
+    @override
     async def async_set_preset_mode(self, preset_mode: str) -> None:
         """Set the preset mode."""
+        await self._api.set_preset(self._location, preset_mode)

/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/config_flow.py RENAMED Viewed

@@ -1,27 +1,8 @@
 """Config flow for Plugwise integration."""
-from __future__ import annotations
-import datetime as dt  # pw-beta options
-from typing import Any
-import voluptuous as vol
-from homeassistant import config_entries
-from homeassistant.components.zeroconf import ZeroconfServiceInfo
-from homeassistant.config_entries import ConfigEntry, ConfigFlow
-from homeassistant.const import (
-    CONF_BASE,
-    CONF_HOST,
-    CONF_NAME,
-    CONF_PASSWORD,
-    CONF_PORT,
-    CONF_SCAN_INTERVAL,
-    CONF_USERNAME,
-)
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.data_entry_flow import FlowResult
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from plugwise import Smile
 from plugwise.exceptions import (
     ConnectionFailedError,
@@ -31,59 +12,66 @@
     ResponseError,
     UnsupportedDeviceError,
 )
 from .const import (
-    CONF_HOMEKIT_EMULATION,  # pw-beta option
-    CONF_REFRESH_INTERVAL,  # pw-beta option
-    COORDINATOR,
     DEFAULT_PORT,
-    DEFAULT_SCAN_INTERVAL,  # pw-beta option
     DEFAULT_USERNAME,
     DOMAIN,
     FLOW_SMILE,
     FLOW_STRETCH,
     SMILE,
     STRETCH,
     STRETCH_USERNAME,
     ZEROCONF_MAP,
 )
-def _base_gw_schema(
-    discovery_info: ZeroconfServiceInfo | None,
-    user_input: dict[str, Any] | None,
-) -> vol.Schema:
     """Generate base schema for gateways."""
     if not discovery_info:
-        if not user_input:
-            return vol.Schema(
-                {
-                    vol.Required(CONF_PASSWORD): str,
-                    vol.Required(CONF_HOST): str,
-                    vol.Optional(CONF_PORT, default=DEFAULT_PORT): int,
-                    vol.Required(CONF_USERNAME, default=SMILE): vol.In(
-                        {SMILE: FLOW_SMILE, STRETCH: FLOW_STRETCH}
-                    ),
-                }
-            )
-        return vol.Schema(
             {
-                vol.Required(CONF_PASSWORD, default=user_input[CONF_PASSWORD]): str,
-                vol.Required(CONF_HOST, default=user_input[CONF_HOST]): str,
-                vol.Optional(CONF_PORT, default=user_input[CONF_PORT]): int,
-                vol.Required(CONF_USERNAME, default=user_input[CONF_USERNAME]): vol.In(
                     {SMILE: FLOW_SMILE, STRETCH: FLOW_STRETCH}
                 ),
             }
         )
-    return vol.Schema({vol.Required(CONF_PASSWORD): str})
-async def validate_gw_input(hass: HomeAssistant, data: dict[str, Any]) -> Smile:
     """Validate whether the user input allows us to connect to the gateway.
-    Data has the keys from _base_gw_schema() with values provided by the user.
     """
     websession = async_get_clientsession(hass, verify_ssl=False)
     api = Smile(
@@ -91,24 +79,51 @@
         password=data[CONF_PASSWORD],
         port=data[CONF_PORT],
         username=data[CONF_USERNAME],
-        timeout=30,
         websession=websession,
     )
     await api.connect()
     return api
 class PlugwiseConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Plugwise Smile."""
     VERSION = 1
     discovery_info: ZeroconfServiceInfo | None = None
     _username: str = DEFAULT_USERNAME
     async def async_step_zeroconf(
         self, discovery_info: ZeroconfServiceInfo
-    ) -> FlowResult:
         """Prepare configuration for a discovered Plugwise Smile."""
         self.discovery_info = discovery_info
         _properties = discovery_info.properties
@@ -116,7 +131,7 @@
         unique_id = discovery_info.hostname.split(".")[0].split("-")[0]
         if config_entry := await self.async_set_unique_id(unique_id):
             try:
-                await validate_gw_input(
                     self.hass,
                     {
                         CONF_HOST: discovery_info.host,
@@ -125,7 +140,7 @@
                         CONF_PASSWORD: config_entry.data[CONF_PASSWORD],
                     },
                 )
-            except Exception:  # pylint: disable=broad-except
                 self._abort_if_unique_id_configured()
             else:
                 self._abort_if_unique_id_configured(
@@ -137,165 +152,108 @@
         if DEFAULT_USERNAME not in unique_id:
             self._username = STRETCH_USERNAME
-        _product = _properties.get("product", None)
         _version = _properties.get("version", "n/a")
         _name = f"{ZEROCONF_MAP.get(_product, _product)} v{_version}"
         # This is an Anna, but we already have config entries.
         # Assuming that the user has already configured Adam, aborting discovery.
-        if self._async_current_entries() and _product == "smile_thermo":
-            return self.async_abort(reason="anna_with_adam")
         # If we have discovered an Adam or Anna, both might be on the network.
         # In that case, we need to cancel the Anna flow, as the Adam should
         # be added.
-        for flow in self._async_in_progress():
-            # This is an Anna, and there is already an Adam flow in progress
-            if (
-                _product == "smile_thermo"
-                and "context" in flow
-                and flow["context"].get("product") == "smile_open_therm"
-            ):
-                return self.async_abort(reason="anna_with_adam")
-            # This is an Adam, and there is already an Anna flow in progress
-            if (
-                _product == "smile_open_therm"
-                and "context" in flow
-                and flow["context"].get("product") == "smile_thermo"
-                and "flow_id" in flow
-            ):
-                self.hass.config_entries.flow.async_abort(flow["flow_id"])
         self.context.update(
             {
-                "title_placeholders": {
-                    CONF_HOST: discovery_info.host,
-                    CONF_NAME: _name,
-                    CONF_PORT: discovery_info.port,
-                    CONF_USERNAME: self._username,
-                },
-                "configuration_url": f"http://{discovery_info.host}:{discovery_info.port}",
-                "product": _product,
             }
         )
         return await self.async_step_user()
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
-    ) -> FlowResult:
         """Handle the initial step when using network/gateway setups."""
         errors: dict[str, str] = {}
-        if not user_input:
-            return self.async_show_form(
-                step_id="user",
-                data_schema=_base_gw_schema(self.discovery_info, None),
-                errors=errors,
-            )
-        if self.discovery_info:
-            user_input[CONF_HOST] = self.discovery_info.host
-            user_input[CONF_PORT] = self.discovery_info.port
-            user_input[CONF_USERNAME] = self._username
-        try:
-            api = await validate_gw_input(self.hass, user_input)
-        except ConnectionFailedError:
-            errors[CONF_BASE] = "cannot_connect"
-        except InvalidAuthentication:
-            errors[CONF_BASE] = "invalid_auth"
-        except InvalidSetupError:
-            errors[CONF_BASE] = "invalid_setup"
-        except (InvalidXMLError, ResponseError):
-            errors[CONF_BASE] = "response_error"
-        except UnsupportedDeviceError:
-            errors[CONF_BASE] = "unsupported"
-        except Exception:  # pylint: disable=broad-except
-            errors[CONF_BASE] = "unknown"
-        if errors:
-            return self.async_show_form(
-                step_id="user",
-                data_schema=_base_gw_schema(None, user_input),
-                errors=errors,
-            )
-        await self.async_set_unique_id(
-            api.smile_hostname or api.gateway_id, raise_on_progress=False
-        )
-        self._abort_if_unique_id_configured()
-        return self.async_create_entry(title=api.smile_name, data=user_input)
-    @staticmethod
-    @callback
-    def async_get_options_flow(
-        config_entry: ConfigEntry,
-    ) -> config_entries.OptionsFlow:  # pw-beta options
-        """Get the options flow for this handler."""
-        return PlugwiseOptionsFlowHandler(config_entry)
-# pw-beta - change the scan-interval via CONFIGURE
-# pw-beta - add homekit emulation via CONFIGURE
-# pw-beta - change the frontend refresh interval via CONFIGURE
-class PlugwiseOptionsFlowHandler(config_entries.OptionsFlow):  # pw-beta options
-    """Plugwise option flow."""
-    def __init__(self, config_entry: ConfigEntry) -> None:  # pragma: no cover
-        """Initialize options flow."""
-        self.config_entry = config_entry
-    async def async_step_none(
-        self, user_input: dict[str, Any] | None = None
-    ) -> FlowResult:  # pragma: no cover
-        """No options available."""
         if user_input is not None:
-            # Apparently not possible to abort an options flow at the moment
-            return self.async_create_entry(title="", data=self.config_entry.options)
-        return self.async_show_form(step_id="none")
-    async def async_step_init(
         self, user_input: dict[str, Any] | None = None
-    ) -> FlowResult:  # pragma: no cover
-        """Manage the Plugwise options."""
-        if not self.config_entry.data.get(CONF_HOST):
-            return await self.async_step_none(user_input)
-        if user_input is not None:
-            return self.async_create_entry(title="", data=user_input)
-        coordinator = self.hass.data[DOMAIN][self.config_entry.entry_id][COORDINATOR]
-        interval: dt.timedelta = DEFAULT_SCAN_INTERVAL[
-            coordinator.api.smile_type
-        ]  # pw-beta options
-        data = {
-            vol.Optional(
-                CONF_SCAN_INTERVAL,
-                default=self.config_entry.options.get(
-                    CONF_SCAN_INTERVAL, interval.seconds
-                ),
-            ): vol.All(cv.positive_int, vol.Clamp(min=10)),
-        }  # pw-beta
-        if coordinator.api.smile_type != "thermostat":
-            return self.async_show_form(step_id="init", data_schema=vol.Schema(data))
-        data.update(
-            {
-                vol.Optional(
-                    CONF_HOMEKIT_EMULATION,
-                    default=self.config_entry.options.get(
-                        CONF_HOMEKIT_EMULATION, False
-                    ),
-                ): cv.boolean,
-                vol.Optional(
-                    CONF_REFRESH_INTERVAL,
-                    default=self.config_entry.options.get(CONF_REFRESH_INTERVAL, 1.5),
-                ): vol.All(vol.Coerce(float), vol.Range(min=1.5, max=10.0)),
             }
-        )  # pw-beta
-        return self.async_show_form(step_id="init", data_schema=vol.Schema(data))

 """Config flow for Plugwise integration."""
+import logging
+from typing import Any, Self, override
 from plugwise import Smile
 from plugwise.exceptions import (
     ConnectionFailedError,
     ResponseError,
     UnsupportedDeviceError,
 )
+import probatio
+from homeassistant.config_entries import SOURCE_USER, ConfigFlow, ConfigFlowResult
+from homeassistant.const import (
+    CONF_BASE,
+    CONF_HOST,
+    CONF_PASSWORD,
+    CONF_PORT,
+    CONF_USERNAME,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo
 from .const import (
+    ANNA_WITH_ADAM,
     DEFAULT_PORT,
     DEFAULT_USERNAME,
     DOMAIN,
     FLOW_SMILE,
     FLOW_STRETCH,
     SMILE,
+    SMILE_OPEN_THERM,
+    SMILE_THERMO,
     STRETCH,
     STRETCH_USERNAME,
+    UNKNOWN_SMILE,
     ZEROCONF_MAP,
 )
+_LOGGER = logging.getLogger(__name__)
+SMILE_RECONF_SCHEMA = probatio.Schema(
+    {
+        probatio.Required(CONF_HOST): str,
+    }
+)
+def smile_user_schema(discovery_info: ZeroconfServiceInfo | None) -> probatio.Schema:
     """Generate base schema for gateways."""
+    schema = probatio.Schema({probatio.Required(probatio.Secret(CONF_PASSWORD)): str})
     if not discovery_info:
+        schema = schema.extend(
             {
+                probatio.Required(CONF_HOST): str,
+                probatio.Required(CONF_USERNAME, default=SMILE): probatio.In(
                     {SMILE: FLOW_SMILE, STRETCH: FLOW_STRETCH}
                 ),
             }
         )
+    return schema
+async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> Smile:
     """Validate whether the user input allows us to connect to the gateway.
+    Data has the keys from the schema with values provided by the user.
     """
     websession = async_get_clientsession(hass, verify_ssl=False)
     api = Smile(
         password=data[CONF_PASSWORD],
         port=data[CONF_PORT],
         username=data[CONF_USERNAME],
         websession=websession,
     )
     await api.connect()
     return api
+async def verify_connection(
+    hass: HomeAssistant, user_input: dict[str, Any]
+) -> tuple[Smile | None, dict[str, str]]:
+    """Verify and return the gateway connection or an error."""
+    errors: dict[str, str] = {}
+    try:
+        return (await validate_input(hass, user_input), errors)
+    except ConnectionFailedError:
+        errors[CONF_BASE] = "cannot_connect"
+    except InvalidAuthentication:
+        errors[CONF_BASE] = "invalid_auth"
+    except InvalidSetupError:
+        errors[CONF_BASE] = "invalid_setup"
+    except InvalidXMLError, ResponseError:
+        errors[CONF_BASE] = "response_error"
+    except UnsupportedDeviceError:
+        errors[CONF_BASE] = "unsupported"
+    except Exception:
+        _LOGGER.exception(
+            "Unknown exception while verifying connection with your Plugwise Smile"
+        )
+        errors[CONF_BASE] = "unknown"
+    return (None, errors)
 class PlugwiseConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Plugwise Smile."""
     VERSION = 1
     discovery_info: ZeroconfServiceInfo | None = None
+    product: str = UNKNOWN_SMILE
     _username: str = DEFAULT_USERNAME
+    @override
     async def async_step_zeroconf(
         self, discovery_info: ZeroconfServiceInfo
+    ) -> ConfigFlowResult:
         """Prepare configuration for a discovered Plugwise Smile."""
         self.discovery_info = discovery_info
         _properties = discovery_info.properties
         unique_id = discovery_info.hostname.split(".")[0].split("-")[0]
         if config_entry := await self.async_set_unique_id(unique_id):
             try:
+                await validate_input(
                     self.hass,
                     {
                         CONF_HOST: discovery_info.host,
                         CONF_PASSWORD: config_entry.data[CONF_PASSWORD],
                     },
                 )
+            except Exception:  # noqa: BLE001
                 self._abort_if_unique_id_configured()
             else:
                 self._abort_if_unique_id_configured(
         if DEFAULT_USERNAME not in unique_id:
             self._username = STRETCH_USERNAME
+        self.product = _product = _properties.get("product", UNKNOWN_SMILE)
         _version = _properties.get("version", "n/a")
         _name = f"{ZEROCONF_MAP.get(_product, _product)} v{_version}"
         # This is an Anna, but we already have config entries.
         # Assuming that the user has already configured Adam, aborting discovery.
+        if self._async_current_entries() and _product == SMILE_THERMO:
+            return self.async_abort(reason=ANNA_WITH_ADAM)
         # If we have discovered an Adam or Anna, both might be on the network.
         # In that case, we need to cancel the Anna flow, as the Adam should
         # be added.
+        if self.hass.config_entries.flow.async_has_matching_flow(self):
+            return self.async_abort(reason=ANNA_WITH_ADAM)
         self.context.update(
             {
+                "title_placeholders": {"name": _name},
+                "configuration_url": (
+                    f"http://{discovery_info.host}:{discovery_info.port}"
+                ),
             }
         )
         return await self.async_step_user()
+    @override
+    def is_matching(self, other_flow: Self) -> bool:
+        """Return True if other_flow is matching this flow."""
+        # This is an Anna, and there is already an Adam flow in progress
+        if self.product == SMILE_THERMO and other_flow.product == SMILE_OPEN_THERM:
+            return True
+        # This is an Adam, and there is already an Anna flow in progress
+        if self.product == SMILE_OPEN_THERM and other_flow.product == SMILE_THERMO:
+            self.hass.config_entries.flow.async_abort(other_flow.flow_id)
+        return False
+    @override
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
         """Handle the initial step when using network/gateway setups."""
         errors: dict[str, str] = {}
         if user_input is not None:
+            user_input[CONF_PORT] = DEFAULT_PORT
+            if self.discovery_info:
+                user_input[CONF_HOST] = self.discovery_info.host
+                user_input[CONF_PORT] = self.discovery_info.port
+                user_input[CONF_USERNAME] = self._username
+            api, errors = await verify_connection(self.hass, user_input)
+            if api:
+                await self.async_set_unique_id(
+                    api.smile.hostname or api.gateway_id,
+                    raise_on_progress=False,
+                )
+                self._abort_if_unique_id_configured()
+                return self.async_create_entry(title=api.smile.name, data=user_input)
+        return self.async_show_form(
+            step_id=SOURCE_USER,
+            data_schema=smile_user_schema(self.discovery_info),
+            errors=errors,
+        )
+    async def async_step_reconfigure(
         self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle reconfiguration of the integration."""
+        errors: dict[str, str] = {}
+        reconfigure_entry = self._get_reconfigure_entry()
+        if user_input:
+            # Keep current username and password
+            full_input = {
+                CONF_HOST: user_input.get(CONF_HOST),
+                CONF_PORT: reconfigure_entry.data.get(CONF_PORT),
+                CONF_USERNAME: reconfigure_entry.data.get(CONF_USERNAME),
+                CONF_PASSWORD: reconfigure_entry.data.get(CONF_PASSWORD),
             }
+            api, errors = await verify_connection(self.hass, full_input)
+            if api:
+                await self.async_set_unique_id(
+                    api.smile.hostname or api.gateway_id,
+                    raise_on_progress=False,
+                )
+                self._abort_if_unique_id_mismatch(reason="not_the_same_smile")
+                return self.async_update_reload_and_abort(
+                    reconfigure_entry,
+                    data_updates=full_input,
+                )
+        return self.async_show_form(
+            step_id="reconfigure",
+            data_schema=self.add_suggested_values_to_schema(
+                data_schema=SMILE_RECONF_SCHEMA,
+                suggested_values=reconfigure_entry.data,
+            ),
+            description_placeholders={"title": reconfigure_entry.title},
+            errors=errors,
+        )

/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/const.py RENAMED Viewed

@@ -1,7 +1,8 @@
 """Constants for Plugwise component."""
 from datetime import timedelta
 import logging
-from typing import Final
 from homeassistant.const import Platform
@@ -9,57 +10,121 @@
 LOGGER = logging.getLogger(__package__)
 API: Final = "api"
-COORDINATOR: Final = "coordinator"
-CONF_HOMEKIT_EMULATION: Final = "homekit_emulation"  # pw-beta options
-CONF_REFRESH_INTERVAL: Final = "refresh_interval"  # pw-beta options
-CONF_MANUAL_PATH: Final = "Enter Manually"
 SMILE: Final = "smile"
 STRETCH: Final = "stretch"
 STRETCH_USERNAME: Final = "stretch"
-FLOW_NET: Final = "Network: Smile/Stretch"
-FLOW_SMILE: Final = "Smile (Adam/Anna/P1)"
-FLOW_STRETCH: Final = "Stretch (Stretch)"
-FLOW_TYPE: Final = "flow_type"
-UNDO_UPDATE_LISTENER: Final = "undo_update_listener"
-# Default directives
-DEFAULT_PORT: Final = 80
-DEFAULT_SCAN_INTERVAL: Final[dict[str, timedelta]] = {
-    "power": timedelta(seconds=10),
-    "stretch": timedelta(seconds=60),
-    "thermostat": timedelta(seconds=60),
-}
-DEFAULT_TIMEOUT: Final = 10
-DEFAULT_USERNAME: Final = "smile"
-# --- Const for Plugwise Smile and Stretch
-PLATFORMS_GATEWAY: Final[list[str]] = [
     Platform.BINARY_SENSOR,
     Platform.CLIMATE,
     Platform.NUMBER,
     Platform.SELECT,
     Platform.SENSOR,
     Platform.SWITCH,
 ]
-SENSOR_PLATFORMS: Final[list[str]] = [Platform.SENSOR, Platform.SWITCH]
-SERVICE_DELETE: Final = "delete_notification"
-SEVERITIES: Final[list[str]] = ["other", "info", "message", "warning", "error"]
-# Climate const:
 MASTER_THERMOSTATS: Final[list[str]] = [
     "thermostat",
     "zone_thermometer",
     "zone_thermostat",
-    "thermostatic_radiator_valve",
 ]
-# Config_flow const:
-ZEROCONF_MAP: Final[dict[str, str]] = {
-    "smile": "Smile P1",
-    "smile_thermo": "Smile Anna",
-    "smile_open_therm": "Adam",
-    "stretch": "Stretch",
-}

 """Constants for Plugwise component."""
 from datetime import timedelta
 import logging
+from typing import Final, Literal, get_args
 from homeassistant.const import Platform
 LOGGER = logging.getLogger(__package__)
+ANNA_WITH_ADAM: Final = "anna_with_adam"
 API: Final = "api"
+AVAILABLE: Final = "available"
+DEV_CLASS: Final = "dev_class"
+FLOW_SMILE: Final = "smile (Adam/Anna/P1)"
+FLOW_STRETCH: Final = "stretch (Stretch)"
+FLOW_TYPE: Final = "flow_type"
+GATEWAY: Final = "gateway"
+LOCATION: Final = "location"
+LOWER_BOUND: Final = "lower_bound"
+PW_TYPE: Final = "plugwise_type"
+REBOOT: Final = "reboot"
 SMILE: Final = "smile"
+SMILE_OPEN_THERM: Final = "smile_open_therm"
+SMILE_THERMO: Final = "smile_thermo"
 STRETCH: Final = "stretch"
 STRETCH_USERNAME: Final = "stretch"
+UNKNOWN_SMILE: Final = "Unknown Smile"
+UPPER_BOUND: Final = "upper_bound"
+PLATFORMS: Final[list[str]] = [
     Platform.BINARY_SENSOR,
+    Platform.BUTTON,
     Platform.CLIMATE,
     Platform.NUMBER,
     Platform.SELECT,
     Platform.SENSOR,
     Platform.SWITCH,
+    Platform.WATER_HEATER,
 ]
+ZEROCONF_MAP: Final[dict[str, str]] = {
+    "smile": "Smile P1",
+    "smile_thermo": "Smile Anna",
+    "smile_open_therm": "Adam",
+    "stretch": "Stretch",
+}
+type BinarySensorType = Literal["dhw_state"]
+type NumberDataType = Literal[
+    "asleep_preset_temperature",
+    "away_preset_temperature",
+    "boiler_temperature",
+    "dhw_temperature",
+    "home_preset_temperature",
+    "no_frost_preset_temperature",
+    "temperature_offset",
+    "vacation_preset_temperature",
+]
+type PresetTemperatureType = Literal[
+    "asleep_preset_temperature",
+    "away_preset_temperature",
+    "home_preset_temperature",
+    "no_frost_preset_temperature",
+    "vacation_preset_temperature",
+]
+PRESET_TEMPERATURE_KEYS: Final[tuple[PresetTemperatureType, ...]] = get_args(
+    PresetTemperatureType.__value__
+)
+type PresetCoolingTemperatureType = Literal[
+    "asleep_preset_cooling_temperature",
+    "away_preset_cooling_temperature",
+    "home_preset_cooling_temperature",
+    "no_frost_preset_cooling_temperature",
+    "vacation_preset_cooling_temperature",
+]
+PRESET_COOLING_TEMPERATURE_KEYS: Final[tuple[PresetCoolingTemperatureType, ...]] = (
+    get_args(PresetCoolingTemperatureType.__value__)
+)
+type NumberType = NumberDataType | PresetCoolingTemperatureType
+type SelectType = Literal[
+    "dhw_mode",
+    "select_dhw_mode",
+    "select_gateway_mode",
+    "select_regulation_mode",
+    "select_schedule",
+    "select_zone_profile",
+]
+type SelectOptionsType = Literal[
+    "available_schedules",
+    "dhw_modes",
+    "gateway_modes",
+    "regulation_modes",
+    "zone_profiles",
+]
+type SetpointType = Literal["setpoint", "setpoint_high", "setpoint_low"]
+type WaterHeaterType = Literal["dhw_temperature"]
+# Default directives
+DEFAULT_MAX_TEMP: Final = 30
+DEFAULT_MIN_TEMP: Final = 4
+DEFAULT_PORT: Final = 80
+DEFAULT_UPDATE_INTERVAL = timedelta(seconds=60)
+DEFAULT_USERNAME: Final = "smile"
+P1_UPDATE_INTERVAL = timedelta(seconds=10)
 MASTER_THERMOSTATS: Final[list[str]] = [
     "thermostat",
+    "thermostatic_radiator_valve",
     "zone_thermometer",
     "zone_thermostat",
 ]
+# Select constants
+DHW_MODE: Final = "dhw_mode"
+SELECT_DHW_MODE: Final = "select_dhw_mode"
+SELECT_GATEWAY_MODE: Final = "select_gateway_mode"
+SELECT_REGULATION_MODE: Final = "select_regulation_mode"
+SELECT_SCHEDULE: Final = "select_schedule"
+SELECT_ZONE_PROFILE: Final = "select_zone_profile"
+# Water_heater constants
+DHW_TEMP: Final = "dhw_temperature"

/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/coordinator.py RENAMED Viewed

@@ -1,115 +1,213 @@
 """DataUpdateCoordinator for Plugwise."""
-from datetime import timedelta
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import (
-    CONF_HOST,
-    CONF_PASSWORD,
-    CONF_PORT,
-    CONF_SCAN_INTERVAL,  # pw-beta options
-    CONF_USERNAME,
-)
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryError
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.debounce import Debouncer
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
-from plugwise import PlugwiseData, Smile
 from plugwise.exceptions import (
     ConnectionFailedError,
     InvalidAuthentication,
     InvalidXMLError,
     ResponseError,
     UnsupportedDeviceError,
 )
-from .const import DEFAULT_PORT, DEFAULT_SCAN_INTERVAL, DEFAULT_USERNAME, DOMAIN, LOGGER
-class PlugwiseDataUpdateCoordinator(DataUpdateCoordinator[PlugwiseData]):
     """Class to manage fetching Plugwise data from single endpoint."""
-    _connected: bool = False
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        entry: ConfigEntry,
-        cooldown: float,
-        update_interval: timedelta = timedelta(seconds=60),
-    ) -> None:  # pw-beta cooldown
         """Initialize the coordinator."""
         super().__init__(
             hass,
             LOGGER,
             name=DOMAIN,
-            # Core directly updates from const's DEFAULT_SCAN_INTERVAL
-            update_interval=update_interval,
             # Don't refresh immediately, give the device time to process
             # the change in state before we query it.
             request_refresh_debouncer=Debouncer(
                 hass,
                 LOGGER,
-                cooldown=cooldown,
                 immediate=False,
             ),
         )
         self.api = Smile(
-            host=entry.data[CONF_HOST],
-            username=entry.data.get(CONF_USERNAME, DEFAULT_USERNAME),
-            password=entry.data[CONF_PASSWORD],
-            port=entry.data.get(CONF_PORT, DEFAULT_PORT),
-            timeout=30,
             websession=async_get_clientsession(hass, verify_ssl=False),
         )
-        self._entry = entry
-        self._unavailable_logged = False
-        self.update_interval = update_interval
     async def _connect(self) -> None:
-        """Connect to the Plugwise Smile."""
-        self._connected = await self.api.connect()
-        self.api.get_all_devices()
-        self.update_interval = DEFAULT_SCAN_INTERVAL.get(
-            self.api.smile_type, timedelta(seconds=60)
-        )  # pw-beta options scan-interval
-        if (custom_time := self._entry.options.get(CONF_SCAN_INTERVAL)) is not None:
-            self.update_interval = timedelta(
-                seconds=int(custom_time)
-            )  # pragma: no cover  # pw-beta options
-        LOGGER.debug("DUC update interval: %s", self.update_interval)  # pw-beta options
-    async def _async_update_data(self) -> PlugwiseData:
         """Fetch data from Plugwise."""
-        data = PlugwiseData(gateway={}, devices={})
         try:
             if not self._connected:
                 await self._connect()
             data = await self.api.async_update()
-            LOGGER.debug(f"{self.api.smile_name} data: %s", data)
-            if self._unavailable_logged:
-                self._unavailable_logged = False
         except InvalidAuthentication as err:
-            if not self._unavailable_logged:  # pw-beta add to Core
-                self._unavailable_logged = True
-                raise ConfigEntryError("Authentication failed") from err
         except (InvalidXMLError, ResponseError) as err:
-            if not self._unavailable_logged:  # pw-beta add to Core
-                self._unavailable_logged = True
-                raise UpdateFailed(
-                    "Invalid XML data, or error indication received from the Plugwise Adam/Smile/Stretch"
-                ) from err
         except UnsupportedDeviceError as err:
-            if not self._unavailable_logged:  # pw-beta add to Core
-                self._unavailable_logged = True
-                raise ConfigEntryError("Device with unsupported firmware") from err
-        except ConnectionFailedError as err:
-            if not self._unavailable_logged:  # pw-beta add to Core
-                self._unavailable_logged = True
-                raise UpdateFailed("Failed to connect") from err
         return data

 """DataUpdateCoordinator for Plugwise."""
+from typing import override
+from packaging.version import Version
+from plugwise import GwEntityData, Smile
 from plugwise.exceptions import (
     ConnectionFailedError,
     InvalidAuthentication,
+    InvalidSetupError,
     InvalidXMLError,
+    PlugwiseError,
     ResponseError,
     UnsupportedDeviceError,
 )
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_PORT, CONF_USERNAME
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryError
+from homeassistant.helpers import device_registry as dr
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.debounce import Debouncer
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+from .const import (
+    DEFAULT_PORT,
+    DEFAULT_UPDATE_INTERVAL,
+    DEFAULT_USERNAME,
+    DOMAIN,
+    LOGGER,
+    P1_UPDATE_INTERVAL,
+)
+type PlugwiseConfigEntry = ConfigEntry[PlugwiseDataUpdateCoordinator]
+class PlugwiseDataUpdateCoordinator(DataUpdateCoordinator[dict[str, GwEntityData]]):
     """Class to manage fetching Plugwise data from single endpoint."""
+    config_entry: PlugwiseConfigEntry
+    def __init__(self, hass: HomeAssistant, config_entry: PlugwiseConfigEntry) -> None:
         """Initialize the coordinator."""
         super().__init__(
             hass,
             LOGGER,
+            config_entry=config_entry,
             name=DOMAIN,
+            update_interval=DEFAULT_UPDATE_INTERVAL,
             # Don't refresh immediately, give the device time to process
             # the change in state before we query it.
             request_refresh_debouncer=Debouncer(
                 hass,
                 LOGGER,
+                cooldown=1.5,
                 immediate=False,
             ),
         )
         self.api = Smile(
+            host=self.config_entry.data[CONF_HOST],
+            username=self.config_entry.data.get(CONF_USERNAME, DEFAULT_USERNAME),
+            password=self.config_entry.data[CONF_PASSWORD],
+            port=self.config_entry.data.get(CONF_PORT, DEFAULT_PORT),
             websession=async_get_clientsession(hass, verify_ssl=False),
         )
+        self._connected: bool = False
+        self._current_devices: set[str] = set()
+        self._firmware_list: dict[str, str | None] = {}
+        self._stored_devices: set[str] = set()
+        self.new_devices: set[str] = set()
     async def _connect(self) -> None:
+        """Connect to the Plugwise Smile.
+        A Version object is received when the connection succeeds.
+        """
+        version = await self.api.connect()
+        self._connected = isinstance(version, Version)
+        if self._connected and self.api.smile.type == "power":
+            self.update_interval = P1_UPDATE_INTERVAL
+    @override
+    async def _async_setup(self) -> None:
+        """Initialize the update_data process."""
+        device_reg = dr.async_get(self.hass)
+        device_entries = dr.async_entries_for_config_entry(
+            device_reg, self.config_entry.entry_id
+        )
+        self._stored_devices = {
+            identifier[1]
+            for device_entry in device_entries
+            for identifier in device_entry.identifiers
+            if identifier[0] == DOMAIN
+        }
+    @override
+    async def _async_update_data(self) -> dict[str, GwEntityData]:
         """Fetch data from Plugwise."""
         try:
             if not self._connected:
                 await self._connect()
             data = await self.api.async_update()
+        except ConnectionFailedError as err:
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="failed_to_connect",
+            ) from err
         except InvalidAuthentication as err:
+            raise ConfigEntryError(
+                translation_domain=DOMAIN,
+                translation_key="authentication_failed",
+            ) from err
+        except InvalidSetupError as err:
+            raise ConfigEntryError(
+                translation_domain=DOMAIN,
+                translation_key="invalid_setup",
+            ) from err
         except (InvalidXMLError, ResponseError) as err:
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="response_error",
+            ) from err
+        except PlugwiseError as err:
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="data_incomplete_or_missing",
+            ) from err
         except UnsupportedDeviceError as err:
+            raise ConfigEntryError(
+                translation_domain=DOMAIN,
+                translation_key="unsupported_firmware",
+            ) from err
+        self._add_remove_devices(data)
+        self._update_device_firmware(data)
         return data
+    def _add_remove_devices(self, data: dict[str, GwEntityData]) -> None:
+        """Add new Plugwise devices, remove non-existing devices."""
+        set_of_data = set(data)
+        # Check for new or removed devices,
+        # 'new_devices' contains all devices present in 'data'
+        # at init ('self._current_devices' is empty) this is
+        # required for the proper initialization of all the
+        # present platform entities.
+        self.new_devices = set_of_data - self._current_devices
+        for device_id in self.new_devices:
+            self._firmware_list.setdefault(device_id, data[device_id].get("firmware"))
+        current_devices = (
+            self._stored_devices if not self._current_devices else self._current_devices
+        )
+        self._current_devices = set_of_data
+        if removed_devices := (current_devices - set_of_data):  # device(s) to remove
+            self._remove_devices(removed_devices)
+    def _remove_devices(self, removed_devices: set[str]) -> None:
+        """Clean registries when removed devices found."""
+        device_reg = dr.async_get(self.hass)
+        for device_id in removed_devices:
+            if (
+                device_entry := device_reg.async_get_device_by_identifier(
+                    (DOMAIN, device_id), self.config_entry.entry_id
+                )
+            ) is not None:
+                device_reg.async_remove_device(device_entry.id)
+                LOGGER.debug(
+                    "%s %s %s removed from device_registry",
+                    DOMAIN,
+                    device_entry.model,
+                    device_id,
+                )
+            self._firmware_list.pop(device_id, None)
+    def _update_device_firmware(self, data: dict[str, GwEntityData]) -> None:
+        """Detect firmware changes and update the device registry."""
+        for device_id, device in data.items():
+            # Only update firmware when the key is present and not None, to avoid
+            # wiping stored firmware on partial or transient updates.
+            if "firmware" not in device:
+                continue
+            new_firmware = device.get("firmware")
+            if new_firmware is None:
+                continue
+            if (
+                device_id in self._firmware_list
+                and new_firmware != self._firmware_list[device_id]
+            ):
+                updated = self._update_firmware_in_dr(device_id, new_firmware)
+                if updated:
+                    self._firmware_list[device_id] = new_firmware
+    def _update_firmware_in_dr(self, device_id: str, firmware: str | None) -> bool:
+        """Update device sw_version in device_registry."""
+        device_reg = dr.async_get(self.hass)
+        if (
+            device_entry := device_reg.async_get_device_by_identifier(
+                (DOMAIN, device_id), self.config_entry.entry_id
+            )
+        ) is not None:
+            device_reg.async_update_device(device_entry.id, sw_version=firmware)
+            LOGGER.debug(
+                "Firmware in device_registry updated for %s %s %s",
+                DOMAIN,
+                device_entry.model,
+                device_id,
+            )
+            return True
+        return False  # pragma: no cover

/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/diagnostics.py RENAMED Viewed

@@ -1,26 +1,15 @@
 """Diagnostics support for Plugwise."""
-from __future__ import annotations
 from typing import Any
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
-from .const import (
-    COORDINATOR,  # pw-beta
-    DOMAIN,
-)
-from .coordinator import PlugwiseDataUpdateCoordinator
 async def async_get_config_entry_diagnostics(
-    hass: HomeAssistant, entry: ConfigEntry
 ) -> dict[str, Any]:
     """Return diagnostics for a config entry."""
-    coordinator: PlugwiseDataUpdateCoordinator = hass.data[DOMAIN][entry.entry_id][
-        COORDINATOR
-    ]
-    return {
-        "gateway": coordinator.data.gateway,
-        "devices": coordinator.data.devices,
-    }

 """Diagnostics support for Plugwise."""
 from typing import Any
 from homeassistant.core import HomeAssistant
+from .coordinator import PlugwiseConfigEntry
 async def async_get_config_entry_diagnostics(
+    hass: HomeAssistant, entry: PlugwiseConfigEntry
 ) -> dict[str, Any]:
     """Return diagnostics for a config entry."""
+    coordinator = entry.runtime_data
+    return coordinator.data

/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/entity.py RENAMED Viewed

@@ -1,16 +1,19 @@
 """Generic Plugwise Entity Class."""
-from __future__ import annotations
-from homeassistant.const import ATTR_NAME, ATTR_VIA_DEVICE, CONF_HOST
 from homeassistant.helpers.device_registry import (
     CONNECTION_NETWORK_MAC,
     CONNECTION_ZIGBEE,
 )
-from homeassistant.helpers.entity import DeviceInfo
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
-from plugwise.constants import DeviceData
-from .const import DOMAIN
 from .coordinator import PlugwiseDataUpdateCoordinator
@@ -28,54 +31,62 @@
         super().__init__(coordinator)
         self._dev_id = device_id
-        configuration_url: str | None = None
-        if entry := self.coordinator.config_entry:
-            configuration_url = f"http://{entry.data[CONF_HOST]}"
-        data = coordinator.data.devices[device_id]
-        connections = set()
-        if mac := data.get("mac_address"):
-            connections.add((CONNECTION_NETWORK_MAC, mac))
-        if mac := data.get("zigbee_mac_address"):
-            connections.add((CONNECTION_ZIGBEE, mac))
         self._attr_device_info = DeviceInfo(
             configuration_url=configuration_url,
             identifiers={(DOMAIN, device_id)},
             connections=connections,
-            manufacturer=data.get("vendor"),
-            model=data.get("model"),
-            name=coordinator.data.gateway["smile_name"],
-            sw_version=data.get("firmware"),
-            hw_version=data.get("hardware"),
         )
-        if device_id != coordinator.data.gateway["gateway_id"]:
-            self._attr_device_info.update(
-                {
-                    ATTR_NAME: data.get("name"),
-                    ATTR_VIA_DEVICE: (
-                        DOMAIN,
-                        str(self.coordinator.data.gateway["gateway_id"]),
-                    ),
-                }
             )
     @property
     def available(self) -> bool:
         """Return if entity is available."""
         return (
-            self._dev_id in self.coordinator.data.devices
-            and ("available" not in self.device or self.device["available"] is True)
             and super().available
         )
     @property
-    def device(self) -> DeviceData:
         """Return data for this device."""
-        return self.coordinator.data.devices[self._dev_id]
-    async def async_added_to_hass(self) -> None:
-        """Subscribe to updates."""
-        self._handle_coordinator_update()
-        await super().async_added_to_hass()

 """Generic Plugwise Entity Class."""
+from typing import override
+from plugwise import GwEntityData
+from homeassistant.const import ATTR_NAME, CONF_HOST
 from homeassistant.helpers.device_registry import (
     CONNECTION_NETWORK_MAC,
     CONNECTION_ZIGBEE,
+    DeviceInfo,
+    async_get_device_id_by_identifier,
 )
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
+from .const import AVAILABLE, DOMAIN
 from .coordinator import PlugwiseDataUpdateCoordinator
         super().__init__(coordinator)
         self._dev_id = device_id
+        api = coordinator.api
+        gateway_id = api.gateway_id
+        entry = coordinator.config_entry
+        # Link configuration-URL for the gateway device
+        configuration_url = (
+            f"http://{entry.data[CONF_HOST]}"
+            if device_id == gateway_id and entry
+            else None
+        )
+        # Build connections set
+        connections = {
+            (CONNECTION_NETWORK_MAC, mac_address)
+            for mac_address in (
+                self.device.get("mac_address"),
+                self.device.get("wifi_mac_address"),
+            )
+            if mac_address is not None
+        }
+        if zigbee_mac := self.device.get("zigbee_mac_address"):
+            connections.add((CONNECTION_ZIGBEE, zigbee_mac))
+        # Set base device info
         self._attr_device_info = DeviceInfo(
             configuration_url=configuration_url,
             identifiers={(DOMAIN, device_id)},
             connections=connections,
+            manufacturer=self.device.get("vendor"),
+            model=self.device.get("model"),
+            model_id=self.device.get("model_id"),
+            name=api.smile.name,
+            sw_version=self.device.get("firmware"),
+            hw_version=self.device.get("hardware"),
         )
+        # Add extra info if not the gateway device
+        if device_id != gateway_id:
+            self._attr_device_info.name = self.device.get(ATTR_NAME)
+            self._attr_device_info.via_device_id = async_get_device_id_by_identifier(
+                coordinator.hass,
+                (DOMAIN, gateway_id),
+                config_entry_id=entry.entry_id,
             )
     @property
+    @override
     def available(self) -> bool:
         """Return if entity is available."""
         return (
+            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[self._dev_id]

/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/manifest.json RENAMED Viewed

@@ -1,13 +1,15 @@
 {
   "domain": "plugwise",
-  "name": "Plugwise Smile/Stretch Beta",
-  "after_dependencies": ["zeroconf"],
   "codeowners": ["@CoMPaTech", "@bouwew"],
   "config_flow": true,
-  "documentation": "https://github.com/plugwise/plugwise-beta",
   "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["plugwise"],
-  "requirements": ["plugwise==0.31.6"],
-  "version": "0.40.3a6"
 }

 {
   "domain": "plugwise",
+  "name": "Plugwise",
+  "categories": ["climate.thermostats_heating", "energy.meters_monitoring"],
   "codeowners": ["@CoMPaTech", "@bouwew"],
   "config_flow": true,
+  "connectivity": ["network"],
+  "documentation": "https://www.home-assistant.io/integrations/plugwise",
   "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["plugwise"],
+  "quality_scale": "platinum",
+  "requirements": ["plugwise==1.16.0"],
+  "zeroconf": ["_plugwise._tcp.local."]
 }

/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/number.py RENAMED Viewed

@@ -1,8 +1,9 @@
 """Number platform for Plugwise integration."""
-from __future__ import annotations
-from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
 from homeassistant.components.number import (
     NumberDeviceClass,
@@ -10,89 +11,134 @@
     NumberEntityDescription,
     NumberMode,
 )
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import EntityCategory, UnitOfTemperature
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-from plugwise import ActuatorData, DeviceData, Smile
 from .const import (
-    COORDINATOR,  # pw-beta
-    DOMAIN,
-    LOGGER,
 )
-from .coordinator import PlugwiseDataUpdateCoordinator
 from .entity import PlugwiseEntity
-@dataclass
-class PlugwiseNumberMixin:
-    """Mixin values for Plugwse entities."""
-    command: Callable[[Smile, str, float], Awaitable[None]]
-    native_max_value_fn: Callable[[ActuatorData], float]
-    native_min_value_fn: Callable[[ActuatorData], float]
-    native_step_fn: Callable[[ActuatorData], float]
-    native_value_fn: Callable[[ActuatorData], float]
-    actuator_fn: Callable[[DeviceData], ActuatorData | None]
-@dataclass
-class PlugwiseNumberEntityDescription(NumberEntityDescription, PlugwiseNumberMixin):
     """Class describing Plugwise Number entities."""
 NUMBER_TYPES = (
     PlugwiseNumberEntityDescription(
-        key="maximum_boiler_temperature",
         translation_key="maximum_boiler_temperature",
-        command=lambda api, number, value: api.set_number_setpoint(number, value),
         device_class=NumberDeviceClass.TEMPERATURE,
         entity_category=EntityCategory.CONFIG,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        native_max_value_fn=lambda data: data["upper_bound"],
-        native_min_value_fn=lambda data: data["lower_bound"],
-        native_step_fn=lambda data: data["resolution"],
-        native_value_fn=lambda data: data["setpoint"],
-        actuator_fn=lambda data: data.get("maximum_boiler_temperature"),
     ),
     PlugwiseNumberEntityDescription(
-        key="max_dhw_temperature",
         translation_key="max_dhw_temperature",
-        command=lambda api, number, value: api.set_number_setpoint(number, value),
         device_class=NumberDeviceClass.TEMPERATURE,
         entity_category=EntityCategory.CONFIG,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        native_max_value_fn=lambda data: data["upper_bound"],
-        native_min_value_fn=lambda data: data["lower_bound"],
-        native_step_fn=lambda data: data["resolution"],
-        native_value_fn=lambda data: data["setpoint"],
-        actuator_fn=lambda data: data.get("max_dhw_temperature"),
     ),
 )
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: ConfigEntry,
-    async_add_entities: AddEntitiesCallback,
 ) -> None:
     """Set up Plugwise number platform."""
-    coordinator: PlugwiseDataUpdateCoordinator = hass.data[DOMAIN][
-        config_entry.entry_id
-    ][COORDINATOR]
-    entities: list[PlugwiseNumberEntity] = []
-    for device_id, device in coordinator.data.devices.items():
-        for description in NUMBER_TYPES:
-            if actuator := description.actuator_fn(device):
                 entities.append(
-                    PlugwiseNumberEntity(actuator, coordinator, device_id, description)
                 )
-                LOGGER.debug("Add %s %s number", device["name"], description.name)
-    async_add_entities(entities)
 class PlugwiseNumberEntity(PlugwiseEntity, NumberEntity):
@@ -102,44 +148,47 @@
     def __init__(
         self,
-        actuator: ActuatorData,
         coordinator: PlugwiseDataUpdateCoordinator,
         device_id: str,
         description: PlugwiseNumberEntityDescription,
     ) -> None:
         """Initiate Plugwise Number."""
         super().__init__(coordinator, device_id)
-        self.actuator = actuator
-        self.entity_description = description
-        self._attr_unique_id = f"{device_id}-{description.key}"
         self._attr_mode = NumberMode.BOX
-    @property
-    def native_max_value(self) -> float:
-        """Return the setpoint max. value."""
-        return self.entity_description.native_max_value_fn(self.actuator)
-    @property
-    def native_min_value(self) -> float:
-        """Return the setpoint min. value."""
-        return self.entity_description.native_min_value_fn(self.actuator)
-    @property
-    def native_step(self) -> float:
-        """Return the setpoint step value."""
-        return max(self.entity_description.native_step_fn(self.actuator), 0.5)
     @property
-    def native_value(self) -> float:
         """Return the present setpoint value."""
-        return self.entity_description.native_value_fn(self.actuator)
     async def async_set_native_value(self, value: float) -> None:
         """Change to the new setpoint value."""
-        await self.entity_description.command(
-            self.coordinator.api, self.entity_description.key, value
-        )
-        LOGGER.debug(
-            "Setting %s to %s was successful", self.entity_description.name, value
-        )
-        await self.coordinator.async_request_refresh()

 """Number platform for Plugwise integration."""
 from dataclasses import dataclass
+from typing import override
+from plugwise.constants import GwEntityData
 from homeassistant.components.number import (
     NumberDeviceClass,
     NumberEntityDescription,
     NumberMode,
 )
+from homeassistant.const import EntityCategory, Platform, UnitOfTemperature
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import entity_registry as er
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from .const import (
+    PRESET_COOLING_TEMPERATURE_KEYS,
+    PRESET_TEMPERATURE_KEYS,
+    NumberDataType,
+    NumberType,
+    SetpointType,
 )
+from .coordinator import PlugwiseConfigEntry, PlugwiseDataUpdateCoordinator
 from .entity import PlugwiseEntity
+from .util import deprecate_entity, plugwise_command
+PARALLEL_UPDATES = 0
+@dataclass(frozen=True, kw_only=True)
+class PlugwiseNumberEntityDescription(NumberEntityDescription):
     """Class describing Plugwise Number entities."""
+    key: NumberType
+    data_key: NumberDataType
+    value_keys: tuple[SetpointType, ...] = ("setpoint",)
 NUMBER_TYPES = (
     PlugwiseNumberEntityDescription(
+        key="boiler_temperature",
+        data_key="boiler_temperature",
         translation_key="maximum_boiler_temperature",
         device_class=NumberDeviceClass.TEMPERATURE,
         entity_category=EntityCategory.CONFIG,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
     ),
     PlugwiseNumberEntityDescription(
+        key="dhw_temperature",
+        data_key="dhw_temperature",
         translation_key="max_dhw_temperature",
         device_class=NumberDeviceClass.TEMPERATURE,
         entity_category=EntityCategory.CONFIG,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+    ),
+    PlugwiseNumberEntityDescription(
+        key="temperature_offset",
+        data_key="temperature_offset",
+        translation_key="temperature_offset",
+        device_class=NumberDeviceClass.TEMPERATURE,
+        entity_category=EntityCategory.CONFIG,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+    ),
+    *(
+        PlugwiseNumberEntityDescription(
+            key=key,
+            data_key=key,
+            translation_key=key,
+            device_class=NumberDeviceClass.TEMPERATURE,
+            entity_category=EntityCategory.CONFIG,
+            native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+            value_keys=("setpoint", "setpoint_low"),
+        )
+        for key in PRESET_TEMPERATURE_KEYS
+    ),
+    *(
+        PlugwiseNumberEntityDescription(
+            key=key,
+            data_key=data_key,
+            translation_key=key,
+            device_class=NumberDeviceClass.TEMPERATURE,
+            entity_category=EntityCategory.CONFIG,
+            native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+            value_keys=("setpoint_high",),
+        )
+        for key, data_key in zip(
+            PRESET_COOLING_TEMPERATURE_KEYS, PRESET_TEMPERATURE_KEYS, strict=True
+        )
     ),
 )
+def _value_key(
+    description: PlugwiseNumberEntityDescription, device: GwEntityData
+) -> SetpointType | None:
+    """Return the first value key of the description present in the device data."""
+    ctrl = device.get(description.data_key, {})
+    return next((key for key in description.value_keys if key in ctrl), None)
 async def async_setup_entry(
     hass: HomeAssistant,
+    entry: PlugwiseConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Plugwise number platform."""
+    coordinator = entry.runtime_data
+    entity_registry = er.async_get(hass)
+    @callback
+    def _add_entities() -> None:
+        """Add Entities."""
+        if not coordinator.new_devices:
+            return
+        entities = []
+        for device_id in coordinator.new_devices:
+            for description in NUMBER_TYPES:
+                if _value_key(description, coordinator.data[device_id]) is None:
+                    continue
+                if description.key == "dhw_temperature" and not deprecate_entity(
+                    hass,
+                    entity_registry,
+                    async_on_unload=entry.async_on_unload,
+                    platform_domain=Platform.NUMBER,
+                    entity_unique_id=f"{device_id}-{description.translation_key}",
+                    issue_id=f"deprecated_dhw_temperature_{device_id}",
+                    translation_key="deprecated_dhw_temperature",
+                ):
+                    continue
                 entities.append(
+                    PlugwiseNumberEntity(coordinator, device_id, description)
                 )
+        async_add_entities(entities)
+    _add_entities()
+    entry.async_on_unload(coordinator.async_add_listener(_add_entities))
 class PlugwiseNumberEntity(PlugwiseEntity, NumberEntity):
     def __init__(
         self,
         coordinator: PlugwiseDataUpdateCoordinator,
         device_id: str,
         description: PlugwiseNumberEntityDescription,
     ) -> None:
         """Initiate Plugwise Number."""
         super().__init__(coordinator, device_id)
         self._attr_mode = NumberMode.BOX
+        self._data_key = description.data_key
+        ctrl = self.device.get(self._data_key, {})
+        self._attr_native_max_value = ctrl.get("upper_bound", 100.0)
+        self._attr_native_min_value = ctrl.get("lower_bound", 0.0)
+        self._attr_unique_id = f"{device_id}-{description.translation_key}"
+        self.device_id = device_id
+        self.entity_description = description
+        native_step = ctrl["resolution"]
+        if description.key != "temperature_offset":
+            native_step = max(native_step, 0.5)
+        self._attr_native_step = native_step
     @property
+    @override
+    def native_value(self) -> float | None:
         """Return the present setpoint value."""
+        ctrl = self.device.get(self._data_key, {})
+        value_keys = self.entity_description.value_keys
+        return next((ctrl[key] for key in value_keys if key in ctrl), None)
+    @plugwise_command
+    @override
     async def async_set_native_value(self, value: float) -> None:
         """Change to the new setpoint value."""
+        if self._data_key in PRESET_TEMPERATURE_KEYS:
+            await self.coordinator.api.set_number(
+                self.device_id,
+                self._data_key,
+                value,
+                setpoint=_value_key(self.entity_description, self.device)
+                or self.entity_description.value_keys[0],
+            )
+        else:
+            await self.coordinator.api.set_number(
+                self.device_id, self.entity_description.key, value
+            )

/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/select.py RENAMED Viewed

@@ -1,93 +1,123 @@
 """Plugwise Select component for Home Assistant."""
-from __future__ import annotations
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
 from homeassistant.components.select import SelectEntity, SelectEntityDescription
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import STATE_ON, EntityCategory
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-from plugwise import DeviceData, Smile
 from .const import (
-    COORDINATOR,  # pw-beta
-    DOMAIN,
-    LOGGER,
 )
-from .coordinator import PlugwiseDataUpdateCoordinator
 from .entity import PlugwiseEntity
 PARALLEL_UPDATES = 0
-@dataclass
-class PlugwiseSelectDescriptionMixin:
-    """Mixin values for Plugwise Select entities."""
-    command: Callable[[Smile, str, str], Awaitable[None]]
-    value_fn: Callable[[DeviceData], str]
-    options_fn: Callable[[DeviceData], list[str] | None]
-@dataclass
-class PlugwiseSelectEntityDescription(
-    SelectEntityDescription, PlugwiseSelectDescriptionMixin
-):
-    """Class describing Plugwise Number entities."""
 SELECT_TYPES = (
     PlugwiseSelectEntityDescription(
-        key="select_schedule",
-        translation_key="thermostat_schedule",
-        icon="mdi:calendar-clock",
-        command=lambda api, loc, opt: api.set_schedule_state(loc, opt, STATE_ON),
-        value_fn=lambda data: data["selected_schedule"],
-        options_fn=lambda data: data.get("available_schedules"),
     ),
     PlugwiseSelectEntityDescription(
-        key="select_regulation_mode",
-        translation_key="regulation_mode",
-        icon="mdi:hvac",
         entity_category=EntityCategory.CONFIG,
-        command=lambda api, loc, opt: api.set_regulation_mode(opt),
-        value_fn=lambda data: data["regulation_mode"],
-        options_fn=lambda data: data.get("regulation_modes"),
     ),
     PlugwiseSelectEntityDescription(
-        key="select_dhw_mode",
-        translation_key="dhw_mode",
-        icon="mdi:shower",
         entity_category=EntityCategory.CONFIG,
-        command=lambda api, loc, opt: api.set_dhw_mode(opt),
-        value_fn=lambda data: data["dhw_mode"],
-        options_fn=lambda data: data.get("dhw_modes"),
     ),
 )
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: ConfigEntry,
-    async_add_entities: AddEntitiesCallback,
 ) -> None:
     """Set up the Smile selector from a config entry."""
-    coordinator: PlugwiseDataUpdateCoordinator = hass.data[DOMAIN][
-        config_entry.entry_id
-    ][COORDINATOR]
-    entities: list[PlugwiseSelectEntity] = []
-    for device_id, device in coordinator.data.devices.items():
-        for description in SELECT_TYPES:
-            if (options := description.options_fn(device)) and len(options) > 1:
-                entities.append(
-                    PlugwiseSelectEntity(coordinator, device_id, description, options)
-                )
-                LOGGER.debug("Add %s %s selector", device["name"], description.name)
-    async_add_entities(entities)
 class PlugwiseSelectEntity(PlugwiseEntity, SelectEntity):
@@ -100,28 +130,50 @@
         coordinator: PlugwiseDataUpdateCoordinator,
         device_id: str,
         entity_description: PlugwiseSelectEntityDescription,
-        options: list[str],
     ) -> None:
         """Initialise the selector."""
         super().__init__(coordinator, device_id)
         self.entity_description = entity_description
-        self._attr_unique_id = f"{device_id}-{entity_description.key}"
-        self._attr_options = options
     @property
-    def current_option(self) -> str:
         """Return the selected entity option to represent the entity state."""
-        # return self.device[self.entity_description.current_option_key]  # type: ignore [literal-required]
-        return self.entity_description.value_fn(self.device)
     async def async_select_option(self, option: str) -> None:
-        """Change to the selected entity option."""
-        await self.entity_description.command(
-            self.coordinator.api, self.device["location"], option
-        )
-        LOGGER.debug(
-            "Set %s to %s was successful.",
-            self.entity_description.name,
             option,
         )
-        await self.coordinator.async_request_refresh()

 """Plugwise Select component for Home Assistant."""
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
+from typing import override
+from plugwise import Smile
 from homeassistant.components.select import SelectEntity, SelectEntityDescription
 from homeassistant.const import STATE_ON, EntityCategory
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from .const import (
+    DHW_MODE,
+    LOCATION,
+    SELECT_DHW_MODE,
+    SELECT_GATEWAY_MODE,
+    SELECT_REGULATION_MODE,
+    SELECT_SCHEDULE,
+    SELECT_ZONE_PROFILE,
+    SelectOptionsType,
+    SelectType,
 )
+from .coordinator import PlugwiseConfigEntry, PlugwiseDataUpdateCoordinator
 from .entity import PlugwiseEntity
+from .util import plugwise_command
 PARALLEL_UPDATES = 0
+@dataclass(frozen=True, kw_only=True)
+class PlugwiseSelectEntityDescription(SelectEntityDescription):
+    """Class describing Plugwise Select entities."""
+    key: SelectType
+    options_key: SelectOptionsType
+    set_value_fn: Callable[[Smile, str, str, str, int | str | None], Awaitable[None]]
 SELECT_TYPES = (
     PlugwiseSelectEntityDescription(
+        key=DHW_MODE,
+        translation_key=SELECT_DHW_MODE,
+        entity_category=EntityCategory.CONFIG,
+        options_key="dhw_modes",
+        set_value_fn=lambda api, key, appl_id, option, length: api.set_dhw_mode(
+            key, appl_id, option, length
+        ),
+    ),
+    PlugwiseSelectEntityDescription(
+        key=SELECT_DHW_MODE,
+        translation_key=SELECT_DHW_MODE,
+        entity_category=EntityCategory.CONFIG,
+        options_key="dhw_modes",
+        set_value_fn=lambda api, key, appl_or_loc_id, option, state: api.set_select(
+            key, appl_or_loc_id, option, state
+        ),
     ),
     PlugwiseSelectEntityDescription(
+        key=SELECT_GATEWAY_MODE,
+        translation_key=SELECT_GATEWAY_MODE,
         entity_category=EntityCategory.CONFIG,
+        options_key="gateway_modes",
+        set_value_fn=lambda api, key, appl_or_loc_id, option, state: api.set_select(
+            key, appl_or_loc_id, option, state
+        ),
     ),
     PlugwiseSelectEntityDescription(
+        key=SELECT_REGULATION_MODE,
+        translation_key=SELECT_REGULATION_MODE,
         entity_category=EntityCategory.CONFIG,
+        options_key="regulation_modes",
+        set_value_fn=lambda api, key, appl_or_loc_id, option, state: api.set_select(
+            key, appl_or_loc_id, option, state
+        ),
+    ),
+    PlugwiseSelectEntityDescription(
+        key=SELECT_SCHEDULE,
+        translation_key=SELECT_SCHEDULE,
+        options_key="available_schedules",
+        set_value_fn=lambda api, key, appl_or_loc_id, option, state: api.set_select(
+            key, appl_or_loc_id, option, state
+        ),
+    ),
+    PlugwiseSelectEntityDescription(
+        key=SELECT_ZONE_PROFILE,
+        translation_key=SELECT_ZONE_PROFILE,
+        entity_category=EntityCategory.CONFIG,
+        options_key="zone_profiles",
+        set_value_fn=lambda api, key, appl_or_loc_id, option, state: api.set_select(
+            key, appl_or_loc_id, option, state
+        ),
     ),
 )
 async def async_setup_entry(
     hass: HomeAssistant,
+    entry: PlugwiseConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the Smile selector from a config entry."""
+    coordinator = entry.runtime_data
+    @callback
+    def _add_entities() -> None:
+        """Add entities."""
+        if not coordinator.new_devices:
+            return
+        async_add_entities(
+            PlugwiseSelectEntity(coordinator, device_id, description)
+            for device_id in coordinator.new_devices
+            for description in SELECT_TYPES
+            if coordinator.data[device_id].get(description.key)
+        )
+    _add_entities()
+    entry.async_on_unload(coordinator.async_add_listener(_add_entities))
 class PlugwiseSelectEntity(PlugwiseEntity, SelectEntity):
         coordinator: PlugwiseDataUpdateCoordinator,
         device_id: str,
         entity_description: PlugwiseSelectEntityDescription,
     ) -> None:
         """Initialise the selector."""
         super().__init__(coordinator, device_id)
+        suffix = entity_description.key
+        if entity_description.key == DHW_MODE:
+            suffix = SELECT_DHW_MODE
+        self._attr_unique_id = f"{device_id}-{suffix}"
         self.entity_description = entity_description
+        self._device_or_location = device_id
+        if (
+            self.entity_description.key in (SELECT_SCHEDULE, SELECT_ZONE_PROFILE)
+            and (location := self.device.get(LOCATION)) is not None
+        ):
+            self._device_or_location = location
     @property
+    @override
+    def current_option(self) -> str | None:
         """Return the selected entity option to represent the entity state."""
+        return self.device[self.entity_description.key]
+    @property
+    @override
+    def options(self) -> list[str]:
+        """Return the available select-options."""
+        return self.device[self.entity_description.options_key]
+    @plugwise_command
+    @override
     async def async_select_option(self, option: str) -> None:
+        """Change to the selected entity option.
+        The appliance ID (= device_id) is required for the dhw_mode select.
+        The location ID is required for the thermostat schedule and zone_profile selects.
+        STATE_ON is required for the thermostat schedule select.
+        """
+        options_count_or_state: int | str | None = len(self.options)
+        if self.entity_description.key != DHW_MODE:
+            options_count_or_state = STATE_ON
+        await self.entity_description.set_value_fn(
+            self.coordinator.api,
+            self.entity_description.key,
+            self._device_or_location,
             option,
+            options_count_or_state,
         )

/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/sensor.py RENAMED Viewed

@@ -1,48 +1,427 @@
 """Plugwise Sensor component for Home Assistant."""
-from __future__ import annotations
-from homeassistant.components.sensor import SensorEntity
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-from .const import (
-    COORDINATOR,  # pw-beta
-    DOMAIN,
-    LOGGER,
 )
-from .coordinator import PlugwiseDataUpdateCoordinator
 from .entity import PlugwiseEntity
-from .models import PW_SENSOR_TYPES, PlugwiseSensorEntityDescription
 PARALLEL_UPDATES = 0
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: ConfigEntry,
-    async_add_entities: AddEntitiesCallback,
 ) -> None:
     """Set up the Smile sensors from a config entry."""
-    coordinator = hass.data[DOMAIN][config_entry.entry_id][COORDINATOR]
-    entities: list[PlugwiseSensorEntity] = []
-    for device_id, device in coordinator.data.devices.items():
-        if not (sensors := device.get("sensors")):
-            continue
-        for description in PW_SENSOR_TYPES:
-            if description.key not in sensors:
-                continue
-            entities.append(
-                PlugwiseSensorEntity(
-                    coordinator,
-                    device_id,
-                    description,
-                )
-            )
-            LOGGER.debug("Add %s sensor", description.key)
-    async_add_entities(entities)
 class PlugwiseSensorEntity(PlugwiseEntity, SensorEntity):
@@ -58,10 +437,11 @@
     ) -> None:
         """Initialise the sensor."""
         super().__init__(coordinator, device_id)
-        self.entity_description = description
         self._attr_unique_id = f"{device_id}-{description.key}"
     @property
     def native_value(self) -> int | float:
         """Return the value reported by the sensor."""
-        return self.entity_description.value_fn(self.device["sensors"])

 """Plugwise Sensor component for Home Assistant."""
+from dataclasses import dataclass
+from typing import override
+from plugwise.constants import SensorType
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorEntity,
+    SensorEntityDescription,
+    SensorStateClass,
+)
+from homeassistant.const import (
+    LIGHT_LUX,
+    PERCENTAGE,
+    EntityCategory,
+    UnitOfElectricPotential,
+    UnitOfEnergy,
+    UnitOfPower,
+    UnitOfPressure,
+    UnitOfTemperature,
+    UnitOfVolume,
+    UnitOfVolumeFlowRate,
 )
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from .coordinator import PlugwiseConfigEntry, PlugwiseDataUpdateCoordinator
 from .entity import PlugwiseEntity
+# Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
+@dataclass(frozen=True)
+class PlugwiseSensorEntityDescription(SensorEntityDescription):
+    """Describes Plugwise sensor entity."""
+    key: SensorType
+SENSORS: tuple[PlugwiseSensorEntityDescription, ...] = (
+    PlugwiseSensorEntityDescription(
+        key="setpoint",
+        translation_key="setpoint",
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        device_class=SensorDeviceClass.TEMPERATURE,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="setpoint_high",
+        translation_key="cooling_setpoint",
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        device_class=SensorDeviceClass.TEMPERATURE,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="setpoint_low",
+        translation_key="heating_setpoint",
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        device_class=SensorDeviceClass.TEMPERATURE,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="temperature",
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        device_class=SensorDeviceClass.TEMPERATURE,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="intended_boiler_temperature",
+        translation_key="intended_boiler_temperature",
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        device_class=SensorDeviceClass.TEMPERATURE,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="temperature_difference",
+        translation_key="temperature_difference",
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        device_class=SensorDeviceClass.TEMPERATURE,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="outdoor_temperature",
+        translation_key="outdoor_temperature",
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        device_class=SensorDeviceClass.TEMPERATURE,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="outdoor_air_temperature",
+        translation_key="outdoor_air_temperature",
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        device_class=SensorDeviceClass.TEMPERATURE,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="water_temperature",
+        translation_key="water_temperature",
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        device_class=SensorDeviceClass.TEMPERATURE,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="return_temperature",
+        translation_key="return_temperature",
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        device_class=SensorDeviceClass.TEMPERATURE,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="electricity_consumed",
+        translation_key="electricity_consumed",
+        native_unit_of_measurement=UnitOfPower.WATT,
+        device_class=SensorDeviceClass.POWER,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="electricity_produced",
+        translation_key="electricity_produced",
+        native_unit_of_measurement=UnitOfPower.WATT,
+        device_class=SensorDeviceClass.POWER,
+        state_class=SensorStateClass.MEASUREMENT,
+        entity_registry_enabled_default=False,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="electricity_consumed_interval",
+        translation_key="electricity_consumed_interval",
+        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
+        device_class=SensorDeviceClass.ENERGY,
+        state_class=SensorStateClass.TOTAL,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="electricity_consumed_peak_interval",
+        translation_key="electricity_consumed_peak_interval",
+        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
+        device_class=SensorDeviceClass.ENERGY,
+        state_class=SensorStateClass.TOTAL,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="electricity_consumed_off_peak_interval",
+        translation_key="electricity_consumed_off_peak_interval",
+        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
+        device_class=SensorDeviceClass.ENERGY,
+        state_class=SensorStateClass.TOTAL,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="electricity_produced_interval",
+        translation_key="electricity_produced_interval",
+        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
+        device_class=SensorDeviceClass.ENERGY,
+        state_class=SensorStateClass.TOTAL,
+        entity_registry_enabled_default=False,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="electricity_produced_peak_interval",
+        translation_key="electricity_produced_peak_interval",
+        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
+        device_class=SensorDeviceClass.ENERGY,
+        state_class=SensorStateClass.TOTAL,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="electricity_produced_off_peak_interval",
+        translation_key="electricity_produced_off_peak_interval",
+        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
+        device_class=SensorDeviceClass.ENERGY,
+        state_class=SensorStateClass.TOTAL,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="electricity_consumed_point",
+        translation_key="electricity_consumed_point",
+        device_class=SensorDeviceClass.POWER,
+        native_unit_of_measurement=UnitOfPower.WATT,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="electricity_consumed_off_peak_point",
+        translation_key="electricity_consumed_off_peak_point",
+        native_unit_of_measurement=UnitOfPower.WATT,
+        device_class=SensorDeviceClass.POWER,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="electricity_consumed_peak_point",
+        translation_key="electricity_consumed_peak_point",
+        native_unit_of_measurement=UnitOfPower.WATT,
+        device_class=SensorDeviceClass.POWER,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="electricity_consumed_off_peak_cumulative",
+        translation_key="electricity_consumed_off_peak_cumulative",
+        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
+        device_class=SensorDeviceClass.ENERGY,
+        state_class=SensorStateClass.TOTAL_INCREASING,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="electricity_consumed_peak_cumulative",
+        translation_key="electricity_consumed_peak_cumulative",
+        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
+        device_class=SensorDeviceClass.ENERGY,
+        state_class=SensorStateClass.TOTAL_INCREASING,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="electricity_produced_point",
+        translation_key="electricity_produced_point",
+        device_class=SensorDeviceClass.POWER,
+        native_unit_of_measurement=UnitOfPower.WATT,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="electricity_produced_off_peak_point",
+        translation_key="electricity_produced_off_peak_point",
+        native_unit_of_measurement=UnitOfPower.WATT,
+        device_class=SensorDeviceClass.POWER,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="electricity_produced_peak_point",
+        translation_key="electricity_produced_peak_point",
+        native_unit_of_measurement=UnitOfPower.WATT,
+        device_class=SensorDeviceClass.POWER,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="electricity_produced_off_peak_cumulative",
+        translation_key="electricity_produced_off_peak_cumulative",
+        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
+        device_class=SensorDeviceClass.ENERGY,
+        state_class=SensorStateClass.TOTAL_INCREASING,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="electricity_produced_peak_cumulative",
+        translation_key="electricity_produced_peak_cumulative",
+        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
+        device_class=SensorDeviceClass.ENERGY,
+        state_class=SensorStateClass.TOTAL_INCREASING,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="electricity_phase_one_consumed",
+        translation_key="electricity_phase_one_consumed",
+        device_class=SensorDeviceClass.POWER,
+        native_unit_of_measurement=UnitOfPower.WATT,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="electricity_phase_two_consumed",
+        translation_key="electricity_phase_two_consumed",
+        device_class=SensorDeviceClass.POWER,
+        native_unit_of_measurement=UnitOfPower.WATT,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="electricity_phase_three_consumed",
+        translation_key="electricity_phase_three_consumed",
+        device_class=SensorDeviceClass.POWER,
+        native_unit_of_measurement=UnitOfPower.WATT,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="electricity_phase_one_produced",
+        translation_key="electricity_phase_one_produced",
+        device_class=SensorDeviceClass.POWER,
+        native_unit_of_measurement=UnitOfPower.WATT,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="electricity_phase_two_produced",
+        translation_key="electricity_phase_two_produced",
+        device_class=SensorDeviceClass.POWER,
+        native_unit_of_measurement=UnitOfPower.WATT,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="electricity_phase_three_produced",
+        translation_key="electricity_phase_three_produced",
+        device_class=SensorDeviceClass.POWER,
+        native_unit_of_measurement=UnitOfPower.WATT,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="voltage_phase_one",
+        translation_key="voltage_phase_one",
+        device_class=SensorDeviceClass.VOLTAGE,
+        native_unit_of_measurement=UnitOfElectricPotential.VOLT,
+        state_class=SensorStateClass.MEASUREMENT,
+        entity_registry_enabled_default=False,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="voltage_phase_two",
+        translation_key="voltage_phase_two",
+        device_class=SensorDeviceClass.VOLTAGE,
+        native_unit_of_measurement=UnitOfElectricPotential.VOLT,
+        state_class=SensorStateClass.MEASUREMENT,
+        entity_registry_enabled_default=False,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="voltage_phase_three",
+        translation_key="voltage_phase_three",
+        device_class=SensorDeviceClass.VOLTAGE,
+        native_unit_of_measurement=UnitOfElectricPotential.VOLT,
+        state_class=SensorStateClass.MEASUREMENT,
+        entity_registry_enabled_default=False,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="gas_consumed_interval",
+        translation_key="gas_consumed_interval",
+        native_unit_of_measurement=UnitOfVolumeFlowRate.CUBIC_METERS_PER_HOUR,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="gas_consumed_cumulative",
+        translation_key="gas_consumed_cumulative",
+        native_unit_of_measurement=UnitOfVolume.CUBIC_METERS,
+        device_class=SensorDeviceClass.GAS,
+        state_class=SensorStateClass.TOTAL,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="net_electricity_point",
+        translation_key="net_electricity_point",
+        native_unit_of_measurement=UnitOfPower.WATT,
+        device_class=SensorDeviceClass.POWER,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="net_electricity_cumulative",
+        translation_key="net_electricity_cumulative",
+        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
+        device_class=SensorDeviceClass.ENERGY,
+        state_class=SensorStateClass.TOTAL,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="battery",
+        native_unit_of_measurement=PERCENTAGE,
+        device_class=SensorDeviceClass.BATTERY,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="illuminance",
+        native_unit_of_measurement=LIGHT_LUX,
+        device_class=SensorDeviceClass.ILLUMINANCE,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="modulation_level",
+        translation_key="modulation_level",
+        native_unit_of_measurement=PERCENTAGE,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="valve_position",
+        translation_key="valve_position",
+        native_unit_of_measurement=PERCENTAGE,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="water_pressure",
+        translation_key="water_pressure",
+        native_unit_of_measurement=UnitOfPressure.BAR,
+        device_class=SensorDeviceClass.PRESSURE,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="humidity",
+        native_unit_of_measurement=PERCENTAGE,
+        device_class=SensorDeviceClass.HUMIDITY,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="dhw_temperature",
+        translation_key="dhw_temperature",
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        device_class=SensorDeviceClass.TEMPERATURE,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    PlugwiseSensorEntityDescription(
+        key="domestic_hot_water_setpoint",
+        translation_key="domestic_hot_water_setpoint",
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        device_class=SensorDeviceClass.TEMPERATURE,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+)
 async def async_setup_entry(
     hass: HomeAssistant,
+    entry: PlugwiseConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the Smile sensors from a config entry."""
+    coordinator = entry.runtime_data
+    @callback
+    def _add_entities() -> None:
+        """Add Entities."""
+        if not coordinator.new_devices:
+            return
+        async_add_entities(
+            PlugwiseSensorEntity(coordinator, device_id, description)
+            for device_id in coordinator.new_devices
+            if (sensors := coordinator.data[device_id].get("sensors"))
+            for description in SENSORS
+            if description.key in sensors
+        )
+    _add_entities()
+    entry.async_on_unload(coordinator.async_add_listener(_add_entities))
 class PlugwiseSensorEntity(PlugwiseEntity, SensorEntity):
     ) -> None:
         """Initialise the sensor."""
         super().__init__(coordinator, device_id)
         self._attr_unique_id = f"{device_id}-{description.key}"
+        self.entity_description = description
     @property
+    @override
     def native_value(self) -> int | float:
         """Return the value reported by the sensor."""
+        return self.device["sensors"][self.entity_description.key]

/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/strings.json RENAMED Viewed

@@ -1,48 +1,46 @@
 {
-  "options": {
-    "step": {
-      "none": {
-        "title": "No Options available",
-        "description": "This Integration does not provide any Options"
-      },
-      "init": {
-        "description": "Adjust Smile/Stretch Options",
-        "data": {
-          "cooling_on": "Anna: cooling-mode is on",
-          "scan_interval": "Scan Interval (seconds) *) beta-only option",
-          "homekit_emulation": "Homekit emulation (i.e. on hvac_off => Away) *) beta-only option",
-          "refresh_interval": "Frontend refresh-time (1.5 - 5 seconds) *) beta-only option"
-        }
-      }
-    }
-  },
   "config": {
-    "step": {
-      "user": {
-        "title": "Connect to the Plugwise Adam/Smile/Stretch",
-        "description": "Please enter:",
-        "data": {
-          "password": "ID",
-          "username": "Username",
-          "host": "IP-address",
-          "port": "Port number"
-        }
-      }
     },
     "error": {
-      "cannot_connect": "Failed to connect",
-      "invalid_auth": "Authentication failed",
       "invalid_setup": "Add your Adam instead of your Anna, see the documentation",
-      "network_down": "Plugwise Zigbee network is down",
-      "network_timeout": "Network communication timeout",
       "response_error": "Invalid XML data, or error indication received",
-      "stick_init": "Initialization of Plugwise USB-stick failed",
-      "unknown": "Unknown error!",
       "unsupported": "Device with unsupported firmware"
     },
-    "abort": {
-      "already_configured": "This device is already configured",
-      "anna_with_adam": "Both Anna and Adam detected. Add your Adam instead of your Anna"
     }
   },
   "entity": {
@@ -53,6 +51,9 @@
       "cooling_enabled": {
         "name": "Cooling enabled"
       },
       "dhw_state": {
         "name": "DHW state"
       },
@@ -60,230 +61,331 @@
         "name": "Flame state"
       },
       "heating_state": {
-        "name": "Heating"
-      },
-      "cooling_state": {
-        "name": "Cooling"
-      },
-      "slave_boiler_state": {
-        "name": "Secondary boiler state"
       },
       "plugwise_notification": {
         "name": "Plugwise notification"
       }
     },
     "climate": {
       "plugwise": {
         "state_attributes": {
           "preset_mode": {
             "state": {
               "asleep": "Night",
-              "away": "Away",
-              "home": "Home",
               "no_frost": "Anti-frost",
               "vacation": "Vacation"
             }
           }
         }
       }
     },
     "number": {
-      "maximum_boiler_temperature": {
-        "name": "Maximum boiler temperature setpoint"
       },
       "max_dhw_temperature": {
         "name": "Domestic hot water setpoint"
       }
     },
     "select": {
-      "dhw_mode": {
         "name": "DHW mode",
         "state": {
-          "auto": "Auto",
           "boost": "Boost",
           "comfort": "Comfort",
-          "off": "Off"
         }
       },
-      "regulation_mode": {
         "name": "Regulation mode",
         "state": {
           "bleeding_cold": "Bleeding cold",
           "bleeding_hot": "Bleeding hot",
-          "cooling": "Cooling",
-          "heating": "Heating",
-          "off": "Off"
         }
       },
-      "thermostat_schedule": {
-        "name": "Thermostat schedule"
       }
     },
     "sensor": {
-      "setpoint": {
-        "name": "Setpoint"
-      },
       "cooling_setpoint": {
         "name": "Cooling setpoint"
       },
-      "heating_setpoint": {
-        "name": " Heating setpoint"
-      },
-      "temperature": {
-        "name": "Temperature"
-      },
-      "intended_boiler_temperature": {
-        "name": "Intended boiler temperature"
-      },
-      "temperature_difference": {
-        "name": "Temperature difference"
-      },
-      "outdoor_temperature": {
-        "name": "Outdoor temperature"
-      },
-      "outdoor_air_temperature": {
-        "name": "Outdoor air temperature"
-      },
-      "water_temperature": {
-        "name": "Water temperature"
       },
-      "return_temperature": {
-        "name": "Return temperature"
       },
       "electricity_consumed": {
         "name": "Electricity consumed"
       },
-      "electricity_produced": {
-        "name": "Electricity produced"
-      },
-      "electricity_consumed_point": {
-        "name": "Electricity consumed point"
-      },
-      "electricity_produced_point": {
-        "name": "Electricity produced point"
-      },
       "electricity_consumed_interval": {
         "name": "Electricity consumed interval"
       },
-      "electricity_consumed_peak_interval": {
-        "name": "Electricity consumed peak interval"
       },
       "electricity_consumed_off_peak_interval": {
-        "name": "Electricity consumed off peak interval"
-      },
-      "electricity_produced_interval": {
-        "name": "Electricity produced interval"
-      },
-      "electricity_produced_peak_interval": {
-        "name": "Electricity produced peak interval"
-      },
-      "electricity_produced_off_peak_interval": {
-        "name": "Electricity produced off peak interval"
       },
       "electricity_consumed_off_peak_point": {
-        "name": "Electricity consumed off peak point"
-      },
-      "electricity_consumed_peak_point": {
-        "name": "Electricity consumed peak point"
-      },
-      "electricity_consumed_off_peak_cumulative": {
-        "name": "Electricity consumed off peak cumulative"
       },
       "electricity_consumed_peak_cumulative": {
         "name": "Electricity consumed peak cumulative"
       },
-      "electricity_produced_off_peak_point": {
-        "name": "Electricity produced off peak point"
-      },
-      "electricity_produced_peak_point": {
-        "name": "Electricity produced peak point"
       },
-      "electricity_produced_off_peak_cumulative": {
-        "name": "Electricity produced off peak_cumulative"
       },
-      "electricity_produced_peak_cumulative": {
-        "name": "Electricity produced peak cumulative"
       },
       "electricity_phase_one_consumed": {
         "name": "Electricity phase one consumed"
       },
-      "electricity_phase_two_consumed": {
-        "name": "Electricity phase two consumed"
       },
       "electricity_phase_three_consumed": {
         "name": "Electricity phase three consumed"
       },
-      "electricity_phase_one_produced": {
-        "name": "Electricity phase one produced"
       },
       "electricity_phase_two_produced": {
         "name": "Electricity phase two produced"
       },
-      "electricity_phase_three_produced": {
-        "name": "Electricity phase three produced"
       },
-      "voltage_phase_one": {
-        "name": "Voltage phase one"
       },
-      "voltage_phase_two": {
-        "name": "Voltage phase two"
       },
-      "voltage_phase_three": {
-        "name": "Voltage phase three"
       },
-      "gas_consumed_interval": {
-        "name": "Gas consumed interval"
       },
       "gas_consumed_cumulative": {
         "name": "Gas consumed cumulative"
       },
-      "net_electricity_point": {
-        "name": "Net electricity point"
       },
-      "net_electricity_cumulative": {
-        "name": "Net electricity cumulative"
       },
-      "battery": {
-        "name": "Battery"
       },
-      "illuminance": {
-        "name": "Illuminance"
       },
       "modulation_level": {
         "name": "Modulation level"
       },
       "valve_position": {
         "name": "Valve position"
       },
-      "water_pressure": {
-        "name": "Water pressure"
       },
-      "relative_humidity": {
-        "name": "Relative humidity"
       },
-      "dhw_temperature": {
-        "name": "DHW temperature"
       },
-      "domestic_hot_water_setpoint": {
-        "name": "DHW setpoint"
       },
-      "maximum_boiler_temperature": {
-        "name": "Maximum boiler temperature setpoint"
       }
     },
     "switch": {
       "cooling_ena_switch": {
-        "name": "Cooling"
       },
       "dhw_cm_switch": {
         "name": "DHW comfort mode"
       },
       "lock": {
-        "name": "Lock"
       },
       "relay": {
         "name": "Relay"
       }
     }
   }
 }

 {
   "config": {
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_service%]",
+      "anna_with_adam": "Both Anna and Adam detected. Add your Adam instead of your Anna",
+      "not_the_same_smile": "The configured Smile ID does not match the Smile ID on the requested IP address."
     },
     "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
       "invalid_setup": "Add your Adam instead of your Anna, see the documentation",
       "response_error": "Invalid XML data, or error indication received",
+      "unknown": "[%key:common::config_flow::error::unknown%]",
       "unsupported": "Device with unsupported firmware"
     },
+    "step": {
+      "reconfigure": {
+        "data": {
+          "host": "[%key:common::config_flow::data::ip%]",
+          "port": "[%key:common::config_flow::data::port%]"
+        },
+        "data_description": {
+          "host": "[%key:component::plugwise::config::step::user::data_description::host%]",
+          "port": "[%key:component::plugwise::config::step::user::data_description::port%]"
+        },
+        "description": "Update configuration for {title}."
+      },
+      "user": {
+        "data": {
+          "host": "[%key:common::config_flow::data::ip%]",
+          "password": "Smile ID",
+          "port": "[%key:common::config_flow::data::port%]",
+          "username": "Smile username"
+        },
+        "data_description": {
+          "host": "The hostname or IP address of your Smile. You can find it in your router or the Plugwise app.",
+          "password": "The Smile ID printed on the label on the back of your Adam, Smile-T, or P1.",
+          "port": "By default your Smile uses port 80, normally you should not have to change this.",
+          "username": "Default is `smile`, or `stretch` for the legacy Stretch."
+        },
+        "description": "Please enter",
+        "title": "Connect to the Smile"
+      }
     }
   },
   "entity": {
       "cooling_enabled": {
         "name": "Cooling enabled"
       },
+      "cooling_state": {
+        "name": "[%key:component::climate::entity_component::_::state_attributes::hvac_action::state::cooling%]"
+      },
       "dhw_state": {
         "name": "DHW state"
       },
         "name": "Flame state"
       },
       "heating_state": {
+        "name": "[%key:component::climate::entity_component::_::state_attributes::hvac_action::state::heating%]"
       },
       "plugwise_notification": {
         "name": "Plugwise notification"
+      },
+      "secondary_boiler_state": {
+        "name": "Secondary boiler state"
+      }
+    },
+    "button": {
+      "reboot": {
+        "name": "[%key:common::action::reboot%]"
       }
     },
     "climate": {
       "plugwise": {
         "state_attributes": {
+          "available_schemas": {
+            "name": "Available schemas"
+          },
           "preset_mode": {
             "state": {
               "asleep": "Night",
+              "away": "[%key:common::state::not_home%]",
+              "home": "[%key:common::state::home%]",
               "no_frost": "Anti-frost",
               "vacation": "Vacation"
             }
+          },
+          "selected_schema": {
+            "name": "Selected schema"
           }
         }
       }
     },
     "number": {
+      "asleep_preset_cooling_temperature": {
+        "name": "Night preset cooling temperature"
+      },
+      "asleep_preset_temperature": {
+        "name": "Night preset temperature"
+      },
+      "away_preset_cooling_temperature": {
+        "name": "Away preset cooling temperature"
+      },
+      "away_preset_temperature": {
+        "name": "Away preset temperature"
+      },
+      "home_preset_cooling_temperature": {
+        "name": "Home preset cooling temperature"
+      },
+      "home_preset_temperature": {
+        "name": "Home preset temperature"
       },
       "max_dhw_temperature": {
         "name": "Domestic hot water setpoint"
+      },
+      "maximum_boiler_temperature": {
+        "name": "Maximum boiler temperature setpoint"
+      },
+      "no_frost_preset_cooling_temperature": {
+        "name": "Anti-frost preset cooling temperature"
+      },
+      "no_frost_preset_temperature": {
+        "name": "Anti-frost preset temperature"
+      },
+      "temperature_offset": {
+        "name": "Temperature offset"
+      },
+      "vacation_preset_cooling_temperature": {
+        "name": "Vacation preset cooling temperature"
+      },
+      "vacation_preset_temperature": {
+        "name": "Vacation preset temperature"
       }
     },
     "select": {
+      "select_dhw_mode": {
         "name": "DHW mode",
         "state": {
+          "auto": "[%key:common::state::auto%]",
           "boost": "Boost",
           "comfort": "Comfort",
+          "eco": "Eco",
+          "off": "[%key:common::state::off%]"
         }
       },
+      "select_gateway_mode": {
+        "name": "Gateway mode",
+        "state": {
+          "away": "Pause",
+          "full": "[%key:common::state::normal%]",
+          "vacation": "Vacation"
+        }
+      },
+      "select_regulation_mode": {
         "name": "Regulation mode",
         "state": {
           "bleeding_cold": "Bleeding cold",
           "bleeding_hot": "Bleeding hot",
+          "cooling": "[%key:component::climate::entity_component::_::state_attributes::hvac_action::state::cooling%]",
+          "heating": "[%key:component::climate::entity_component::_::state_attributes::hvac_action::state::heating%]",
+          "off": "[%key:common::state::off%]"
+        }
+      },
+      "select_schedule": {
+        "name": "Thermostat schedule",
+        "state": {
+          "off": "[%key:common::state::off%]"
         }
       },
+      "select_zone_profile": {
+        "name": "Zone profile",
+        "state": {
+          "active": "[%key:common::state::active%]",
+          "off": "[%key:common::state::off%]",
+          "passive": "Passive"
+        }
       }
     },
     "sensor": {
       "cooling_setpoint": {
         "name": "Cooling setpoint"
       },
+      "dhw_temperature": {
+        "name": "DHW temperature"
       },
+      "domestic_hot_water_setpoint": {
+        "name": "DHW setpoint"
       },
       "electricity_consumed": {
         "name": "Electricity consumed"
       },
       "electricity_consumed_interval": {
         "name": "Electricity consumed interval"
       },
+      "electricity_consumed_off_peak_cumulative": {
+        "name": "Electricity consumed off-peak cumulative"
       },
       "electricity_consumed_off_peak_interval": {
+        "name": "Electricity consumed off-peak interval"
       },
       "electricity_consumed_off_peak_point": {
+        "name": "Electricity consumed off-peak point"
       },
       "electricity_consumed_peak_cumulative": {
         "name": "Electricity consumed peak cumulative"
       },
+      "electricity_consumed_peak_interval": {
+        "name": "Electricity consumed peak interval"
       },
+      "electricity_consumed_peak_point": {
+        "name": "Electricity consumed peak point"
       },
+      "electricity_consumed_point": {
+        "name": "Electricity consumed point"
       },
       "electricity_phase_one_consumed": {
         "name": "Electricity phase one consumed"
       },
+      "electricity_phase_one_produced": {
+        "name": "Electricity phase one produced"
       },
       "electricity_phase_three_consumed": {
         "name": "Electricity phase three consumed"
       },
+      "electricity_phase_three_produced": {
+        "name": "Electricity phase three produced"
+      },
+      "electricity_phase_two_consumed": {
+        "name": "Electricity phase two consumed"
       },
       "electricity_phase_two_produced": {
         "name": "Electricity phase two produced"
       },
+      "electricity_produced": {
+        "name": "Electricity produced"
       },
+      "electricity_produced_interval": {
+        "name": "Electricity produced interval"
       },
+      "electricity_produced_off_peak_cumulative": {
+        "name": "Electricity produced off-peak cumulative"
       },
+      "electricity_produced_off_peak_interval": {
+        "name": "Electricity produced off-peak interval"
       },
+      "electricity_produced_off_peak_point": {
+        "name": "Electricity produced off-peak point"
+      },
+      "electricity_produced_peak_cumulative": {
+        "name": "Electricity produced peak cumulative"
+      },
+      "electricity_produced_peak_interval": {
+        "name": "Electricity produced peak interval"
+      },
+      "electricity_produced_peak_point": {
+        "name": "Electricity produced peak point"
+      },
+      "electricity_produced_point": {
+        "name": "Electricity produced point"
       },
       "gas_consumed_cumulative": {
         "name": "Gas consumed cumulative"
       },
+      "gas_consumed_interval": {
+        "name": "Gas consumed interval"
       },
+      "heating_setpoint": {
+        "name": "Heating setpoint"
       },
+      "intended_boiler_temperature": {
+        "name": "Intended boiler temperature"
       },
+      "maximum_boiler_temperature": {
+        "name": "Maximum boiler temperature"
       },
       "modulation_level": {
         "name": "Modulation level"
       },
+      "net_electricity_cumulative": {
+        "name": "Net electricity cumulative"
+      },
+      "net_electricity_point": {
+        "name": "Net electricity point"
+      },
+      "outdoor_air_temperature": {
+        "name": "Outdoor air temperature"
+      },
+      "outdoor_temperature": {
+        "name": "Outdoor temperature"
+      },
+      "return_temperature": {
+        "name": "Return temperature"
+      },
+      "setpoint": {
+        "name": "Setpoint"
+      },
+      "temperature_difference": {
+        "name": "Temperature difference"
+      },
       "valve_position": {
         "name": "Valve position"
       },
+      "voltage_phase_one": {
+        "name": "Voltage phase one"
       },
+      "voltage_phase_three": {
+        "name": "Voltage phase three"
       },
+      "voltage_phase_two": {
+        "name": "Voltage phase two"
       },
+      "water_pressure": {
+        "name": "Water pressure"
       },
+      "water_temperature": {
+        "name": "Water temperature"
       }
     },
     "switch": {
       "cooling_ena_switch": {
+        "name": "[%key:component::climate::entity_component::_::state_attributes::hvac_action::state::cooling%]"
       },
       "dhw_cm_switch": {
         "name": "DHW comfort mode"
       },
       "lock": {
+        "name": "[%key:component::lock::title%]"
       },
       "relay": {
         "name": "Relay"
       }
+    },
+    "water_heater": {
+      "dhw_temperature": {
+        "name": "Domestic hot water"
+      }
+    }
+  },
+  "exceptions": {
+    "authentication_failed": {
+      "message": "[%key:common::config_flow::error::invalid_auth%]"
+    },
+    "data_incomplete_or_missing": {
+      "message": "Data incomplete or missing."
+    },
+    "error_communicating_with_api": {
+      "message": "Error communicating with API: {error}."
+    },
+    "failed_to_connect": {
+      "message": "[%key:common::config_flow::error::cannot_connect%]"
+    },
+    "invalid_setup": {
+      "message": "Add your Adam instead of your Anna, see the documentation"
+    },
+    "response_error": {
+      "message": "[%key:component::plugwise::config::error::response_error%]"
+    },
+    "set_schedule_first": {
+      "message": "Failed setting HVACMode, set a schedule first."
+    },
+    "temperature_out_of_range": {
+      "message": "Temperature must be between {min_temp} and {max_temp} {temperature_unit}."
+    },
+    "unsupported_firmware": {
+      "message": "[%key:component::plugwise::config::error::unsupported%]"
+    }
+  },
+  "issues": {
+    "deprecated_dhw_cm_switch": {
+      "description": "The `{entity_id}` ({entity_name}) switch is deprecated and will be removed in Home Assistant 2027.5.0. It has been replaced by the **DHW mode** select, which provides the available modes for your heater.\n\nUpdate dashboards, templates, automations, and scripts to use the DHW mode select and choose the required mode. Then disable `{entity_id}` in Settings > Devices & services > Entities. Home Assistant will remove it after the next restart.",
+      "title": "The Plugwise DHW comfort switch is deprecated"
+    },
+    "deprecated_dhw_cm_switch_scripts": {
+      "description": "The `{entity_id}` ({entity_name}) switch is deprecated and will be removed in Home Assistant 2027.5.0. It has been replaced by the **DHW mode** select, which provides the available modes for your heater.\n\nIt is used in the following automations or scripts:\n{items}\n\nUpdate these automations or scripts to use the DHW mode select and choose the required mode, then disable `{entity_id}` in Settings > Devices & services > Entities. Home Assistant will remove it after the next restart.",
+      "title": "[%key:component::plugwise::issues::deprecated_dhw_cm_switch::title%]"
+    },
+    "deprecated_dhw_temperature": {
+      "description": "The `{entity_id}` ({entity_name}) number is deprecated and will be removed in Home Assistant 2027.5.0. Its setpoint is now provided by the **Domestic hot water** water heater entity.\n\nUpdate dashboards, templates, automations, and scripts to use the water heater entity and its set-temperature control. Then disable `{entity_id}` in Settings > Devices & services > Entities. Home Assistant will remove it after the next restart.",
+      "title": "The Plugwise DHW temperature number is deprecated"
+    },
+    "deprecated_dhw_temperature_scripts": {
+      "description": "The `{entity_id}` ({entity_name}) number is deprecated and will be removed in Home Assistant 2027.5.0. Its setpoint is now provided by the **Domestic hot water** water heater entity.\n\nIt is used in the following automations or scripts:\n{items}\n\nUpdate these automations or scripts to use the water heater entity and its set-temperature control, then disable `{entity_id}` in Settings > Devices & services > Entities. Home Assistant will remove it after the next restart.",
+      "title": "[%key:component::plugwise::issues::deprecated_dhw_temperature::title%]"
     }
   }
 }

/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/switch.py RENAMED Viewed

@@ -1,42 +1,103 @@
 """Plugwise Switch component for HomeAssistant."""
-from __future__ import annotations
-from typing import Any
-from homeassistant.components.switch import SwitchEntity
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-from .const import (
-    COORDINATOR,  # pw-beta
-    DOMAIN,
-    LOGGER,
 )
-from .coordinator import PlugwiseDataUpdateCoordinator
 from .entity import PlugwiseEntity
-from .models import PW_SWITCH_TYPES, PlugwiseSwitchEntityDescription
-from .util import plugwise_command
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: ConfigEntry,
-    async_add_entities: AddEntitiesCallback,
 ) -> None:
     """Set up the Smile switches from a config entry."""
-    coordinator = hass.data[DOMAIN][config_entry.entry_id][COORDINATOR]
-    entities: list[PlugwiseSwitchEntity] = []
-    for device_id, device in coordinator.data.devices.items():
-        if not (switches := device.get("switches")):
-            continue
-        for description in PW_SWITCH_TYPES:
-            if description.key not in switches:
                 continue
-            entities.append(PlugwiseSwitchEntity(coordinator, device_id, description))
-            LOGGER.debug("Add %s switch", description.key)
-    async_add_entities(entities)
 class PlugwiseSwitchEntity(PlugwiseEntity, SwitchEntity):
@@ -52,15 +113,17 @@
     ) -> None:
         """Set up the Plugwise API."""
         super().__init__(coordinator, device_id)
-        self.entity_description = description
         self._attr_unique_id = f"{device_id}-{description.key}"
     @property
     def is_on(self) -> bool:
         """Return True if entity is on."""
-        return self.entity_description.value_fn(self.device["switches"])
     @plugwise_command
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn the device on."""
         await self.coordinator.api.set_switch_state(
@@ -71,6 +134,7 @@
         )
     @plugwise_command
     async def async_turn_off(self, **kwargs: Any) -> None:
         """Turn the device off."""
         await self.coordinator.api.set_switch_state(
@@ -79,3 +143,17 @@
             self.entity_description.key,
             "off",
         )

 """Plugwise Switch component for HomeAssistant."""
+from dataclasses import dataclass
+from typing import Any, override
+from plugwise.constants import SwitchType
+from homeassistant.components.switch import (
+    SwitchDeviceClass,
+    SwitchEntity,
+    SwitchEntityDescription,
 )
+from homeassistant.const import EntityCategory, Platform
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import entity_registry as er
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from .coordinator import PlugwiseConfigEntry, PlugwiseDataUpdateCoordinator
 from .entity import PlugwiseEntity
+from .util import deprecate_entity, plugwise_command
+PARALLEL_UPDATES = 0
+@dataclass(frozen=True)
+class PlugwiseSwitchEntityDescription(SwitchEntityDescription):
+    """Describes Plugwise switch entity."""
+    key: SwitchType
+SWITCHES: tuple[PlugwiseSwitchEntityDescription, ...] = (
+    PlugwiseSwitchEntityDescription(
+        key="dhw_cm_switch",
+        translation_key="dhw_cm_switch",
+        entity_category=EntityCategory.CONFIG,
+    ),
+    PlugwiseSwitchEntityDescription(
+        key="lock",
+        translation_key="lock",
+        entity_category=EntityCategory.CONFIG,
+    ),
+    PlugwiseSwitchEntityDescription(
+        key="relay",
+        translation_key="relay",
+        device_class=SwitchDeviceClass.SWITCH,
+    ),
+    PlugwiseSwitchEntityDescription(
+        key="cooling_ena_switch",
+        translation_key="cooling_ena_switch",
+        entity_category=EntityCategory.CONFIG,
+    ),
+)
 async def async_setup_entry(
     hass: HomeAssistant,
+    entry: PlugwiseConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the Smile switches from a config entry."""
+    coordinator = entry.runtime_data
+    entity_registry = er.async_get(hass)
+    @callback
+    def _add_entities() -> None:
+        """Add Entities."""
+        if not coordinator.new_devices:
+            return
+        entities: list[SwitchEntity] = []
+        for device_id in coordinator.new_devices:
+            if not (switches := coordinator.data[device_id].get("switches")):
                 continue
+            for description in SWITCHES:
+                if description.key not in switches:
+                    continue
+                if description.key == "dhw_cm_switch":
+                    if not deprecate_entity(
+                        hass,
+                        entity_registry,
+                        async_on_unload=entry.async_on_unload,
+                        platform_domain=Platform.SWITCH,
+                        entity_unique_id=f"{device_id}-dhw_cm_switch",
+                        issue_id=f"deprecated_dhw_cm_switch_{device_id}",
+                        translation_key="deprecated_dhw_cm_switch",
+                    ):
+                        continue
+                    entities.append(
+                        PlugwiseDhwCmSwitchEntity(coordinator, device_id, description)
+                    )
+                else:
+                    entities.append(
+                        PlugwiseSwitchEntity(coordinator, device_id, description)
+                    )
+        async_add_entities(entities)
+    _add_entities()
+    entry.async_on_unload(coordinator.async_add_listener(_add_entities))
 class PlugwiseSwitchEntity(PlugwiseEntity, SwitchEntity):
     ) -> None:
         """Set up the Plugwise API."""
         super().__init__(coordinator, device_id)
         self._attr_unique_id = f"{device_id}-{description.key}"
+        self.entity_description = description
     @property
+    @override
     def is_on(self) -> bool:
         """Return True if entity is on."""
+        return self.device["switches"][self.entity_description.key]
     @plugwise_command
+    @override
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn the device on."""
         await self.coordinator.api.set_switch_state(
         )
     @plugwise_command
+    @override
     async def async_turn_off(self, **kwargs: Any) -> None:
         """Turn the device off."""
         await self.coordinator.api.set_switch_state(
             self.entity_description.key,
             "off",
         )
+class PlugwiseDhwCmSwitchEntity(PlugwiseSwitchEntity):
+    """Represent the deprecated DHW comfort switch."""
+    @override
+    async def async_turn_on(self, **kwargs: Any) -> None:
+        """Turn the deprecated DHW comfort switch on."""
+        await super().async_turn_on(**kwargs)
+    @override
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Turn the deprecated DHW comfort switch off."""
+        await super().async_turn_off(**kwargs)

/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/util.py RENAMED Viewed

@@ -1,21 +1,185 @@
 """Utilities for Plugwise."""
 from collections.abc import Awaitable, Callable, Coroutine
-from typing import Any, Concatenate, TypeVar
-from typing_extensions import ParamSpec
 from homeassistant.exceptions import HomeAssistantError
-from plugwise.exceptions import PlugwiseException
 from .entity import PlugwiseEntity
-_PlugwiseEntityT = TypeVar("_PlugwiseEntityT", bound=PlugwiseEntity)
-_R = TypeVar("_R")
-_P = ParamSpec("_P")
-def plugwise_command(
-    func: Callable[Concatenate[_PlugwiseEntityT, _P], Awaitable[_R]]
 ) -> Callable[Concatenate[_PlugwiseEntityT, _P], Coroutine[Any, Any, _R]]:
     """Decorate Plugwise calls that send commands/make changes to the device.
@@ -28,10 +192,14 @@
     ) -> _R:
         try:
             return await func(self, *args, **kwargs)
-        except PlugwiseException as error:
             raise HomeAssistantError(
-                f"Error communicating with API: {error}"
-            ) from error
         finally:
             await self.coordinator.async_request_refresh()

 """Utilities for Plugwise."""
 from collections.abc import Awaitable, Callable, Coroutine
+from typing import Any, Concatenate
+from plugwise.exceptions import PlugwiseException
+from homeassistant.components.automation import automations_with_entity
+from homeassistant.components.script import scripts_with_entity
+from homeassistant.core import CoreState, HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import entity_registry as er
+from homeassistant.helpers.issue_registry import (
+    IssueSeverity,
+    async_create_issue,
+    async_delete_issue,
+)
+from homeassistant.helpers.start import async_at_started
+from .const import DOMAIN
 from .entity import PlugwiseEntity
+# Version in which deprecated entities will be removed.
+DEPRECATED_REMOVAL_VERSION = "2027.5.0"
+def deprecate_entity(
+    hass: HomeAssistant,
+    entity_registry: er.EntityRegistry,
+    *,
+    async_on_unload: Callable[[Callable[[], None]], None],
+    platform_domain: str,
+    entity_unique_id: str,
+    issue_id: str,
+    translation_key: str,
+) -> bool:
+    """Handle deprecation of an entity that has been replaced.
+    Return True if the deprecated entity should still be set up, which is the
+    case while it exists in the entity registry. A repair issue informs the user
+    about the replacement and the removal date; when the entity is still used by
+    automations or scripts they are listed in the issue. The entity is removed
+    once the user disables it and nothing references it anymore. New
+    installations never create the entity.
+    """
+    entity_id = entity_registry.async_get_entity_id(
+        platform_domain, DOMAIN, entity_unique_id
+    )
+    if entity_id is None:
+        async_delete_issue(hass, DOMAIN, issue_id)
+        return False
+    entity_entry = entity_registry.async_get(entity_id)
+    if entity_entry is None:
+        async_delete_issue(hass, DOMAIN, issue_id)
+        return False
+    if hass.state is not CoreState.running:
+        _async_defer_deprecation_check(
+            hass,
+            entity_registry,
+            async_on_unload=async_on_unload,
+            platform_domain=platform_domain,
+            entity_unique_id=entity_unique_id,
+            issue_id=issue_id,
+            translation_key=translation_key,
+        )
+        return True
+    return _async_check_deprecated_entity(
+        hass,
+        entity_registry,
+        entity_id=entity_id,
+        issue_id=issue_id,
+        translation_key=translation_key,
+    )
+@callback
+def _async_check_deprecated_entity(
+    hass: HomeAssistant,
+    entity_registry: er.EntityRegistry,
+    *,
+    entity_id: str,
+    issue_id: str,
+    translation_key: str,
+) -> bool:
+    """Check whether a deprecated entity should remain in the registry."""
+    entity_entry = entity_registry.async_get(entity_id)
+    if entity_entry is None:
+        async_delete_issue(hass, DOMAIN, issue_id)
+        return False
+    items = _automations_and_scripts_using_entity(hass, entity_registry, entity_id)
+    if entity_entry.disabled and not items:
+        entity_registry.async_remove(entity_id)
+        async_delete_issue(hass, DOMAIN, issue_id)
+        return False
+    placeholders = {
+        "entity_id": entity_id,
+        "entity_name": entity_entry.name or entity_entry.original_name or entity_id,
+    }
+    if items:
+        translation_key = f"{translation_key}_scripts"
+        placeholders["items"] = "\n".join(items)
+    async_create_issue(
+        hass,
+        DOMAIN,
+        issue_id,
+        breaks_in_ha_version=DEPRECATED_REMOVAL_VERSION,
+        config_entry_id=entity_entry.config_entry_id,
+        is_fixable=False,
+        severity=IssueSeverity.WARNING,
+        translation_key=translation_key,
+        translation_placeholders=placeholders,
+    )
+    return True
+def _automations_and_scripts_using_entity(
+    hass: HomeAssistant,
+    entity_registry: er.EntityRegistry,
+    entity_id: str,
+) -> list[str]:
+    """Return markdown list items for automations and scripts."""
+    automations = automations_with_entity(hass, entity_id)
+    scripts = scripts_with_entity(hass, entity_id)
+    if not automations and not scripts:
+        return []
+    items: list[str] = []
+    for integration, used_entities in (
+        ("automation", automations),
+        ("script", scripts),
+    ):
+        for used_entity_id in used_entities:
+            if entry := entity_registry.async_get(used_entity_id):
+                items.append(
+                    f"- [{entry.original_name}](/config/{integration}/edit/{entry.unique_id})"
+                )
+            else:
+                items.append(f"- `{used_entity_id}`")
+    return items
+@callback
+def _async_defer_deprecation_check(
+    hass: HomeAssistant,
+    entity_registry: er.EntityRegistry,
+    *,
+    async_on_unload: Callable[[Callable[[], None]], None],
+    platform_domain: str,
+    entity_unique_id: str,
+    issue_id: str,
+    translation_key: str,
+) -> None:
+    """Recheck entity references once Home Assistant has started."""
+    @callback
+    def _async_recheck(_: HomeAssistant) -> None:
+        if entity_id := entity_registry.async_get_entity_id(
+            platform_domain, DOMAIN, entity_unique_id
+        ):
+            _async_check_deprecated_entity(
+                hass,
+                entity_registry,
+                entity_id=entity_id,
+                issue_id=issue_id,
+                translation_key=translation_key,
+            )
+        else:
+            async_delete_issue(hass, DOMAIN, issue_id)
+    async_on_unload(async_at_started(hass, _async_recheck))
+def plugwise_command[_PlugwiseEntityT: PlugwiseEntity, **_P, _R](
+    func: Callable[Concatenate[_PlugwiseEntityT, _P], Awaitable[_R]],
 ) -> Callable[Concatenate[_PlugwiseEntityT, _P], Coroutine[Any, Any, _R]]:
     """Decorate Plugwise calls that send commands/make changes to the device.
     ) -> _R:
         try:
             return await func(self, *args, **kwargs)
+        except PlugwiseException as err:
             raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="error_communicating_with_api",
+                translation_placeholders={
+                    "error": str(err),
+                },
+            ) from err
         finally:
             await self.coordinator.async_request_refresh()