Diff to HTML by rtfpessoa

Files changed (16) hide show

/home/runner/work/progress/progress/clones/beta/{ha-core/homeassistant/components → beta/custom_components}/plugwise/__init__.py +95 -34
/home/runner/work/progress/progress/clones/beta/{ha-core/homeassistant/components → beta/custom_components}/plugwise/binary_sensor.py +94 -35
/home/runner/work/progress/progress/clones/beta/{ha-core/homeassistant/components → beta/custom_components}/plugwise/button.py +17 -7
/home/runner/work/progress/progress/clones/beta/{ha-core/homeassistant/components → beta/custom_components}/plugwise/climate.py +108 -73
/home/runner/work/progress/progress/clones/beta/{ha-core/homeassistant/components → beta/custom_components}/plugwise/config_flow.py +133 -29
/home/runner/work/progress/progress/clones/beta/{ha-core/homeassistant/components → beta/custom_components}/plugwise/const.py +154 -39
/home/runner/work/progress/progress/clones/beta/{ha-core/homeassistant/components → beta/custom_components}/plugwise/coordinator.py +46 -21
/home/runner/work/progress/progress/clones/beta/{ha-core/homeassistant/components → beta/custom_components}/plugwise/entity.py +35 -16
/home/runner/work/progress/progress/clones/beta/{ha-core/homeassistant/components → beta/custom_components}/plugwise/icons.json +3 -0
/home/runner/work/progress/progress/clones/beta/{ha-core/homeassistant/components → beta/custom_components}/plugwise/manifest.json +4 -5
/home/runner/work/progress/progress/clones/beta/{ha-core/homeassistant/components → beta/custom_components}/plugwise/number.py +50 -37
/home/runner/work/progress/progress/clones/beta/{ha-core/homeassistant/components → beta/custom_components}/plugwise/select.py +39 -14
/home/runner/work/progress/progress/clones/beta/{ha-core/homeassistant/components → beta/custom_components}/plugwise/sensor.py +172 -101
/home/runner/work/progress/progress/clones/beta/{ha-core/homeassistant/components → beta/custom_components}/plugwise/switch.py +47 -60
/home/runner/work/progress/progress/clones/beta/{ha-core/homeassistant/components → beta/custom_components}/plugwise/util.py +11 -213
/home/runner/work/progress/progress/clones/beta/{ha-core/homeassistant/components → beta/custom_components}/plugwise/water_heater.py +20 -14

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

@@ -2,35 +2,63 @@
 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_device(
         config_entry_id=entry.entry_id,
-        device_info=dr.DeviceInfo(
-            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)
@@ -35,18 +63,25 @@
     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"
@@ -68,29 +103,55 @@
     # No migration needed
     return None
-def migrate_sensor_entities(
     hass: HomeAssistant,
     coordinator: PlugwiseDataUpdateCoordinator,
 ) -> 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"
         if entity_id := ent_reg.async_get_entity_id(
             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)

 from typing import Any
+from homeassistant.const import ATTR_NAME, CONF_TIMEOUT, Platform
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import (
+    config_validation as cv,
+    device_registry as dr,
+    entity_registry as er,
+)
+from homeassistant.helpers.typing import ConfigType
+from .const import (
+    CONF_REFRESH_INTERVAL,  # pw-beta options
+    DOMAIN,
+    LOGGER,
+    PLATFORMS,
+)
 from .coordinator import PlugwiseConfigEntry, PlugwiseDataUpdateCoordinator
+from .services import async_setup_services
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
+async def async_setup(hass: HomeAssistant, _config: ConfigType) -> bool:
+    """Set up my integration."""
+    async_setup_services(hass)
+    return True
+async def async_setup_entry(hass: HomeAssistant, entry: PlugwiseConfigEntry) -> bool:
+    """Set up Plugwise 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, cooldown, entry
+    )  # pw-beta - cooldown, update_interval as extra
     await coordinator.async_config_entry_first_refresh()
+    await async_migrate_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)
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+    entry.async_on_unload(entry.add_update_listener(update_listener))  # pw-beta options_flow
+    return True
+async def update_listener(
+    hass: HomeAssistant, entry: PlugwiseConfigEntry
+) -> 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: PlugwiseConfigEntry) -> bool:
+    """Unload Plugwise."""
+    return await hass.config_entries.async_unload_platforms(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"
     # No migration needed
     return None
+async def async_migrate_entities(
     hass: HomeAssistant,
     coordinator: PlugwiseDataUpdateCoordinator,
 ) -> None:
+    """Migrate entities if needed."""
     ent_reg = er.async_get(hass)
     for device_id, device in coordinator.data.items():
+        if device["dev_class"] not in ("climate", "heater_central"):
             continue
+        # Migrate opentherm_outdoor_temperature
+        # to opentherm_outdoor_air_temperature sensor
         old_unique_id = f"{device_id}-outdoor_temperature"
         if entity_id := ent_reg.async_get_entity_id(
             Platform.SENSOR, DOMAIN, old_unique_id
         ):
             new_unique_id = f"{device_id}-outdoor_air_temperature"
+            # Upstream remove LOGGER debug
             ent_reg.async_update_entity(entity_id, new_unique_id=new_unique_id)
+        # Migrate id-climate to id-device-name
+        old_unique_id = f"{device_id}-climate"
+        if entity_id := ent_reg.async_get_entity_id(
+            Platform.CLIMATE, DOMAIN, old_unique_id
+        ):
+            new_unique_id = f"{device_id}-{device[ATTR_NAME]}".lower()
+            # Upstream remove LOGGER debug
+            ent_reg.async_update_entity(entity_id, new_unique_id=new_unique_id)
+# pw-beta only - revert adding CONF_TIMEOUT to config_entry in v0.53.3
+async def async_migrate_entry(hass: HomeAssistant, entry: PlugwiseConfigEntry) -> bool:
+    """Migrate back to v1.1 config entry."""
+    if entry.version > 1:
+        # This means the user has downgraded from a future version
+        return False  #pragma: no cover
+    if entry.version == 1 and entry.minor_version == 2:
+        new_data = {**entry.data}
+        new_data.pop(CONF_TIMEOUT)
+        hass.config_entries.async_update_entry(
+            entry, data=new_data, minor_version=1, version=1
+        )
+    LOGGER.debug(
+        "Migration to version %s.%s successful",
+        entry.version,
+        entry.minor_version,
+    )
+    return True

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

@@ -6,6 +6,9 @@
 from plugwise.constants import BinarySensorType
 from homeassistant.components.binary_sensor import (
     BinarySensorDeviceClass,
     BinarySensorEntity,
@@ -15,11 +18,26 @@
 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
@@ -31,50 +49,51 @@
     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,
     ),
 )
@@ -85,7 +104,7 @@
     entry: PlugwiseConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
-    """Set up the Smile binary_sensors from a config entry."""
     coordinator = entry.runtime_data
     @callback
@@ -94,20 +113,40 @@
         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):
-    """Represent Smile Binary Sensors."""
     entity_description: PlugwiseBinarySensorEntityDescription
@@ -121,28 +160,48 @@
         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

 from plugwise.constants import BinarySensorType
+from homeassistant.components import (
+    persistent_notification,  # pw-beta Plugwise notifications
+)
 from homeassistant.components.binary_sensor import (
     BinarySensorDeviceClass,
     BinarySensorEntity,
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from .const import (
+    BATTERY_STATE,
+    BINARY_SENSORS,
+    COMPRESSOR_STATE,
+    COOLING_ENABLED,
+    COOLING_STATE,
+    DHW_STATE,
+    DOMAIN,
+    FLAME_STATE,
+    HEATING_STATE,
+    LOGGER,  # pw-beta
+    PLUGWISE_NOTIFICATION,
+    SECONDARY_BOILER_STATE,
+    SEVERITIES,
+)
+# Upstream
 from .coordinator import PlugwiseConfigEntry, PlugwiseDataUpdateCoordinator
 from .entity import PlugwiseEntity
 # Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
     key: BinarySensorType
+# Upstream PLUGWISE_BINARY_SENSORS
+PLUGWISE_BINARY_SENSORS: tuple[PlugwiseBinarySensorEntityDescription, ...] = (
     PlugwiseBinarySensorEntityDescription(
+        key=BATTERY_STATE,
         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,
     ),
 )
     entry: PlugwiseConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
+    """Set up Plugwise binary_sensors from a config entry."""
     coordinator = entry.runtime_data
     @callback
         if not coordinator.new_devices:
             return
+        # Upstream consts to HA
+        # async_add_entities(
+        #     PlugwiseBinarySensorEntity(coordinator, device_id, description)
+        #     for device_id in coordinator.new_devices
+        #     if (
+        #         binary_sensors := coordinator.data.devices[device_id].get(
+        #             BINARY_SENSORS
+        #         )
+        #     )
+        #     for description in PLUGWISE_BINARY_SENSORS
+        #     if description.key in binary_sensors
+        # )
+        # pw-beta alternative for debugging
+        entities: list[PlugwiseBinarySensorEntity] = []
+        for device_id in coordinator.new_devices:
+            device = coordinator.data[device_id]
+            if not (binary_sensors := device.get(BINARY_SENSORS)):
+                continue
+            for description in PLUGWISE_BINARY_SENSORS:
+                if description.key not in binary_sensors:
+                    continue
+                entities.append(PlugwiseBinarySensorEntity(coordinator, device_id, description))
+                LOGGER.debug(
+                    "Add %s %s binary sensor", device["name"], description.translation_key or description.key
+                )
+        async_add_entities(entities)
     _add_entities()
     entry.async_on_unload(coordinator.async_add_listener(_add_entities))
 class PlugwiseBinarySensorEntity(PlugwiseEntity, BinarySensorEntity):
+    """Set up Plugwise binary_sensors from a config entry."""
     entity_description: PlugwiseBinarySensorEntityDescription
         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
     @override
+    def is_on(self) -> bool | None:
         """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():
+                persistent_notification.async_create(
+                    self.hass, message, "Plugwise Notification:", f"{DOMAIN}.{notify_id}"
+                )
+        return self.device.get(BINARY_SENSORS, {}).get(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:  # Upstream const
             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
         gateway_id = self.coordinator.api.gateway_id
         if notify := self.coordinator.data[gateway_id]["notifications"]:
+            for notify_id, details in notify.items():  # pw-beta uses notify_id
                 for msg_type, msg in details.items():
                     msg_type = msg_type.lower()
                     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

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

@@ -7,7 +7,10 @@
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from .const import REBOOT
 from .coordinator import PlugwiseConfigEntry, PlugwiseDataUpdateCoordinator
 from .entity import PlugwiseEntity
 from .util import plugwise_command
@@ -20,14 +23,21 @@
     entry: PlugwiseConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
-    """Set up the Plugwise buttons from a ConfigEntry."""
     coordinator = entry.runtime_data
-    async_add_entities(
-        PlugwiseButtonEntity(coordinator, device_id)
-        for device_id in coordinator.data
-        if device_id == coordinator.api.gateway_id and coordinator.api.reboot
-    )
 class PlugwiseButtonEntity(PlugwiseEntity, ButtonEntity):

 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from .const import (
+    LOGGER,  # pw-betea
+    REBOOT,
+)
 from .coordinator import PlugwiseConfigEntry, PlugwiseDataUpdateCoordinator
 from .entity import PlugwiseEntity
 from .util import plugwise_command
     entry: PlugwiseConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
+    """Set up Plugwise buttons from a config entry."""
     coordinator = entry.runtime_data
+    # async_add_entities(
+    #     PlugwiseButtonEntity(coordinator, device_id)
+    #     for device_id in coordinator.data.devices
+    #     if device_id == gateway[GATEWAY_ID] and REBOOT in gateway
+    # )
+    # pw-beta alternative for debugging
+    entities: list[PlugwiseButtonEntity] = []
+    for device_id, device in coordinator.data.items():
+        if device_id == coordinator.api.gateway_id and coordinator.api.reboot:
+            entities.append(PlugwiseButtonEntity(coordinator, device_id))
+            LOGGER.debug("Add %s reboot button", device["name"])
+    async_add_entities(entities)
 class PlugwiseButtonEntity(PlugwiseEntity, ButtonEntity):

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

@@ -12,13 +12,39 @@
     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
@@ -63,27 +89,32 @@
     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))
@@ -93,7 +124,7 @@
     """Representation of a Plugwise thermostat."""
     _attr_name = None
-    _attr_native_temperature_unit = UnitOfTemperature.CELSIUS
     _attr_translation_key = DOMAIN
     def __init__(
@@ -103,21 +134,25 @@
     ) -> 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
             )
@@ -125,15 +160,15 @@
             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
@@ -141,15 +176,12 @@
         """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
@@ -157,70 +189,76 @@
     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)
@@ -231,19 +269,19 @@
     @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
@@ -252,7 +290,7 @@
     @override
     def preset_mode(self) -> str | None:
         """Return the current preset mode."""
-        return self.device.get("active_preset")
     @plugwise_command
     @override
@@ -260,11 +298,13 @@
         """Set new target temperature."""
         data: dict[str, Any] = {}
         if ATTR_TEMPERATURE in kwargs:
-            data["setpoint"] = kwargs.get(ATTR_TEMPERATURE)
         if ATTR_TARGET_TEMP_HIGH in kwargs:
-            data["setpoint_high"] = kwargs.get(ATTR_TARGET_TEMP_HIGH)
         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)
@@ -272,7 +312,7 @@
         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.
         """
@@ -286,6 +326,7 @@
     @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
@@ -305,9 +346,7 @@
             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
@@ -315,9 +354,7 @@
             # 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)
@@ -327,9 +364,7 @@
         # 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

     HVACAction,
     HVACMode,
 )
+from homeassistant.const import (
+    ATTR_NAME,
+    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 (
+    ACTIVE_PRESET,
+    AVAILABLE_SCHEDULES,
+    CLIMATE_MODE,
+    CONTROL_STATE,
+    DEV_CLASS,
+    DOMAIN,
+    LOCATION,
+    LOGGER,
+    LOWER_BOUND,
+    MASTER_THERMOSTATS,
+    REGULATION_MODES,
+    RESOLUTION,
+    SELECT_REGULATION_MODE,
+    SENSORS,
+    TARGET_TEMP,
+    TARGET_TEMP_HIGH,
+    TARGET_TEMP_LOW,
+    THERMOSTAT,
+    UPPER_BOUND,
+)
 from .coordinator import PlugwiseConfigEntry, PlugwiseDataUpdateCoordinator
 from .entity import PlugwiseEntity
 from .util import plugwise_command
     entry: PlugwiseConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
+    """Set up Plugwise thermostats from a config entry."""
     coordinator = entry.runtime_data
     @callback
     def _add_entities() -> None:
+        """Add Entities during init and runtime."""
         if not coordinator.new_devices:
             return
+        entities: list[PlugwiseClimateEntity] = []
+        gateway_name = coordinator.api.smile.name
+        for device_id in coordinator.new_devices:
+            device = coordinator.data[device_id]
+            if gateway_name == "Adam":
+                if device[DEV_CLASS] == "climate":
+                    entities.append(
+                        PlugwiseClimateEntity(coordinator, device_id)
+                    )
+                    LOGGER.debug("Add climate %s", device[ATTR_NAME])
+            elif device[DEV_CLASS] in MASTER_THERMOSTATS:
+                entities.append(
+                    PlugwiseClimateEntity(coordinator, device_id)
+                )
+                LOGGER.debug("Add climate %s", device[ATTR_NAME])
+        async_add_entities(entities)
     _add_entities()
     entry.async_on_unload(coordinator.async_add_listener(_add_entities))
     """Representation of a Plugwise thermostat."""
     _attr_name = None
+    _attr_temperature_unit = UnitOfTemperature.CELSIUS
     _attr_translation_key = DOMAIN
     def __init__(
     ) -> None:
         """Set up the Plugwise API."""
         super().__init__(coordinator, device_id)
+        entity_name = f"{self.device[ATTR_NAME]}".lower()
+        self._attr_unique_id = f"{device_id}-{entity_name}"
         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
             )
             self._attr_supported_features |= (
                 ClimateEntityFeature.TURN_OFF | ClimateEntityFeature.TURN_ON
             )
+        if presets := self.device.get("preset_modes", None):  # can be NONE
             self._attr_supported_features |= ClimateEntityFeature.PRESET_MODE
+        self._attr_preset_modes = presets
+        self._attr_max_temp = min(self.device.get(THERMOSTAT, {}).get(UPPER_BOUND, 35.0), 35.0)
+        self._attr_min_temp = self.device.get(THERMOSTAT, {}).get(LOWER_BOUND, 0.0)
         # Ensure we don't drop below 0.1
         self._attr_target_temperature_step = max(
+            self.device.get(THERMOSTAT, {}).get(RESOLUTION, 0.5), 0.1
         )
     @override
         """Run when entity about to be added."""
         await super().async_added_to_hass()
+        extra_data = await self.async_get_last_extra_data()
+        if extra_data is not None:
+            data = extra_data.as_dict()
+            self._last_active_schedule = data.get("last_active_schedule") or STATE_OFF
             self._previous_action_mode = (
+                data.get("previous_action_mode") or HVACAction.HEATING.value
             )
     @property
     def extra_restore_state_data(self) -> PlugwiseClimateExtraStoredData:
         """Return text specific state data to be restored."""
         return PlugwiseClimateExtraStoredData(
+            self._last_active_schedule,
+            self._previous_action_mode,
         )
     @property
     @override
+    def current_temperature(self) -> float | None:
         """Return the current temperature."""
+        return self.device.get(SENSORS, {}).get(ATTR_TEMPERATURE)
     @property
     @override
+    def target_temperature(self) -> float | None:
         """Return the temperature we try to reach.
         Connected to the HVACMode combination of AUTO-HEAT.
         """
+        return self.device.get(THERMOSTAT, {}).get(TARGET_TEMP)
     @property
     @override
+    def target_temperature_high(self) -> float | None:
         """Return the temperature we try to reach in case of cooling.
         Connected to the HVACMode combination of AUTO-HEAT_COOL.
         """
+        return self.device.get(THERMOSTAT, {}).get(TARGET_TEMP_HIGH)
     @property
     @override
+    def target_temperature_low(self) -> float | None:
         """Return the heating temperature we try to reach in case of heating.
         Connected to the HVACMode combination AUTO-HEAT_COOL.
         """
+        return self.device.get(THERMOSTAT, {}).get(TARGET_TEMP_LOW)
     @property
     @override
     def hvac_mode(self) -> HVACMode:
         """Return HVAC operation ie. auto, cool, heat, heat_cool, or off mode."""
+        mode = self.device.get(CLIMATE_MODE)
+        if mode is None:
+            return HVACMode.HEAT  # pragma: no cover
+        try:
+            hvac = HVACMode(mode)
+        except ValueError:  # pragma: no cover
+            return HVACMode.HEAT  # pragma: no cover
+        if hvac not in self.hvac_modes:
+            return HVACMode.HEAT  # pragma: no cover
+        return hvac
     @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)
     @property
     @override
+    def hvac_action(self) -> HVACAction:  # pw-beta add to Core
         """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
     @override
     def preset_mode(self) -> str | None:
         """Return the current preset mode."""
+        return self.device.get(ACTIVE_PRESET)
     @plugwise_command
     @override
         """Set new target temperature."""
         data: dict[str, Any] = {}
         if ATTR_TEMPERATURE in kwargs:
+            data[TARGET_TEMP] = kwargs.get(ATTR_TEMPERATURE)
         if ATTR_TARGET_TEMP_HIGH in kwargs:
+            data[TARGET_TEMP_HIGH] = kwargs.get(ATTR_TARGET_TEMP_HIGH)
         if ATTR_TARGET_TEMP_LOW in kwargs:
+            data[TARGET_TEMP_LOW] = kwargs.get(ATTR_TARGET_TEMP_LOW)
+        # Upstream removed input-valid check
         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.
         The function inputs are limited to the HVACModes HEAT and COOL.
         """
     @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
             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)
         # 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

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

@@ -1,5 +1,8 @@
 """Config flow for Plugwise integration."""
 import logging
 from typing import Any, Self, override
@@ -12,9 +15,16 @@
     ResponseError,
     UnsupportedDeviceError,
 )
-import probatio
-from homeassistant.config_entries import SOURCE_USER, ConfigFlow, ConfigFlowResult
 from homeassistant.const import (
     ATTR_CONFIGURATION_URL,
     CONF_BASE,
@@ -22,11 +32,16 @@
     CONF_NAME,
     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,
@@ -30,22 +45,35 @@
 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,
@@ -53,21 +81,31 @@
 )
-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:
@@ -101,7 +139,7 @@
         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"
@@ -117,9 +155,10 @@
     """Handle a config flow for Plugwise Smile."""
     VERSION = 1
     discovery_info: ZeroconfServiceInfo | None = None
-    product: str = UNKNOWN_SMILE
     _username: str = DEFAULT_USERNAME
     @override
@@ -129,17 +168,21 @@
         """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_PORT: discovery_info.port,
                         CONF_USERNAME: config_entry.data[CONF_USERNAME],
-                        CONF_PASSWORD: config_entry.data[CONF_PASSWORD],
                     },
                 )
             except Exception:  # noqa: BLE001
@@ -152,12 +195,6 @@
                     }
                 )
-        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:
@@ -167,18 +204,20 @@
         # 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": {CONF_NAME: _name},
                 ATTR_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."""
@@ -192,6 +231,7 @@
         return False
     @override
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
@@ -209,18 +249,19 @@
             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:
@@ -230,7 +271,7 @@
         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),
@@ -241,8 +282,7 @@
             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(
@@ -259,3 +299,67 @@
             description_placeholders={"title": reconfigure_entry.title},
             errors=errors,
         )

 """Config flow for Plugwise integration."""
+# pylint: disable=home-assistant-config-flow-polling-field
+from copy import deepcopy
 import logging
 from typing import Any, Self, override
     ResponseError,
     UnsupportedDeviceError,
 )
+from homeassistant.config_entries import (
+    SOURCE_USER,
+    ConfigEntry,
+    ConfigFlow,
+    ConfigFlowResult,
+    OptionsFlow,
+)
+# Upstream
 from homeassistant.const import (
     ATTR_CONFIGURATION_URL,
     CONF_BASE,
     CONF_NAME,
     CONF_PASSWORD,
     CONF_PORT,
+    CONF_SCAN_INTERVAL,
     CONF_USERNAME,
 )
+# Upstream
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo
+import probatio
 from .const import (
     ANNA_WITH_ADAM,
 from .const import (
     ANNA_WITH_ADAM,
+    CONF_REFRESH_INTERVAL,  # pw-beta option
     DEFAULT_PORT,
+    DEFAULT_UPDATE_INTERVAL,
     DEFAULT_USERNAME,
     DOMAIN,
     FLOW_SMILE,
     FLOW_STRETCH,
+    INIT,
+    P1_UPDATE_INTERVAL,
     SMILE,
     SMILE_OPEN_THERM,
     SMILE_THERMO,
     STRETCH,
     STRETCH_USERNAME,
+    THERMOSTAT,
+    TITLE_PLACEHOLDERS,
+    VERSION,
     ZEROCONF_MAP,
 )
+# Upstream
+from .coordinator import PlugwiseDataUpdateCoordinator
+type PlugwiseConfigEntry = ConfigEntry[PlugwiseDataUpdateCoordinator]
 _LOGGER = logging.getLogger(__name__)
+# Upstream basically the whole file (excluding the pw-beta options)
 SMILE_RECONF_SCHEMA = probatio.Schema(
     {
         probatio.Required(CONF_HOST): str,
 )
+def smile_user_schema(cf_input: ZeroconfServiceInfo | dict[str, Any] | None) -> probatio.Schema:
     """Generate base schema for gateways."""
+    if not cf_input:  # no discovery- or user-input available
+        return probatio.Schema(
             {
                 probatio.Required(CONF_HOST): str,
+                probatio.Required(CONF_PASSWORD): str,
                 probatio.Required(CONF_USERNAME, default=SMILE): probatio.In(
                     {SMILE: FLOW_SMILE, STRETCH: FLOW_STRETCH}
                 ),
             }
         )
+    if isinstance(cf_input, ZeroconfServiceInfo):
+        return probatio.Schema({probatio.Required(CONF_PASSWORD): str})
+    return probatio.Schema(
+        {
+            probatio.Required(CONF_HOST, default=cf_input[CONF_HOST]): str,
+            probatio.Required(CONF_PASSWORD, default=cf_input[CONF_PASSWORD]): str,
+            probatio.Required(CONF_USERNAME, default=cf_input[CONF_USERNAME]): probatio.In(
+                {SMILE: FLOW_SMILE, STRETCH: FLOW_STRETCH}
+            ),
+        }
+    )
 async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> Smile:
         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"
     """Handle a config flow for Plugwise Smile."""
     VERSION = 1
+    MINOR_VERSION = 1
     discovery_info: ZeroconfServiceInfo | None = None
+    product: str = "Unknown Smile"
     _username: str = DEFAULT_USERNAME
     @override
         """Prepare configuration for a discovered Plugwise Smile."""
         self.discovery_info = discovery_info
         _properties = discovery_info.properties
+        _version = _properties.get(VERSION, "n/a")
+        self.product = _product = _properties.get("product", "Unknown Smile")
         unique_id = discovery_info.hostname.split(".")[0].split("-")[0]
+        if DEFAULT_USERNAME not in unique_id:
+            self._username = STRETCH_USERNAME
         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],
                         CONF_PORT: discovery_info.port,
                         CONF_USERNAME: config_entry.data[CONF_USERNAME],
                     },
                 )
             except Exception:  # noqa: BLE001
                     }
                 )
         # 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:
         # 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")
+        _name = f"{ZEROCONF_MAP.get(_product, _product)} v{_version}"
         self.context.update(
             {
+                TITLE_PLACEHOLDERS: {CONF_NAME: _name},
                 ATTR_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."""
         return False
     @override
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
             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)
+        configure_input = self.discovery_info or user_input
         return self.async_show_form(
             step_id=SOURCE_USER,
+            data_schema=smile_user_schema(configure_input),
             errors=errors,
         )
     async def async_step_reconfigure(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         reconfigure_entry = self._get_reconfigure_entry()
         if user_input:
+            # Redefine ingest existing username and password
             full_input = {
                 CONF_HOST: user_input.get(CONF_HOST),
                 CONF_PORT: reconfigure_entry.data.get(CONF_PORT),
             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(
             description_placeholders={"title": reconfigure_entry.title},
             errors=errors,
         )
+    @callback
+    @override
+    @staticmethod
+    def async_get_options_flow(
+        config_entry: PlugwiseConfigEntry,
+    ) -> PlugwiseOptionsFlowHandler:  # pw-beta options
+        """Get the options flow for this handler."""
+        return PlugwiseOptionsFlowHandler(config_entry)
+# pw-beta - change the scan-interval via CONFIGURE
+# pw-beta - change the frontend refresh interval via CONFIGURE
+class PlugwiseOptionsFlowHandler(OptionsFlow):  # pw-beta options
+    """Plugwise option flow."""
+    def __init__(self, config_entry: ConfigEntry) -> None:
+        """Initialize options flow."""
+        self.options = deepcopy(dict(config_entry.options))
+    def _create_options_schema(self, coordinator: PlugwiseDataUpdateCoordinator) -> probatio.Schema:
+        interval = DEFAULT_UPDATE_INTERVAL
+        if coordinator.api.smile.type == "power":
+            interval = P1_UPDATE_INTERVAL
+        schema = {
+            probatio.Optional(
+                CONF_SCAN_INTERVAL,
+                default=self.options.get(CONF_SCAN_INTERVAL, interval.seconds),
+            ): probatio.All(cv.positive_int, probatio.Clamp(min=10)),
+        }  # pw-beta
+        if coordinator.api.smile.type == THERMOSTAT:
+            schema.update({
+                probatio.Optional(
+                    CONF_REFRESH_INTERVAL,
+                    default=self.options.get(CONF_REFRESH_INTERVAL, 1.5),
+                ): probatio.All(probatio.Coerce(float), probatio.Range(min=1.5, max=10.0)),
+            })  # pw-beta
+        return probatio.Schema(schema)
+    async def async_step_none(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:  # 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.options)
+        return self.async_show_form(step_id="none")
+    async def async_step_init(self, user_input: dict[str, Any] | None = None) -> ConfigFlowResult:
+        """Manage the Plugwise options."""
+        if not self.config_entry.data.get(CONF_HOST):
+            return await self.async_step_none(user_input)  # pragma: no cover
+        if user_input is not None:
+            return self.async_create_entry(title="", data=user_input)
+        coordinator = self.config_entry.runtime_data
+        return self.async_show_form(
+            step_id=INIT,
+            data_schema=self._create_options_schema(coordinator)
+        )

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

@@ -6,30 +6,160 @@
 from homeassistant.const import Platform
 DOMAIN: Final = "plugwise"
 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,
@@ -40,6 +170,18 @@
     Platform.SWITCH,
     Platform.WATER_HEATER,
 ]
 ZEROCONF_MAP: Final[dict[str, str]] = {
     "smile": "Smile P1",
     "smile_thermo": "Smile Anna",
@@ -54,14 +196,13 @@
     "dhw_temperature",
     "temperature_offset",
 ]
 type SelectType = Literal[
     "dhw_mode",
     "select_dhw_mode",
     "select_gateway_mode",
     "select_regulation_mode",
     "select_schedule",
-    "select_zone_profile",
 ]
 type SelectOptionsType = Literal[
     "available_schedules",
@@ -71,29 +212,3 @@
     "zone_profiles",
 ]
 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"

 from homeassistant.const import Platform
+# Upstream basically the whole file excluding pw-beta options
 DOMAIN: Final = "plugwise"
 LOGGER = logging.getLogger(__package__)
 API: Final = "api"
+COORDINATOR: Final = "coordinator"
+CONFIG_ENTRY: Final = "config_entry"  # pw-beta service
+CONF_HOMEKIT_EMULATION: Final = "homekit_emulation"  # pw-beta options
+CONF_REFRESH_INTERVAL: Final = "refresh_interval"  # pw-beta options
+CONF_MANUAL_PATH: Final = "Enter Manually"
 GATEWAY: Final = "gateway"
 LOCATION: Final = "location"
+MAC_ADDRESS: Final = "mac_address"
 REBOOT: Final = "reboot"
 SMILE: Final = "smile"
 STRETCH: Final = "stretch"
 STRETCH_USERNAME: Final = "stretch"
+SWITCH_GROUPS: Final[tuple[str, str]] = ("report", "switching")
+UNIQUE_IDS: Final = "unique_ids"
+WIFI_MAC_ADDRESS: Final = "wifi_mac_address"
+ZIGBEE_MAC_ADDRESS: Final = "zigbee_mac_address"
+# Binary Sensor constants
+BINARY_SENSORS: Final = "binary_sensors"
+BATTERY_STATE: Final = "low_battery"
+COMPRESSOR_STATE: Final = "compressor_state"
+COOLING_ENABLED: Final = "cooling_enabled"
+COOLING_STATE: Final = "cooling_state"
+DHW_STATE: Final = "dhw_state"
+FLAME_STATE: Final = "flame_state"
+HEATING_STATE: Final = "heating_state"
+PLUGWISE_NOTIFICATION: Final = "plugwise_notification"
+SECONDARY_BOILER_STATE: Final = "secondary_boiler_state"
+# Climate constants
+ACTIVE_PRESET: Final = "active_preset"
+CLIMATE_MODE: Final = "climate_mode"
+CONTROL_STATE: Final = "control_state"
+COOLING_PRESENT: Final ="cooling_present"
+DEV_CLASS: Final = "dev_class"
+NONE : Final = "None"
+TARGET_TEMP: Final = "setpoint"
+TARGET_TEMP_HIGH: Final = "setpoint_high"
+TARGET_TEMP_LOW: Final = "setpoint_low"
+THERMOSTAT: Final = "thermostat"
+# Config_flow constants
+ANNA_WITH_ADAM: Final = "anna_with_adam"
+CONTEXT: Final = "context"
+FLOW_ID: Final = "flow_id"
+FLOW_NET: Final = "Network: Smile/Stretch"
+FLOW_SMILE: Final = "Smile (Adam/Anna/P1)"
+FLOW_STRETCH: Final = "Stretch (Stretch)"
+FLOW_TYPE: Final = "flow_type"
+INIT: Final = "init"
+PRODUCT: Final = "product"
+SMILE_OPEN_THERM: Final = "smile_open_therm"
+SMILE_THERMO: Final = "smile_thermo"
+TITLE_PLACEHOLDERS: Final = "title_placeholders"
+VERSION: Final = "version"
+# Entity constants
+AVAILABLE: Final = "available"
+FIRMWARE: Final = "firmware"
+HARDWARE: Final = "hardware"
+MODEL: Final = "model"
+MODEL_ID: Final = "model_id"
+VENDOR: Final = "vendor"
+# Number constants
+BOILER_TEMP: Final = "boiler_temperature"
+LOWER_BOUND: Final = "lower_bound"
+RESOLUTION: Final = "resolution"
+TEMPERATURE_OFFSET: Final = "temperature_offset"
 UPPER_BOUND: Final = "upper_bound"
+# Sensor constants
+DHW_SETPOINT: Final = "domestic_hot_water_setpoint"
+EL_CONSUMED: Final = "electricity_consumed"
+EL_CONS_INTERVAL: Final = "electricity_consumed_interval"
+EL_CONS_OP_CUMULATIVE: Final = "electricity_consumed_off_peak_cumulative"
+EL_CONS_OP_INTERVAL: Final = "electricity_consumed_off_peak_interval"
+EL_CONS_OP_POINT: Final = "electricity_consumed_off_peak_point"
+EL_CONS_P_CUMULATIVE: Final = "electricity_consumed_peak_cumulative"
+EL_CONS_P_INTERVAL: Final = "electricity_consumed_peak_interval"
+EL_CONS_P_POINT: Final = "electricity_consumed_peak_point"
+EL_CONS_POINT: Final = "electricity_consumed_point"
+EL_PH1_CONSUMED: Final = "electricity_phase_one_consumed"
+EL_PH2_CONSUMED: Final = "electricity_phase_two_consumed"
+EL_PH3_CONSUMED: Final = "electricity_phase_three_consumed"
+EL_PH1_PRODUCED: Final = "electricity_phase_one_produced"
+EL_PH2_PRODUCED: Final = "electricity_phase_two_produced"
+EL_PH3_PRODUCED: Final = "electricity_phase_three_produced"
+EL_PRODUCED: Final = "electricity_produced"
+EL_PROD_INTERVAL: Final = "electricity_produced_interval"
+EL_PROD_OP_CUMULATIVE: Final = "electricity_produced_off_peak_cumulative"
+EL_PROD_OP_INTERVAL: Final = "electricity_produced_off_peak_interval"
+EL_PROD_OP_POINT: Final = "electricity_produced_off_peak_point"
+EL_PROD_P_CUMULATIVE: Final = "electricity_produced_peak_cumulative"
+EL_PROD_P_INTERVAL: Final = "electricity_produced_peak_interval"
+EL_PROD_P_POINT: Final = "electricity_produced_peak_point"
+EL_PROD_POINT: Final = "electricity_produced_point"
+GAS_CONS_CUMULATIVE: Final = "gas_consumed_cumulative"
+GAS_CONS_INTERVAL: Final = "gas_consumed_interval"
+INTENDED_BOILER_TEMP: Final = "intended_boiler_temperature"
+MOD_LEVEL: Final = "modulation_level"
+NET_EL_POINT: Final = "net_electricity_point"
+NET_EL_CUMULATIVE: Final = "net_electricity_cumulative"
+OUTDOOR_AIR_TEMP: Final = "outdoor_air_temperature"
+OUTDOOR_TEMP: Final = "outdoor_temperature"
+RETURN_TEMP: Final = "return_temperature"
+SENSORS: Final = "sensors"
+TEMP_DIFF: Final = "temperature_difference"
+VALVE_POS: Final = "valve_position"
+VOLTAGE_PH1: Final = "voltage_phase_one"
+VOLTAGE_PH2: Final = "voltage_phase_two"
+VOLTAGE_PH3: Final = "voltage_phase_three"
+WATER_TEMP: Final = "water_temperature"
+WATER_PRESSURE: Final = "water_pressure"
+# Select constants
+AVAILABLE_SCHEDULES: Final = "available_schedules"
+DHW_MODE: Final = "dhw_mode"
+DHW_MODES: Final = "dhw_modes"
+GATEWAY_MODES: Final = "gateway_modes"
+REGULATION_MODES: Final = "regulation_modes"
+ZONE_PROFILES: Final = "zone_profiles"
+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"
+# Switch constants
+DHW_CM_SWITCH: Final = "dhw_cm_switch"
+LOCK: Final = "lock"
+MEMBERS: Final ="members"
+RELAY: Final = "relay"
+COOLING_ENA_SWITCH: Final ="cooling_ena_switch"
+SWITCHES: Final = "switches"
+# Water_heater constants
+DHW_TEMP: Final = "dhw_temperature"
+# Default directives
+DEFAULT_PORT: Final[int] = 80
+DEFAULT_TIMEOUT: Final[int] = 30
+DEFAULT_UPDATE_INTERVAL: Final = timedelta(seconds=60)
+DEFAULT_USERNAME: Final = "smile"
+P1_UPDATE_INTERVAL: Final = timedelta(seconds=10)
+# --- Const for Plugwise Smile and Stretch
 PLATFORMS: Final[list[str]] = [
     Platform.BINARY_SENSOR,
     Platform.BUTTON,
     Platform.SWITCH,
     Platform.WATER_HEATER,
 ]
+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",
     "dhw_temperature",
     "temperature_offset",
 ]
 type SelectType = Literal[
     "dhw_mode",
     "select_dhw_mode",
     "select_gateway_mode",
     "select_regulation_mode",
     "select_schedule",
+    "select_zone_profile"
 ]
 type SelectOptionsType = Literal[
     "available_schedules",
     "zone_profiles",
 ]
 type WaterHeaterType = Literal["dhw_temperature"]

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

@@ -1,8 +1,8 @@
 """DataUpdateCoordinator for Plugwise."""
 from typing import override
-from packaging.version import Version
 from plugwise import GwEntityData, Smile
 from plugwise.exceptions import (
     ConnectionFailedError,
@@ -15,21 +15,29 @@
 )
 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]
@@ -40,29 +48,36 @@
     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
@@ -78,8 +93,15 @@
         """
         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:
@@ -133,25 +155,27 @@
                 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)
@@ -175,14 +199,15 @@
             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 (

 """DataUpdateCoordinator for Plugwise."""
+from datetime import timedelta
 from typing import override
 from plugwise import GwEntityData, Smile
 from plugwise.exceptions import (
     ConnectionFailedError,
 )
 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 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 packaging.version import Version
 from .const import (
     DEFAULT_UPDATE_INTERVAL,
+    DEV_CLASS,
     DOMAIN,
+    FIRMWARE,
     LOGGER,
     P1_UPDATE_INTERVAL,
+    SWITCH_GROUPS,
 )
 type PlugwiseConfigEntry = ConfigEntry[PlugwiseDataUpdateCoordinator]
     config_entry: PlugwiseConfigEntry
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        cooldown: float,
+        config_entry: PlugwiseConfigEntry,
+    ) -> None:  # pw-beta cooldown
         """Initialize the coordinator."""
         super().__init__(
             hass,
             LOGGER,
             config_entry=config_entry,
             name=DOMAIN,
+            # Core directly updates from const's DEFAULT_SCAN_INTERVAL
+            # Upstream check correct progress for adjusting
             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=cooldown,
                 immediate=False,
             ),
         )
         self.api = Smile(
             host=self.config_entry.data[CONF_HOST],
             password=self.config_entry.data[CONF_PASSWORD],
+            port=self.config_entry.data[CONF_PORT],
+            username=self.config_entry.data[CONF_USERNAME],
             websession=async_get_clientsession(hass, verify_ssl=False),
         )
         self._connected: bool = False
         """
         version = await self.api.connect()
         self._connected = isinstance(version, Version)
+        if self._connected:
+            if self.api.smile.type == "power":
+                self.update_interval = P1_UPDATE_INTERVAL
+            if (custom_time := self.config_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
     @override
     async def _async_setup(self) -> None:
                 translation_key="unsupported_firmware",
             ) from err
+        LOGGER.debug("%s data: %s", self.api.smile.name, data)
         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."""
+        # Block switch-groups, use HA group helper instead to create switch-groups
+        for device_id, device in data.copy().items():
+            if device.get(DEV_CLASS) in SWITCH_GROUPS:
+                data.pop(device_id)
+        # Collect new or removed devices,
+        # 'new_devices' contains all devices present in 'data' at init ('self._current_devices' is empty)
+        # this is required for the initialization of the available platform entities.
         set_of_data = set(data)
         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)
             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 (

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

@@ -2,7 +2,7 @@
 from typing import override
-from plugwise import GwEntityData
 from homeassistant.const import ATTR_NAME, CONF_HOST
 from homeassistant.helpers.device_registry import (
@@ -13,7 +13,20 @@
 )
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
-from .const import AVAILABLE, DOMAIN
 from .coordinator import PlugwiseDataUpdateCoordinator
@@ -46,12 +59,12 @@
         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
@@ -59,21 +72,25 @@
             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
@@ -81,8 +98,10 @@
     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
         )

 from typing import override
+from plugwise.constants import GwEntityData
 from homeassistant.const import ATTR_NAME, CONF_HOST
 from homeassistant.helpers.device_registry import (
 )
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
+from .const import (
+    AVAILABLE,
+    DOMAIN,
+    FIRMWARE,
+    HARDWARE,
+    MAC_ADDRESS,
+    MODEL,
+    MODEL_ID,
+    VENDOR,
+    WIFI_MAC_ADDRESS,
+    ZIGBEE_MAC_ADDRESS,
+)
+# Upstream consts
 from .coordinator import PlugwiseDataUpdateCoordinator
         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
             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.update(
+                {
+                    ATTR_NAME: self.device.get(ATTR_NAME),
+                    "via_device_id": async_get_device_id_by_identifier(
+                        coordinator.hass,
+                        (DOMAIN, gateway_id),
+                        config_entry_id=entry.entry_id,
+                    ),
+                }
             )
     @property
     def available(self) -> bool:
         """Return if entity is available."""
         return (
+            # Upstream: Do not change the AVAILABLE line below: some Plugwise devices and zones
+            # Upstream: do not provide their availability-status!
             self._dev_id in self.coordinator.data
+            and (self.device.get(AVAILABLE, True) is True)
             and super().available
         )

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

@@ -120,5 +120,8 @@
         "default": "mdi:lock"
       }
     }
   }
 }

         "default": "mdi:lock"
       }
     }
+  },
+  "services": {
+    "delete_notification": "mdi:trash-can"
   }
 }

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

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

 {
   "domain": "plugwise",
+  "name": "Plugwise Beta",
   "codeowners": ["@CoMPaTech", "@bouwew"],
   "config_flow": true,
+  "documentation": "https://github.com/plugwise/plugwise-beta",
   "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["plugwise"],
+  "requirements": ["plugwise>=1.14.7"],
+  "version": "0.65.2",
   "zeroconf": ["_plugwise._tcp.local."]
 }

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

@@ -9,15 +9,25 @@
     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 NumberType
 from .coordinator import PlugwiseConfigEntry, PlugwiseDataUpdateCoordinator
 from .entity import PlugwiseEntity
-from .util import deprecate_entity, plugwise_command
 PARALLEL_UPDATES = 0
@@ -29,24 +39,25 @@
     key: NumberType
 NUMBER_TYPES = (
     PlugwiseNumberEntityDescription(
-        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",
         translation_key="max_dhw_temperature",
         device_class=NumberDeviceClass.TEMPERATURE,
         entity_category=EntityCategory.CONFIG,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
     ),
     PlugwiseNumberEntityDescription(
-        key="temperature_offset",
-        translation_key="temperature_offset",
         device_class=NumberDeviceClass.TEMPERATURE,
         entity_category=EntityCategory.CONFIG,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
@@ -59,9 +70,9 @@
     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:
@@ -69,24 +80,26 @@
         if not coordinator.new_devices:
             return
-        entities = []
         for device_id in coordinator.new_devices:
             for description in NUMBER_TYPES:
-                if description.key not in coordinator.data[device_id]:
-                    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)
@@ -107,28 +120,28 @@
     ) -> None:
         """Initiate Plugwise Number."""
         super().__init__(coordinator, device_id)
-        self._attr_mode = NumberMode.BOX
-        self._attr_native_max_value = self.device[description.key]["upper_bound"]
-        self._attr_native_min_value = self.device[description.key]["lower_bound"]
-        self._attr_unique_id = f"{device_id}-{description.translation_key}"
         self.device_id = device_id
         self.entity_description = description
-        native_step = self.device[description.key]["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:
         """Return the present setpoint value."""
-        return self.device[self.entity_description.key]["setpoint"]
     @plugwise_command
     @override
     async def async_set_native_value(self, value: float) -> None:
         """Change to the new setpoint value."""
-        await self.coordinator.api.set_number(
-            self.device_id, self.entity_description.key, value
         )

     NumberEntityDescription,
     NumberMode,
 )
+from homeassistant.const import EntityCategory, UnitOfTemperature
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from .const import (
+    BOILER_TEMP,
+    DHW_TEMP,
+    LOGGER,
+    LOWER_BOUND,
+    RESOLUTION,
+    TEMPERATURE_OFFSET,
+    UPPER_BOUND,
+    NumberType,
+)
+# Upstream consts
 from .coordinator import PlugwiseConfigEntry, PlugwiseDataUpdateCoordinator
 from .entity import PlugwiseEntity
+from .util import plugwise_command
 PARALLEL_UPDATES = 0
     key: NumberType
+# Upstream + is there a reason we didn't rename this one prefixed?
 NUMBER_TYPES = (
     PlugwiseNumberEntityDescription(
+        key=BOILER_TEMP,
         translation_key="maximum_boiler_temperature",
         device_class=NumberDeviceClass.TEMPERATURE,
         entity_category=EntityCategory.CONFIG,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
     ),
     PlugwiseNumberEntityDescription(
+        key=DHW_TEMP,
         translation_key="max_dhw_temperature",
         device_class=NumberDeviceClass.TEMPERATURE,
         entity_category=EntityCategory.CONFIG,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
     ),
     PlugwiseNumberEntityDescription(
+        key=TEMPERATURE_OFFSET,
+        translation_key=TEMPERATURE_OFFSET,
         device_class=NumberDeviceClass.TEMPERATURE,
         entity_category=EntityCategory.CONFIG,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
     entry: PlugwiseConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
+    """Set up Plugwise number platform from a config entry."""
+    # Upstream above to adhere to standard used
     coordinator = entry.runtime_data
     @callback
     def _add_entities() -> None:
         if not coordinator.new_devices:
             return
+        # Upstream consts
+        # async_add_entities(
+        #     PlugwiseNumberEntity(coordinator, device_id, description)
+        #     for device_id in coordinator.new_devices
+        #     for description in NUMBER_TYPES
+        #     if description.key in coordinator.data.devices[device_id]
+        # )
+        # pw-beta alternative for debugging
+        entities: list[PlugwiseNumberEntity] = []
         for device_id in coordinator.new_devices:
+            device = coordinator.data[device_id]
             for description in NUMBER_TYPES:
+                if description.key in device:
+                    entities.append(
+                        PlugwiseNumberEntity(coordinator, device_id, description)
+                    )
+                    LOGGER.debug(
+                        "Add %s %s number", device["name"], description.translation_key
+                    )
         async_add_entities(entities)
     ) -> None:
         """Initiate Plugwise Number."""
         super().__init__(coordinator, device_id)
         self.device_id = device_id
         self.entity_description = description
+        self._attr_unique_id = f"{device_id}-{description.key}"
+        self._attr_mode = NumberMode.BOX
+        ctrl = self.device.get(description.key, {})
+        self._attr_native_max_value = ctrl.get(UPPER_BOUND, 100.0)  # Upstream const
+        self._attr_native_min_value = ctrl.get(LOWER_BOUND, 0.0)  # Upstream const
+        native_step = ctrl.get(RESOLUTION, 0.5)  # Upstream const
         self._attr_native_step = native_step
     @property
     @override
+    def native_value(self) -> float | None:
         """Return the present setpoint value."""
+        return self.device.get(self.entity_description.key, {}).get("setpoint")
     @plugwise_command
     @override
     async def async_set_native_value(self, value: float) -> None:
         """Change to the new setpoint value."""
+        await self.coordinator.api.set_number(self.device_id, self.entity_description.key, value)
+        LOGGER.debug(
+            "Setting %s to %s was successful", self.entity_description.key, value
         )

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

@@ -12,16 +12,24 @@
 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
@@ -43,7 +51,7 @@
         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
         ),
@@ -52,7 +60,7 @@
         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
         ),
@@ -61,7 +69,7 @@
         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
         ),
@@ -70,7 +78,7 @@
         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
         ),
@@ -78,7 +86,7 @@
     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
         ),
@@ -87,7 +95,7 @@
         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
         ),
@@ -100,21 +108,38 @@
     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))

 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from .const import (
+    AVAILABLE_SCHEDULES,
     DHW_MODE,
+    DHW_MODES,
+    GATEWAY_MODES,
     LOCATION,
+    LOGGER,
+    REGULATION_MODES,
     SELECT_DHW_MODE,
     SELECT_GATEWAY_MODE,
     SELECT_REGULATION_MODE,
     SELECT_SCHEDULE,
     SELECT_ZONE_PROFILE,
+    ZONE_PROFILES,
     SelectOptionsType,
     SelectType,
 )
+# Upstream consts
 from .coordinator import PlugwiseConfigEntry, PlugwiseDataUpdateCoordinator
 from .entity import PlugwiseEntity
 from .util import plugwise_command
         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
         ),
         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
         ),
         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
         ),
         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
         ),
         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
         ),
     entry: PlugwiseConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
+    """Set up Plugwise selector from a config entry."""
     coordinator = entry.runtime_data
     @callback
     def _add_entities() -> None:
+        """Add Entities."""
         if not coordinator.new_devices:
             return
+        # Upstream consts
+        # async_add_entities(
+        #     PlugwiseSelectEntity(coordinator, device_id, description)
+        #     for device_id in coordinator.new_devices
+        #     for description in SELECT_TYPES
+        #     if description.options_key in coordinator.data.devices[device_id]
+        # )
+        # pw-beta alternative for debugging
+        entities: list[PlugwiseSelectEntity] = []
+        for device_id in coordinator.new_devices:
+            device = coordinator.data[device_id]
+            for description in SELECT_TYPES:
+                if device.get(description.key):
+                    entities.append(
+                        PlugwiseSelectEntity(coordinator, device_id, description)
+                    )
+                    LOGGER.debug(
+                        "Add %s %s selector",
+                        device["name"],
+                        description.translation_key,
+                    )
+        async_add_entities(entities)
     _add_entities()
     entry.async_on_unload(coordinator.async_add_listener(_add_entities))

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

@@ -12,6 +12,7 @@
     SensorStateClass,
 )
 from homeassistant.const import (
     LIGHT_LUX,
     PERCENTAGE,
     EntityCategory,
@@ -26,6 +27,57 @@
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from .coordinator import PlugwiseConfigEntry, PlugwiseDataUpdateCoordinator
 from .entity import PlugwiseEntity
@@ -40,299 +92,301 @@
     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,
@@ -352,22 +406,22 @@
         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,
@@ -380,16 +434,16 @@
         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,
@@ -403,7 +457,8 @@
     entry: PlugwiseConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
-    """Set up the Smile sensors from a config entry."""
     coordinator = entry.runtime_data
     @callback
@@ -412,13 +467,29 @@
         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))
@@ -437,11 +508,11 @@
     ) -> 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]

     SensorStateClass,
 )
 from homeassistant.const import (
+    ATTR_TEMPERATURE,  # Upstream
     LIGHT_LUX,
     PERCENTAGE,
     EntityCategory,
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from .const import (
+    DHW_SETPOINT,
+    DHW_TEMP,
+    EL_CONS_INTERVAL,
+    EL_CONS_OP_CUMULATIVE,
+    EL_CONS_OP_INTERVAL,
+    EL_CONS_OP_POINT,
+    EL_CONS_P_CUMULATIVE,
+    EL_CONS_P_INTERVAL,
+    EL_CONS_P_POINT,
+    EL_CONS_POINT,
+    EL_CONSUMED,
+    EL_PH1_CONSUMED,
+    EL_PH1_PRODUCED,
+    EL_PH2_CONSUMED,
+    EL_PH2_PRODUCED,
+    EL_PH3_CONSUMED,
+    EL_PH3_PRODUCED,
+    EL_PROD_INTERVAL,
+    EL_PROD_OP_CUMULATIVE,
+    EL_PROD_OP_INTERVAL,
+    EL_PROD_OP_POINT,
+    EL_PROD_P_CUMULATIVE,
+    EL_PROD_P_INTERVAL,
+    EL_PROD_P_POINT,
+    EL_PROD_POINT,
+    EL_PRODUCED,
+    GAS_CONS_CUMULATIVE,
+    GAS_CONS_INTERVAL,
+    INTENDED_BOILER_TEMP,
+    LOGGER,  # pw-beta
+    MOD_LEVEL,
+    NET_EL_CUMULATIVE,
+    NET_EL_POINT,
+    OUTDOOR_AIR_TEMP,
+    OUTDOOR_TEMP,
+    RETURN_TEMP,
+    SENSORS,
+    TARGET_TEMP,
+    TARGET_TEMP_HIGH,
+    TARGET_TEMP_LOW,
+    TEMP_DIFF,
+    VALVE_POS,
+    VOLTAGE_PH1,
+    VOLTAGE_PH2,
+    VOLTAGE_PH3,
+    WATER_PRESSURE,
+    WATER_TEMP,
+)
+# Upstream consts
 from .coordinator import PlugwiseConfigEntry, PlugwiseDataUpdateCoordinator
 from .entity import PlugwiseEntity
     key: SensorType
+# Upstream consts
+PLUGWISE_SENSORS: tuple[PlugwiseSensorEntityDescription, ...] = (
     PlugwiseSensorEntityDescription(
+        key=TARGET_TEMP,
+        translation_key=TARGET_TEMP,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key=TARGET_TEMP_HIGH,
         translation_key="cooling_setpoint",
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key=TARGET_TEMP_LOW,
         translation_key="heating_setpoint",
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key=ATTR_TEMPERATURE,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key=INTENDED_BOILER_TEMP,
+        translation_key=INTENDED_BOILER_TEMP,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         entity_category=EntityCategory.DIAGNOSTIC,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key=TEMP_DIFF,
+        translation_key=TEMP_DIFF,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         entity_category=EntityCategory.DIAGNOSTIC,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key=OUTDOOR_TEMP,
+        translation_key=OUTDOOR_TEMP,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         entity_category=EntityCategory.DIAGNOSTIC,
         state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=1,
     ),
     PlugwiseSensorEntityDescription(
+        key=OUTDOOR_AIR_TEMP,
+        translation_key=OUTDOOR_AIR_TEMP,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         entity_category=EntityCategory.DIAGNOSTIC,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key=WATER_TEMP,
+        translation_key=WATER_TEMP,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         entity_category=EntityCategory.DIAGNOSTIC,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key=RETURN_TEMP,
+        translation_key=RETURN_TEMP,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         entity_category=EntityCategory.DIAGNOSTIC,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key=EL_CONSUMED,
+        translation_key=EL_CONSUMED,
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key=EL_PRODUCED,
+        translation_key=EL_PRODUCED,
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
         entity_registry_enabled_default=False,
     ),
     PlugwiseSensorEntityDescription(
+        key=EL_CONS_INTERVAL,
+        translation_key=EL_CONS_INTERVAL,
         native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL,
     ),
     PlugwiseSensorEntityDescription(
+        key=EL_CONS_P_INTERVAL,
+        translation_key=EL_CONS_P_INTERVAL,
         native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL,
     ),
     PlugwiseSensorEntityDescription(
+        key=EL_CONS_OP_INTERVAL,
+        translation_key=EL_CONS_OP_INTERVAL,
         native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL,
     ),
     PlugwiseSensorEntityDescription(
+        key=EL_PROD_INTERVAL,
+        translation_key=EL_PROD_INTERVAL,
         native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL,
         entity_registry_enabled_default=False,
     ),
     PlugwiseSensorEntityDescription(
+        key=EL_PROD_P_INTERVAL,
+        translation_key=EL_PROD_P_INTERVAL,
         native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL,
     ),
     PlugwiseSensorEntityDescription(
+        key=EL_PROD_OP_INTERVAL,
+        translation_key=EL_PROD_OP_INTERVAL,
         native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL,
     ),
     PlugwiseSensorEntityDescription(
+        key=EL_CONS_POINT,
+        translation_key=EL_CONS_POINT,
         device_class=SensorDeviceClass.POWER,
         native_unit_of_measurement=UnitOfPower.WATT,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key=EL_CONS_OP_POINT,
+        translation_key=EL_CONS_OP_POINT,
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key=EL_CONS_P_POINT,
+        translation_key=EL_CONS_P_POINT,
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key=EL_CONS_OP_CUMULATIVE,
+        translation_key=EL_CONS_OP_CUMULATIVE,
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
     ),
     PlugwiseSensorEntityDescription(
+        key=EL_CONS_P_CUMULATIVE,
+        translation_key=EL_CONS_P_CUMULATIVE,
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
     ),
     PlugwiseSensorEntityDescription(
+        key=EL_PROD_POINT,
+        translation_key=EL_PROD_POINT,
         device_class=SensorDeviceClass.POWER,
         native_unit_of_measurement=UnitOfPower.WATT,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key=EL_PROD_OP_POINT,
+        translation_key=EL_PROD_OP_POINT,
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key=EL_PROD_P_POINT,
+        translation_key=EL_PROD_P_POINT,
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key=EL_PROD_OP_CUMULATIVE,
+        translation_key=EL_PROD_OP_CUMULATIVE,
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
     ),
     PlugwiseSensorEntityDescription(
+        key=EL_PROD_P_CUMULATIVE,
+        translation_key=EL_PROD_P_CUMULATIVE,
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
     ),
     PlugwiseSensorEntityDescription(
+        key=EL_PH1_CONSUMED,
+        translation_key=EL_PH1_CONSUMED,
         device_class=SensorDeviceClass.POWER,
         native_unit_of_measurement=UnitOfPower.WATT,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key=EL_PH2_CONSUMED,
+        translation_key=EL_PH2_CONSUMED,
         device_class=SensorDeviceClass.POWER,
         native_unit_of_measurement=UnitOfPower.WATT,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key=EL_PH3_CONSUMED,
+        translation_key=EL_PH3_CONSUMED,
         device_class=SensorDeviceClass.POWER,
         native_unit_of_measurement=UnitOfPower.WATT,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key=EL_PH1_PRODUCED,
+        translation_key=EL_PH1_PRODUCED,
         device_class=SensorDeviceClass.POWER,
         native_unit_of_measurement=UnitOfPower.WATT,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key=EL_PH2_PRODUCED,
+        translation_key=EL_PH2_PRODUCED,
         device_class=SensorDeviceClass.POWER,
         native_unit_of_measurement=UnitOfPower.WATT,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key=EL_PH3_PRODUCED,
+        translation_key=EL_PH3_PRODUCED,
         device_class=SensorDeviceClass.POWER,
         native_unit_of_measurement=UnitOfPower.WATT,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key=VOLTAGE_PH1,
+        translation_key=VOLTAGE_PH1,
         device_class=SensorDeviceClass.VOLTAGE,
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         state_class=SensorStateClass.MEASUREMENT,
         entity_registry_enabled_default=False,
     ),
     PlugwiseSensorEntityDescription(
+        key=VOLTAGE_PH2,
+        translation_key=VOLTAGE_PH2,
         device_class=SensorDeviceClass.VOLTAGE,
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         state_class=SensorStateClass.MEASUREMENT,
         entity_registry_enabled_default=False,
     ),
     PlugwiseSensorEntityDescription(
+        key=VOLTAGE_PH3,
+        translation_key=VOLTAGE_PH3,
         device_class=SensorDeviceClass.VOLTAGE,
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         state_class=SensorStateClass.MEASUREMENT,
         entity_registry_enabled_default=False,
     ),
     PlugwiseSensorEntityDescription(
+        key=GAS_CONS_INTERVAL,
+        translation_key=GAS_CONS_INTERVAL,
         native_unit_of_measurement=UnitOfVolumeFlowRate.CUBIC_METERS_PER_HOUR,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key=GAS_CONS_CUMULATIVE,
+        translation_key=GAS_CONS_CUMULATIVE,
         native_unit_of_measurement=UnitOfVolume.CUBIC_METERS,
         device_class=SensorDeviceClass.GAS,
         state_class=SensorStateClass.TOTAL,
     ),
     PlugwiseSensorEntityDescription(
+        key=NET_EL_POINT,
+        translation_key=NET_EL_POINT,
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key=NET_EL_CUMULATIVE,
+        translation_key=NET_EL_CUMULATIVE,
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key=MOD_LEVEL,
+        translation_key=MOD_LEVEL,
         native_unit_of_measurement=PERCENTAGE,
         entity_category=EntityCategory.DIAGNOSTIC,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key=VALVE_POS,
+        translation_key=VALVE_POS,
         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=DHW_TEMP,
+        translation_key=DHW_TEMP,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         entity_category=EntityCategory.DIAGNOSTIC,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key=DHW_SETPOINT,
+        translation_key=DHW_SETPOINT,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         entity_category=EntityCategory.DIAGNOSTIC,
     entry: PlugwiseConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
+    """Set up Plugwise sensors from a config entry."""
+    # Upstream as Plugwise not Smile
     coordinator = entry.runtime_data
     @callback
         if not coordinator.new_devices:
             return
+        # Upstream consts
+        # async_add_entities(
+        #     PlugwiseSensorEntity(coordinator, device_id, description)
+        #     for device_id in coordinator.new_devices
+        #     if (sensors := coordinator.data.devices[device_id].get(SENSORS))
+        #     for description in PLUGWISE_SENSORS
+        #     if description.key in sensors
+        # )
+        # pw-beta alternative for debugging
+        entities: list[PlugwiseSensorEntity] = []
+        for device_id in coordinator.new_devices:
+            device = coordinator.data[device_id]
+            if not (sensors := device.get(SENSORS)):
+                continue
+            for description in PLUGWISE_SENSORS:
+                if description.key not in sensors:
+                    continue
+                entities.append(PlugwiseSensorEntity(coordinator, device_id, description))
+                LOGGER.debug(
+                    "Add %s %s sensor", device["name"], description.translation_key or description.key
+                )
+        async_add_entities(entities)
     _add_entities()
     entry.async_on_unload(coordinator.async_add_listener(_add_entities))
     ) -> None:
         """Initialise the sensor."""
         super().__init__(coordinator, device_id)
         self.entity_description = description
+        self._attr_unique_id = f"{device_id}-{description.key}"
     @property
     @override
+    def native_value(self) -> int | float | None:
         """Return the value reported by the sensor."""
+        return self.device.get(SENSORS, {}).get(self.entity_description.key)  # Upstream consts

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

@@ -10,14 +10,23 @@
     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
@@ -29,25 +38,23 @@
     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,
     ),
 )
@@ -58,9 +65,8 @@
     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:
@@ -68,32 +74,27 @@
         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()
@@ -113,14 +114,14 @@
     ) -> 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
@@ -128,10 +129,10 @@
         """Turn the device on."""
         await self.coordinator.api.set_switch_state(
             self._dev_id,
-            self.device.get("members"),
             self.entity_description.key,
             "on",
-        )
     @plugwise_command
     @override
@@ -139,21 +140,7 @@
         """Turn the device off."""
         await self.coordinator.api.set_switch_state(
             self._dev_id,
-            self.device.get("members"),
             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)

     SwitchEntity,
     SwitchEntityDescription,
 )
+from homeassistant.const import EntityCategory
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from .const import (
+    COOLING_ENA_SWITCH,
+    LOCK,
+    LOGGER,  # pw-beta
+    MEMBERS,
+    RELAY,
+    SWITCHES,
+)
+# Upstream consts
 from .coordinator import PlugwiseConfigEntry, PlugwiseDataUpdateCoordinator
 from .entity import PlugwiseEntity
+from .util import plugwise_command
 PARALLEL_UPDATES = 0
     key: SwitchType
+# Upstream consts
+PLUGWISE_SWITCHES: tuple[PlugwiseSwitchEntityDescription, ...] = (
     PlugwiseSwitchEntityDescription(
+        key=LOCK,
+        translation_key=LOCK,
+        device_class=SwitchDeviceClass.SWITCH,
         entity_category=EntityCategory.CONFIG,
     ),
     PlugwiseSwitchEntityDescription(
+        key=RELAY,
+        translation_key=RELAY,
         device_class=SwitchDeviceClass.SWITCH,
     ),
     PlugwiseSwitchEntityDescription(
+        key=COOLING_ENA_SWITCH,
+        translation_key=COOLING_ENA_SWITCH,
+        device_class=SwitchDeviceClass.SWITCH,
         entity_category=EntityCategory.CONFIG,
     ),
 )
     entry: PlugwiseConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
+    """Set up Plugwise switches from a config entry."""
     coordinator = entry.runtime_data
     @callback
     def _add_entities() -> None:
         if not coordinator.new_devices:
             return
+        # Upstream consts
+        # async_add_entities(
+        #     PlugwiseSwitchEntity(coordinator, device_id, description)
+        #     for device_id in coordinator.new_devices
+        #     if (switches := coordinator.data.devices[device_id].get(SWITCHES))
+        #     for description in PLUGWISE_SWITCHES
+        #     if description.key in switches
+        # )
+        # pw-beta alternative for debugging
+        entities: list[PlugwiseSwitchEntity] = []
         for device_id in coordinator.new_devices:
+            device = coordinator.data[device_id]
+            if not (switches := device.get(SWITCHES)):
                 continue
+            for description in PLUGWISE_SWITCHES:
                 if description.key not in switches:
                     continue
+                entities.append(PlugwiseSwitchEntity(coordinator, device_id, description))
+                LOGGER.debug(
+                    "Add %s %s switch", device["name"], description.translation_key
+                )
         async_add_entities(entities)
     _add_entities()
     ) -> 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
     @override
+    def is_on(self) -> bool | None:
         """Return True if entity is on."""
+        return self.device.get(SWITCHES, {}).get(self.entity_description.key) # Upstream const
     @plugwise_command
     @override
         """Turn the device on."""
         await self.coordinator.api.set_switch_state(
             self._dev_id,
+            self.device.get(MEMBERS),
             self.entity_description.key,
             "on",
+        )  # Upstream const
     @plugwise_command
     @override
         """Turn the device off."""
         await self.coordinator.api.set_switch_state(
             self._dev_id,
+            self.device.get(MEMBERS),
             self.entity_description.key,
             "off",
+        )  # Upstream const

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

@@ -5,222 +5,20 @@
 from plugwise.exceptions import PlugwiseException
-from homeassistant.components.automation import automations_with_entity
-from homeassistant.components.script import scripts_with_entity
-from homeassistant.const import EVENT_COMPONENT_LOADED, EVENT_HOMEASSISTANT_STARTED
-from homeassistant.core import CoreState, Event, 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.typing import NoEventData
-from homeassistant.setup import ATTR_COMPONENT, EventComponentLoaded
 from .const import DOMAIN
 from .entity import PlugwiseEntity
-# Version in which deprecated entities will be removed.
-DEPRECATED_REMOVAL_VERSION = "2027.5.0"
-_REFERENCE_COMPONENTS = {"automation", "script"}
-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 after automation and script setup."""
-    unsubscribers: list[Callable[[], None]] = []
-    loaded_components: set[str] = set()
-    @callback
-    def _async_recheck() -> None:
-        for unsubscribe in unsubscribers:
-            unsubscribe()
-        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)
-    @callback
-    def _async_component_loaded(event: Event[EventComponentLoaded]) -> None:
-        if (component := event.data[ATTR_COMPONENT]) in _REFERENCE_COMPONENTS:
-            loaded_components.add(component)
-            if _REFERENCE_COMPONENTS.issubset(loaded_components):
-                _async_recheck()
-    @callback
-    def _async_homeassistant_started(_: Event[NoEventData]) -> None:
-        _async_recheck()
-    @callback
-    def _async_register_unsubscriber(unsubscribe: Callable[[], None]) -> None:
-        is_subscribed = True
-        @callback
-        def _async_unsubscribe() -> None:
-            nonlocal is_subscribed
-            if is_subscribed:
-                is_subscribed = False
-                unsubscribe()
-        unsubscribers.append(_async_unsubscribe)
-        async_on_unload(_async_unsubscribe)
-    _async_register_unsubscriber(
-        hass.bus.async_listen(EVENT_COMPONENT_LOADED, _async_component_loaded)
-    )
-    _async_register_unsubscriber(
-        hass.bus.async_listen_once(
-            EVENT_HOMEASSISTANT_STARTED, _async_homeassistant_started
-        )
-    )
-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.
     A decorator that wraps the passed in function, catches Plugwise errors,
@@ -228,8 +26,8 @@
     """
     async def handler(
-        self: _PlugwiseEntityT, *args: _P.args, **kwargs: _P.kwargs
-    ) -> _R:
         try:
             return await func(self, *args, **kwargs)
         except PlugwiseException as err:

 from plugwise.exceptions import PlugwiseException
 from homeassistant.exceptions import HomeAssistantError
 from .const import DOMAIN
 from .entity import PlugwiseEntity
+# For reference:
+# PlugwiseEntityT = TypeVar("PlugwiseEntityT", bound=PlugwiseEntity)
+# R = TypeVar("_R")
+# P = ParamSpec("_P")
+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.
     A decorator that wraps the passed in function, catches Plugwise errors,
     """
     async def handler(
+        self: PlugwiseEntityT, *args: P.args, **kwargs: P.kwargs
+    ) -> R:
         try:
             return await func(self, *args, **kwargs)
         except PlugwiseException as err:

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

@@ -1,4 +1,4 @@
-"""Plugwise water heater component for Home Assistant."""
 from dataclasses import dataclass
 from typing import Any, Final, override
@@ -19,6 +19,7 @@
 from .const import (
     DHW_TEMP,
     DOMAIN,
     LOWER_BOUND,
     UPPER_BOUND,
     BinarySensorType,
@@ -33,7 +34,6 @@
 FAIL_SET_TEMP: Final = "temperature_out_of_range"
 OPERATION_LIST: Final[list[str]] = [STATE_GAS, STATE_HEAT_PUMP, STATE_OFF]
 @dataclass(frozen=True, kw_only=True)
 class PlugwiseWaterHeaterEntityDescription(WaterHeaterEntityDescription):
     """Class describing Plugwise WaterHeater entities."""
@@ -50,9 +50,8 @@
     ),
 )
 async def async_setup_entry(
-    hass: HomeAssistant,
     entry: PlugwiseConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
@@ -65,12 +64,19 @@
         if not coordinator.new_devices:
             return
-        async_add_entities(
-            PlugwiseWaterHeaterEntity(coordinator, device_id, description)
-            for device_id in coordinator.new_devices
-            for description in WATERHEATER_TYPES
-            if description.key in coordinator.data[device_id]
-        )
     _add_entities()
     entry.async_on_unload(coordinator.async_add_listener(_add_entities))
@@ -97,12 +103,12 @@
         self._attr_target_temperature_step = max(
             self.device[description.key]["resolution"], 1.0
         )
-        self._attr_native_temperature_unit = UnitOfTemperature.CELSIUS
         self._attr_unique_id = f"{device_id}-{description.key}"
     @property
     @override
-    def current_operation(self) -> str:
         """Return current readable operation mode."""
         if (
             binary_sensors := self.device.get("binary_sensors", {})
@@ -119,13 +125,13 @@
     @property
     @override
-    def native_current_temperature(self) -> float | None:
         """Return the current water temperature."""
         return self.device[self.entity_description.key].get("current")
     @property
     @override
-    def native_target_temperature(self) -> float | None:
         """Return the water temperature we try to reach."""
         return self.device[self.entity_description.key].get("setpoint")

+"""Plugwise water heater component for HomeAssistant."""
 from dataclasses import dataclass
 from typing import Any, Final, override
 from .const import (
     DHW_TEMP,
     DOMAIN,
+    LOGGER,
     LOWER_BOUND,
     UPPER_BOUND,
     BinarySensorType,
 FAIL_SET_TEMP: Final = "temperature_out_of_range"
 OPERATION_LIST: Final[list[str]] = [STATE_GAS, STATE_HEAT_PUMP, STATE_OFF]
 @dataclass(frozen=True, kw_only=True)
 class PlugwiseWaterHeaterEntityDescription(WaterHeaterEntityDescription):
     """Class describing Plugwise WaterHeater entities."""
     ),
 )
 async def async_setup_entry(
+    _hass: HomeAssistant,
     entry: PlugwiseConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
         if not coordinator.new_devices:
             return
+        entities: list[PlugwiseWaterHeaterEntity] = []
+        for device_id in coordinator.new_devices:
+            device = coordinator.data[device_id]
+            for description in WATERHEATER_TYPES:
+                if description.key in device:
+                    entities.append(
+                        PlugwiseWaterHeaterEntity(coordinator, device_id, description)
+                    )
+                    LOGGER.debug(
+                        "Add %s %s water_heater", device["name"], description.translation_key
+                    )
+        async_add_entities(entities)
     _add_entities()
     entry.async_on_unload(coordinator.async_add_listener(_add_entities))
         self._attr_target_temperature_step = max(
             self.device[description.key]["resolution"], 1.0
         )
+        self._attr_temperature_unit = UnitOfTemperature.CELSIUS
         self._attr_unique_id = f"{device_id}-{description.key}"
     @property
     @override
+    def current_operation(self) -> str | None:
         """Return current readable operation mode."""
         if (
             binary_sensors := self.device.get("binary_sensors", {})
     @property
     @override
+    def current_temperature(self) -> float | None:
         """Return the current water temperature."""
         return self.device[self.entity_description.key].get("current")
     @property
     @override
+    def target_temperature(self) -> float | None:
         """Return the water temperature we try to reach."""
         return self.device[self.entity_description.key].get("setpoint")