Diff to HTML by rtfpessoa

Files changed (16) hide show

/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/__init__.py +22 -103
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/binary_sensor.py +35 -94
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/button.py +7 -17
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/climate.py +78 -153
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/config_flow.py +27 -130
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/const.py +38 -154
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/coordinator.py +29 -60
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/entity.py +10 -27
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/icons.json +6 -9
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/manifest.json +4 -4
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/number.py +24 -55
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/select.py +16 -46
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/sensor.py +101 -172
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/strings.json +159 -169
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/switch.py +24 -54
/home/runner/work/progress/progress/clones/beta/{beta/custom_components → ha-core/homeassistant/components}/plugwise/util.py +5 -12

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

@@ -4,44 +4,21 @@
 from typing import Any
-from plugwise.exceptions import PlugwiseError
-import voluptuous as vol  # pw-beta delete_notification
-from homeassistant.const import CONF_TIMEOUT, Platform
-from homeassistant.core import (
-    HomeAssistant,
-    ServiceCall,  # pw-beta delete_notification
-    callback,
-)
 from homeassistant.helpers import device_registry as dr, entity_registry as er
-from .const import (
-    CONF_REFRESH_INTERVAL,  # pw-beta options
-    DOMAIN,
-    LOGGER,
-    PLATFORMS,
-    SERVICE_DELETE,  # pw-beta delete_notifications
-)
 from .coordinator import PlugwiseConfigEntry, PlugwiseDataUpdateCoordinator
 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_sensor_entities(hass, coordinator)
     entry.runtime_data = coordinator
@@ -56,63 +33,21 @@
         sw_version=str(coordinator.api.smile.version),
     )  # required for adding the entity-less P1 Gateway
-    async def delete_notification(
-        call: ServiceCall,
-    ) -> None:  # pragma: no cover  # pw-beta: HA service - delete_notification
-        """Service: delete the Plugwise Notification."""
-        LOGGER.debug(
-            "Service delete PW Notification called for %s",
-            coordinator.api.smile.name,
-        )
-        try:
-            await coordinator.api.delete_notification()
-            LOGGER.debug("PW Notification deleted")
-        except PlugwiseError:
-            LOGGER.debug(
-                "Failed to delete the Plugwise Notification for %s",
-                coordinator.api.smile.name,
-            )
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
-    entry.async_on_unload(entry.add_update_listener(update_listener))  # pw-beta options_flow
-    for component in PLATFORMS:  # pw-beta delete_notification
-        if component == Platform.BINARY_SENSOR:
-            hass.services.async_register(
-                DOMAIN, SERVICE_DELETE, delete_notification, schema=vol.Schema({})
-            )
     return True
-async def update_listener(
-    hass: HomeAssistant, config_entry: PlugwiseConfigEntry
-) -> None:  # pragma: no cover  # pw-beta
-    """Handle options update."""
-    await hass.config_entries.async_reload(config_entry.entry_id)
-async def async_unload_entry(hass: HomeAssistant, config_entry: PlugwiseConfigEntry) -> bool:
-    """Unload Plugwise."""
-    return await hass.config_entries.async_unload_platforms(config_entry, PLATFORMS)
-async def async_remove_config_entry_device(
-    _hass: HomeAssistant, config_entry: PlugwiseConfigEntry, device_entry: dr.DeviceEntry
-) -> bool:
-    """Enable manual removal (button) for Plugwise devices."""
-    coordinator = config_entry.runtime_data
-    return not any(
-        identifier
-        for identifier in device_entry.identifiers
-        if identifier[0] == DOMAIN and (
-            identifier[1] != coordinator.api.gateway_id
-            and identifier[1] in coordinator.data
-            )
-    )
 @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"
@@ -134,17 +69,18 @@
     # No migration needed
     return None
-async def async_migrate_sensor_entities(
     hass: HomeAssistant,
     coordinator: PlugwiseDataUpdateCoordinator,
 ) -> None:
     """Migrate Sensors if needed."""
     ent_reg = er.async_get(hass)
-    # Migrate 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"
@@ -152,27 +88,10 @@
             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)
-# 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

 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) -> bool:
+    """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
         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)
     return True
+async def async_unload_entry(hass: HomeAssistant, entry: PlugwiseConfigEntry) -> bool:
+    """Unload the Plugwise components."""
+    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
+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"
             Platform.SENSOR, DOMAIN, old_unique_id
         ):
             new_unique_id = f"{device_id}-outdoor_air_temperature"
+            LOGGER.debug(
+                "Migrating entity %s from old unique ID '%s' to new unique ID '%s'",
+                entity_id,
+                old_unique_id,
+                new_unique_id,
+            )
             ent_reg.async_update_entity(entity_id, new_unique_id=new_unique_id)

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

@@ -8,9 +8,6 @@
 from plugwise.constants import BinarySensorType
-from homeassistant.components import (
-    persistent_notification,  # pw-beta Plugwise notifications
-)
 from homeassistant.components.binary_sensor import (
     BinarySensorDeviceClass,
     BinarySensorEntity,
@@ -20,26 +17,11 @@
 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
@@ -51,51 +33,50 @@
     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,
     ),
 )
@@ -106,7 +87,7 @@
     entry: PlugwiseConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
-    """Set up Plugwise binary_sensors from a config entry."""
     coordinator = entry.runtime_data
     @callback
@@ -115,40 +96,20 @@
         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
-                )
-        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
@@ -162,46 +123,26 @@
         super().__init__(coordinator, device_id)
         self.entity_description = description
         self._attr_unique_id = f"{device_id}-{description.key}"
-        self._notification: dict[str, str] = {}  # pw-beta
     @property
-    def is_on(self) -> bool | 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
     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

 from plugwise.constants import BinarySensorType
 from homeassistant.components.binary_sensor import (
     BinarySensorDeviceClass,
     BinarySensorEntity,
 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
     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,
     ),
 )
     entry: PlugwiseConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
+    """Set up the Smile binary_sensors from a config entry."""
     coordinator = entry.runtime_data
     @callback
         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
         super().__init__(coordinator, device_id)
         self.entity_description = description
         self._attr_unique_id = f"{device_id}-{description.key}"
     @property
+    def is_on(self) -> bool:
         """Return true if the binary sensor is on."""
+        return self.device["binary_sensors"][self.entity_description.key]
     @property
     def extra_state_attributes(self) -> Mapping[str, Any] | None:
         """Return entity specific state attributes."""
+        if self.entity_description.key != "plugwise_notification":
             return None
+        attrs: dict[str, list[str]] = {f"{severity}_msg": [] for severity in SEVERITIES}
         gateway_id = self.coordinator.api.gateway_id
         if notify := self.coordinator.data[gateway_id]["notifications"]:
+            for details in notify.values():
                 for msg_type, msg in details.items():
                     msg_type = msg_type.lower()
                     if msg_type not in SEVERITIES:
+                        msg_type = "other"
                     attrs[f"{msg_type}_msg"].append(msg)
         return attrs

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

@@ -7,10 +7,7 @@
 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
@@ -23,21 +20,14 @@
     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):

 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
     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):

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

@@ -9,47 +9,18 @@
     ATTR_HVAC_MODE,
     ATTR_TARGET_TEMP_HIGH,
     ATTR_TARGET_TEMP_LOW,
-    PRESET_AWAY,  # pw-beta homekit emulation
-    PRESET_HOME,  # pw-beta homekit emulation
     ClimateEntity,
     ClimateEntityFeature,
     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,
-    CONF_HOMEKIT_EMULATION,  # pw-beta homekit emulation
-    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
@@ -58,49 +29,6 @@
 PARALLEL_UPDATES = 0
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: PlugwiseConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Plugwise thermostats from a config entry."""
-    coordinator = entry.runtime_data
-    homekit_enabled: bool = entry.options.get(
-        CONF_HOMEKIT_EMULATION, False
-    )  # pw-beta homekit emulation
-    @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, homekit_enabled
-                        )  # pw-beta homekit emulation
-                    )
-                    LOGGER.debug("Add climate %s", device[ATTR_NAME])
-            elif device[DEV_CLASS] in MASTER_THERMOSTATS:
-                entities.append(
-                    PlugwiseClimateEntity(
-                        coordinator, device_id, homekit_enabled
-                    )  # pw-beta homekit emulation
-                )
-                LOGGER.debug("Add climate %s", device[ATTR_NAME])
-        async_add_entities(entities)
-    _add_entities()
-    entry.async_on_unload(coordinator.async_add_listener(_add_entities))
 @dataclass
 class PlugwiseClimateExtraStoredData(ExtraStoredData):
     """Object to hold extra stored data."""
@@ -124,18 +52,46 @@
         )
 class PlugwiseClimateEntity(PlugwiseEntity, ClimateEntity, RestoreEntity):
     """Representation of a Plugwise thermostat."""
-    _attr_has_entity_name = True
     _attr_name = None
     _attr_temperature_unit = UnitOfTemperature.CELSIUS
     _attr_translation_key = DOMAIN
-    _enable_turn_on_off_backwards_compatibility = False
     _last_active_schedule: str | None = None
-    _previous_action_mode: str | None = HVACAction.HEATING.value  # Upstream
-    _homekit_mode: HVACMode | None = None  # pw-beta homekit emulation + intentional unsort
     async def async_added_to_hass(self) -> None:
         """Run when entity about to be added."""
@@ -152,26 +108,17 @@
         self,
         coordinator: PlugwiseDataUpdateCoordinator,
         device_id: str,
-        homekit_enabled: bool,  # pw-beta homekit emulation
     ) -> None:
         """Set up the Plugwise API."""
         super().__init__(coordinator, device_id)
         gateway_id: str = coordinator.api.gateway_id
         self._gateway_data = coordinator.data[gateway_id]
-        self._homekit_enabled = homekit_enabled  # pw-beta homekit emulation
         self._location = device_id
-        if (location := self.device.get(LOCATION)) is not None:
             self._location = location
-        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
-        )
-        self._attr_unique_id = f"{device_id}-climate"
         # Determine supported features
         self._attr_supported_features = ClimateEntityFeature.TARGET_TEMPERATURE
         if (
@@ -185,14 +132,21 @@
             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
     @property
-    def current_temperature(self) -> float | None:
         """Return the current temperature."""
-        return self.device.get(SENSORS, {}).get(ATTR_TEMPERATURE)
     @property
     def extra_restore_state_data(self) -> PlugwiseClimateExtraStoredData:
@@ -203,64 +157,52 @@
         )
     @property
-    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
-    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
-    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
     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
-        # pw-beta homekit emulation
-        if self._homekit_enabled and self._homekit_mode == HVACMode.OFF:
-            return HVACMode.OFF  # pragma: no cover
-        return hvac
     @property
     def hvac_modes(self) -> list[HVACMode]:
         """Return a list of available HVACModes."""
         hvac_modes: list[HVACMode] = []
-        if (
-            self._homekit_enabled  # pw-beta homekit emulation
-            or REGULATION_MODES in self._gateway_data
-        ):
             hvac_modes.append(HVACMode.OFF)
-        if self.device.get(AVAILABLE_SCHEDULES, []):
             hvac_modes.append(HVACMode.AUTO)
         if self.coordinator.api.cooling_present:
-            if REGULATION_MODES in self._gateway_data:
-                selected = self._gateway_data.get(SELECT_REGULATION_MODE)
                 if selected == HVACAction.COOLING.value:
                     hvac_modes.append(HVACMode.COOL)
                 if selected == HVACAction.HEATING.value:
@@ -273,19 +215,19 @@
         return hvac_modes
     @property
-    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
@@ -293,20 +235,18 @@
     @property
     def preset_mode(self) -> str | None:
         """Return the current preset mode."""
-        return self.device.get(ACTIVE_PRESET)
     @plugwise_command
     async def async_set_temperature(self, **kwargs: Any) -> None:
         """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)
@@ -319,7 +259,9 @@
         if hvac_mode == self.hvac_mode:
             return
-        if hvac_mode != HVACMode.OFF:
             current = self.device.get("select_schedule")
             desired = current
@@ -341,27 +283,10 @@
                 STATE_ON if hvac_mode == HVACMode.AUTO else STATE_OFF,
                 desired,
             )
-        await self._homekit_translate_or_not(hvac_mode)  # pw-beta
-    async def _homekit_translate_or_not(self, mode: HVACMode) -> None:
-        """Mimic HomeKit by setting a suitable preset, when homekit mode is enabled."""
-        if (
-            not self._homekit_enabled  # pw-beta
-        ):
-            if mode == HVACMode.OFF:
-                await self.coordinator.api.set_regulation_mode(mode.value)
-            elif self.hvac_mode == HVACMode.OFF and self._previous_action_mode:
-                await self.coordinator.api.set_regulation_mode(self._previous_action_mode)
-        else:  # pw-beta
-            self._homekit_mode = mode  # pragma: no cover
-            if self._homekit_mode == HVACMode.OFF:  # pragma: no cover
-                await self.async_set_preset_mode(PRESET_AWAY)  # pragma: no cover
-            if (
-                self._homekit_mode in [HVACMode.HEAT, HVACMode.HEAT_COOL]
-                and self.device.get(ACTIVE_PRESET) == PRESET_AWAY
-            ):  # pragma: no cover
-                await self.async_set_preset_mode(PRESET_HOME)  # pragma: no cover
     @plugwise_command
     async def async_set_preset_mode(self, preset_mode: str) -> None:

     ATTR_HVAC_MODE,
     ATTR_TARGET_TEMP_HIGH,
     ATTR_TARGET_TEMP_LOW,
     ClimateEntity,
     ClimateEntityFeature,
     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
 PARALLEL_UPDATES = 0
 @dataclass
 class PlugwiseClimateExtraStoredData(ExtraStoredData):
     """Object to hold extra stored data."""
         )
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: PlugwiseConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the Smile Thermostats from a config entry."""
+    coordinator = entry.runtime_data
+    @callback
+    def _add_entities() -> None:
+        """Add Entities."""
+        if not coordinator.new_devices:
+            return
+        if coordinator.api.smile.name == "Adam":
+            async_add_entities(
+                PlugwiseClimateEntity(coordinator, device_id)
+                for device_id in coordinator.new_devices
+                if coordinator.data[device_id]["dev_class"] == "climate"
+            )
+        else:
+            async_add_entities(
+                PlugwiseClimateEntity(coordinator, device_id)
+                for device_id in coordinator.new_devices
+                if coordinator.data[device_id]["dev_class"] in MASTER_THERMOSTATS
+            )
+    _add_entities()
+    entry.async_on_unload(coordinator.async_add_listener(_add_entities))
 class PlugwiseClimateEntity(PlugwiseEntity, ClimateEntity, RestoreEntity):
     """Representation of a Plugwise thermostat."""
     _attr_name = None
     _attr_temperature_unit = UnitOfTemperature.CELSIUS
     _attr_translation_key = DOMAIN
     _last_active_schedule: str | None = None
+    _previous_action_mode: str | None = HVACAction.HEATING.value
     async def async_added_to_hass(self) -> None:
         """Run when entity about to be added."""
         self,
         coordinator: PlugwiseDataUpdateCoordinator,
         device_id: str,
     ) -> None:
         """Set up the Plugwise API."""
         super().__init__(coordinator, device_id)
+        self._attr_unique_id = f"{device_id}-climate"
         gateway_id: str = coordinator.api.gateway_id
         self._gateway_data = coordinator.data[gateway_id]
         self._location = device_id
+        if (location := self.device.get("location")) is not None:
             self._location = location
         # Determine supported features
         self._attr_supported_features = ClimateEntityFeature.TARGET_TEMPERATURE
         if (
             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
+        )
     @property
+    def current_temperature(self) -> float:
         """Return the current temperature."""
+        return self.device["sensors"]["temperature"]
     @property
     def extra_restore_state_data(self) -> PlugwiseClimateExtraStoredData:
         )
     @property
+    def 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
+    def target_temperature_high(self) -> float:
         """Return the temperature we try to reach in case of cooling.
         Connected to the HVACMode combination of AUTO-HEAT_COOL.
         """
+        return self.device["thermostat"]["setpoint_high"]
     @property
+    def target_temperature_low(self) -> float:
         """Return the heating temperature we try to reach in case of heating.
         Connected to the HVACMode combination AUTO-HEAT_COOL.
         """
+        return self.device["thermostat"]["setpoint_low"]
     @property
     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
     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.get("available_schedules"):
             hvac_modes.append(HVACMode.AUTO)
         if self.coordinator.api.cooling_present:
+            if "regulation_modes" in self._gateway_data:
+                selected = self._gateway_data.get("select_regulation_mode")
                 if selected == HVACAction.COOLING.value:
                     hvac_modes.append(HVACMode.COOL)
                 if selected == HVACAction.HEATING.value:
         return hvac_modes
     @property
+    def hvac_action(self) -> HVACAction:
         """Return the current running hvac operation if supported."""
         # Keep track of the previous hvac_action mode.
         # When no cooling available, _previous_action_mode is always heating
         if (
+            "regulation_modes" in self._gateway_data
+            and HVACAction.COOLING.value in self._gateway_data["regulation_modes"]
         ):
+            mode = self._gateway_data["select_regulation_mode"]
             if mode in (HVACAction.COOLING.value, HVACAction.HEATING.value):
                 self._previous_action_mode = mode
+        if (action := self.device.get("control_state")) is not None:
             return HVACAction(action)
         return HVACAction.IDLE
     @property
     def preset_mode(self) -> str | None:
         """Return the current preset mode."""
+        return self.device.get("active_preset")
     @plugwise_command
     async def async_set_temperature(self, **kwargs: Any) -> None:
         """Set new target temperature."""
         data: dict[str, Any] = {}
         if ATTR_TEMPERATURE in kwargs:
+            data["setpoint"] = kwargs.get(ATTR_TEMPERATURE)
         if ATTR_TARGET_TEMP_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)
         if hvac_mode == self.hvac_mode:
             return
+        if hvac_mode == HVACMode.OFF:
+            await self.coordinator.api.set_regulation_mode(hvac_mode.value)
+        else:
             current = self.device.get("select_schedule")
             desired = current
                 STATE_ON if hvac_mode == HVACMode.AUTO else STATE_OFF,
                 desired,
             )
+            if self.hvac_mode == HVACMode.OFF and self._previous_action_mode:
+                await self.coordinator.api.set_regulation_mode(
+                    self._previous_action_mode
+                )
     @plugwise_command
     async def async_set_preset_mode(self, preset_mode: str) -> None:

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

@@ -2,7 +2,6 @@
 from __future__ import annotations
-from copy import deepcopy
 import logging
 from typing import Any, Self
@@ -17,15 +16,7 @@
 )
 import voluptuous as vol
-from homeassistant.config_entries import (
-    SOURCE_USER,
-    ConfigEntry,
-    ConfigFlow,
-    ConfigFlowResult,
-    OptionsFlow,
-)
-# Upstream
 from homeassistant.const import (
     ATTR_CONFIGURATION_URL,
     CONF_BASE,
@@ -33,47 +24,30 @@
     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
 from .const import (
     ANNA_WITH_ADAM,
-    CONF_HOMEKIT_EMULATION,  # pw-beta option
-    CONF_REFRESH_INTERVAL,  # pw-beta option
     DEFAULT_PORT,
-    DEFAULT_SCAN_INTERVAL,  # pw-beta option
     DEFAULT_USERNAME,
     DOMAIN,
     FLOW_SMILE,
     FLOW_STRETCH,
-    INIT,
     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 = vol.Schema(
     {
         vol.Required(CONF_HOST): str,
@@ -81,31 +55,21 @@
 )
-def smile_user_schema(cf_input: ZeroconfServiceInfo | dict[str, Any] | None) -> vol.Schema:
     """Generate base schema for gateways."""
-    if not cf_input:  # no discovery- or user-input available
-        return vol.Schema(
             {
                 vol.Required(CONF_HOST): str,
-                vol.Required(CONF_PASSWORD): str,
                 vol.Required(CONF_USERNAME, default=SMILE): vol.In(
                     {SMILE: FLOW_SMILE, STRETCH: FLOW_STRETCH}
                 ),
             }
         )
-    if isinstance(cf_input, ZeroconfServiceInfo):
-        return vol.Schema({vol.Required(CONF_PASSWORD): str})
-    return vol.Schema(
-        {
-            vol.Required(CONF_HOST, default=cf_input[CONF_HOST]): str,
-            vol.Required(CONF_PASSWORD, default=cf_input[CONF_PASSWORD]): str,
-            vol.Required(CONF_USERNAME, default=cf_input[CONF_USERNAME]): vol.In(
-                {SMILE: FLOW_SMILE, STRETCH: FLOW_STRETCH}
-            ),
-        }
-    )
 async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> Smile:
@@ -155,10 +119,9 @@
     """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
     async def async_step_zeroconf(
@@ -167,21 +130,17 @@
         """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
@@ -194,6 +153,12 @@
                     }
                 )
         # 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:
@@ -203,15 +168,14 @@
         # 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()
@@ -228,7 +192,6 @@
         return False
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
@@ -245,19 +208,18 @@
             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:
@@ -267,7 +229,7 @@
         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),
@@ -278,7 +240,8 @@
             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(
@@ -295,69 +258,3 @@
             description_placeholders={"title": reconfigure_entry.title},
             errors=errors,
         )
-    @staticmethod
-    @callback
-    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 - add homekit emulation 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) -> vol.Schema:
-        interval = DEFAULT_SCAN_INTERVAL[coordinator.api.smile.type]  # pw-beta options
-        schema = {
-            vol.Optional(
-                CONF_SCAN_INTERVAL,
-                default=self.options.get(CONF_SCAN_INTERVAL, interval.seconds),
-            ): vol.All(cv.positive_int, vol.Clamp(min=10)),
-        }  # pw-beta
-        if coordinator.api.smile.type == THERMOSTAT:
-            schema.update({
-                vol.Optional(
-                    CONF_HOMEKIT_EMULATION,
-                    default=self.options.get(CONF_HOMEKIT_EMULATION, False),
-                ): vol.All(cv.boolean),
-                vol.Optional(
-                    CONF_REFRESH_INTERVAL,
-                    default=self.options.get(CONF_REFRESH_INTERVAL, 1.5),
-                ): vol.All(vol.Coerce(float), vol.Range(min=1.5, max=10.0)),
-            })  # pw-beta
-        return vol.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)
-        )

 from __future__ import annotations
 import logging
 from typing import Any, Self
 )
 import voluptuous as vol
+from homeassistant.config_entries import SOURCE_USER, ConfigFlow, ConfigFlowResult
 from homeassistant.const import (
     ATTR_CONFIGURATION_URL,
     CONF_BASE,
     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,
     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 = vol.Schema(
     {
         vol.Required(CONF_HOST): str,
 )
+def smile_user_schema(discovery_info: ZeroconfServiceInfo | None) -> vol.Schema:
     """Generate base schema for gateways."""
+    schema = vol.Schema({vol.Required(CONF_PASSWORD): str})
+    if not discovery_info:
+        schema = schema.extend(
             {
                 vol.Required(CONF_HOST): str,
                 vol.Required(CONF_USERNAME, default=SMILE): vol.In(
                     {SMILE: FLOW_SMILE, STRETCH: FLOW_STRETCH}
                 ),
             }
         )
+    return schema
 async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> Smile:
     """Handle a config flow for Plugwise Smile."""
     VERSION = 1
     discovery_info: ZeroconfServiceInfo | None = None
+    product: str = UNKNOWN_SMILE
     _username: str = DEFAULT_USERNAME
     async def async_step_zeroconf(
         """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
                     }
                 )
+        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:
         # 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()
         return False
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
             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:
         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),
             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,
         )

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

@@ -1,164 +1,35 @@
 """Constants for Plugwise component."""
 from datetime import timedelta
 import logging
 from typing import Final, Literal
 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"
-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"
-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
-MAX_BOILER_TEMP: Final = "maximum_boiler_temperature"
-MAX_DHW_TEMP: Final = "max_dhw_temperature"
-LOWER_BOUND: Final = "lower_bound"
-RESOLUTION: Final = "resolution"
-TEMPERATURE_OFFSET: Final = "temperature_offset"
-UPPER_BOUND: Final = "upper_bound"
-# Sensor constants
-DHW_TEMP: Final = "dhw_temperature"
-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_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"
-# Default directives
-DEFAULT_PORT: Final[int] = 80
-DEFAULT_SCAN_INTERVAL: Final[dict[str, timedelta]] = {
-    "power": timedelta(seconds=10),
-    "stretch": timedelta(seconds=60),
-    "thermostat": timedelta(seconds=60),
-}
-DEFAULT_TIMEOUT: Final[int] = 30
-DEFAULT_USERNAME: Final = "smile"
-# --- Const for Plugwise Smile and Stretch
 PLATFORMS: Final[list[str]] = [
     Platform.BINARY_SENSOR,
     Platform.BUTTON,
@@ -168,18 +39,6 @@
     Platform.SENSOR,
     Platform.SWITCH,
 ]
-SERVICE_DELETE: Final = "delete_notification"
-SEVERITIES: Final[list[str]] = ["other", "info", "message", "warning", "error"]
-# Climate const:
-MASTER_THERMOSTATS: Final[list[str]] = [
-    "thermostat",
-    "zone_thermometer",
-    "zone_thermostat",
-    "thermostatic_radiator_valve",
-]
-# Config_flow const:
 ZEROCONF_MAP: Final[dict[str, str]] = {
     "smile": "Smile P1",
     "smile_thermo": "Smile Anna",
@@ -198,7 +57,7 @@
     "select_gateway_mode",
     "select_regulation_mode",
     "select_schedule",
-    "select_zone_profile"
 ]
 type SelectOptionsType = Literal[
     "available_schedules",
@@ -207,3 +66,28 @@
     "regulation_modes",
     "zone_profiles",
 ]

 """Constants for Plugwise component."""
+from __future__ import annotations
 from datetime import timedelta
 import logging
 from typing import Final, Literal
 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"
+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"
 PLATFORMS: Final[list[str]] = [
     Platform.BINARY_SENSOR,
     Platform.BUTTON,
     Platform.SENSOR,
     Platform.SWITCH,
 ]
 ZEROCONF_MAP: Final[dict[str, str]] = {
     "smile": "Smile P1",
     "smile_thermo": "Smile Anna",
     "select_gateway_mode",
     "select_regulation_mode",
     "select_schedule",
+    "select_zone_profile",
 ]
 type SelectOptionsType = Literal[
     "available_schedules",
     "regulation_modes",
     "zone_profiles",
 ]
+# Default directives
+DEFAULT_MAX_TEMP: Final = 30
+DEFAULT_MIN_TEMP: Final = 4
+DEFAULT_PORT: Final = 80
+DEFAULT_SCAN_INTERVAL: Final[dict[str, timedelta]] = {
+    "power": timedelta(seconds=10),
+    "stretch": timedelta(seconds=60),
+    "thermostat": timedelta(seconds=60),
+}
+DEFAULT_USERNAME: Final = "smile"
+MASTER_THERMOSTATS: Final[list[str]] = [
+    "thermostat",
+    "thermostatic_radiator_valve",
+    "zone_thermometer",
+    "zone_thermostat",
+]
+# Select constants
+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"

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

@@ -2,6 +2,7 @@
 from datetime import timedelta
 from plugwise import GwEntityData, Smile
 from plugwise.exceptions import (
     ConnectionFailedError,
@@ -13,22 +14,15 @@
 )
 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_SCAN_INTERVAL, DEV_CLASS, DOMAIN, LOGGER, SWITCH_GROUPS
 type PlugwiseConfigEntry = ConfigEntry[PlugwiseDataUpdateCoordinator]
@@ -40,57 +34,38 @@
     config_entry: PlugwiseConfigEntry
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        cooldown: float,
-        config_entry: PlugwiseConfigEntry,
-        update_interval: timedelta = timedelta(seconds=60),
-    ) -> 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=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._current_devices: set[str] = set()
         self.new_devices: set[str] = set()
-        self.update_interval = update_interval
     async def _connect(self) -> None:
         """Connect to the Plugwise Smile."""
         version = await self.api.connect()
         self._connected = isinstance(version, Version)
-        if self._connected:
-            self.update_interval = DEFAULT_SCAN_INTERVAL.get(
-                self.api.smile.type, timedelta(seconds=60)
-            )  # pw-beta options scan-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
     async def _async_update_data(self) -> dict[str, GwEntityData]:
         """Fetch data from Plugwise."""
@@ -109,7 +84,6 @@
                 translation_key="authentication_failed",
             ) from err
         except (InvalidXMLError, ResponseError) as err:
-            # pwbeta TODO; we had {err} in the text, but not upstream, do we want this?
             raise UpdateFailed(
                 translation_domain=DOMAIN,
                 translation_key="invalid_xml_data",
@@ -125,50 +99,45 @@
                 translation_key="unsupported_firmware",
             ) from err
-        LOGGER.debug(f"{self.api.smile.name} data: %s", data)
-        await self._async_add_remove_devices(data)
         return data
-    async def _async_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
-        for device_id, device in data.copy().items():
-            if device.get(DEV_CLASS) in SWITCH_GROUPS:
-                data.pop(device_id)
         # Check for new or removed devices
         self.new_devices = set(data) - self._current_devices
         removed_devices = self._current_devices - set(data)
         self._current_devices = set(data)
         if removed_devices:
-            await self._async_remove_devices(data)
-    async def _async_remove_devices(self, data: dict[str, GwEntityData]) -> None:
         """Clean registries when removed devices found."""
         device_reg = dr.async_get(self.hass)
         device_list = dr.async_entries_for_config_entry(
             device_reg, self.config_entry.entry_id
         )
         # First find the Plugwise via_device
         gateway_device = device_reg.async_get_device({(DOMAIN, self.api.gateway_id)})
-        if gateway_device is not None:
-            via_device_id = gateway_device.id
         # Then remove the connected orphaned device(s)
         for device_entry in device_list:
             for identifier in device_entry.identifiers:
-                if (
-                    identifier[0] == DOMAIN
-                    and device_entry.via_device_id == via_device_id
-                    and identifier[1] not in data
-                ):
-                    device_reg.async_update_device(
-                        device_entry.id, remove_config_entry_id=self.config_entry.entry_id
-                    )
-                    LOGGER.debug(
-                        "Removed %s device/zone %s %s from device_registry",
-                        DOMAIN,
-                        device_entry.model,
-                        identifier[1],
-                    )

 from datetime import timedelta
+from packaging.version import Version
 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_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_USERNAME, DOMAIN, LOGGER
 type PlugwiseConfigEntry = ConfigEntry[PlugwiseDataUpdateCoordinator]
     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=timedelta(seconds=60),
             # 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._current_devices: set[str] = set()
         self.new_devices: set[str] = set()
     async def _connect(self) -> None:
         """Connect to the Plugwise Smile."""
         version = await self.api.connect()
         self._connected = isinstance(version, Version)
     async def _async_update_data(self) -> dict[str, GwEntityData]:
         """Fetch data from Plugwise."""
                 translation_key="authentication_failed",
             ) from err
         except (InvalidXMLError, ResponseError) as err:
             raise UpdateFailed(
                 translation_domain=DOMAIN,
                 translation_key="invalid_xml_data",
                 translation_key="unsupported_firmware",
             ) from err
+        self._async_add_remove_devices(data)
         return data
+    def _async_add_remove_devices(self, data: dict[str, GwEntityData]) -> None:
         """Add new Plugwise devices, remove non-existing devices."""
         # Check for new or removed devices
         self.new_devices = set(data) - self._current_devices
         removed_devices = self._current_devices - set(data)
         self._current_devices = set(data)
         if removed_devices:
+            self._async_remove_devices(data)
+    def _async_remove_devices(self, data: dict[str, GwEntityData]) -> None:
         """Clean registries when removed devices found."""
         device_reg = dr.async_get(self.hass)
         device_list = dr.async_entries_for_config_entry(
             device_reg, self.config_entry.entry_id
         )
         # First find the Plugwise via_device
         gateway_device = device_reg.async_get_device({(DOMAIN, self.api.gateway_id)})
+        assert gateway_device is not None
+        via_device_id = gateway_device.id
         # Then remove the connected orphaned device(s)
         for device_entry in device_list:
             for identifier in device_entry.identifiers:
+                if identifier[0] == DOMAIN:
+                    if (
+                        device_entry.via_device_id == via_device_id
+                        and identifier[1] not in data
+                    ):
+                        device_reg.async_update_device(
+                            device_entry.id,
+                            remove_config_entry_id=self.config_entry.entry_id,
+                        )
+                        LOGGER.debug(
+                            "Removed %s device %s %s from device_registry",
+                            DOMAIN,
+                            device_entry.model,
+                            identifier[1],
+                        )

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

@@ -12,19 +12,7 @@
 )
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
-from .const import (
-    AVAILABLE,
-    DOMAIN,
-    FIRMWARE,
-    HARDWARE,
-    MAC_ADDRESS,
-    MODEL,
-    MODEL_ID,
-    VENDOR,
-    ZIGBEE_MAC_ADDRESS,
-)
-# Upstream consts
 from .coordinator import PlugwiseDataUpdateCoordinator
@@ -43,29 +31,26 @@
         self._dev_id = device_id
         configuration_url: str | None = None
-        if (
-            device_id == coordinator.api.gateway_id
-            and (entry := self.coordinator.config_entry)
-        ):
             configuration_url = f"http://{entry.data[CONF_HOST]}"
         data = coordinator.data[device_id]
         connections = set()
-        if mac := data.get(MAC_ADDRESS):
             connections.add((CONNECTION_NETWORK_MAC, mac))
-        if mac := data.get(ZIGBEE_MAC_ADDRESS):
             connections.add((CONNECTION_ZIGBEE, mac))
         self._attr_device_info = DeviceInfo(
             configuration_url=configuration_url,
             identifiers={(DOMAIN, device_id)},
             connections=connections,
-            manufacturer=data.get(VENDOR),
-            model=data.get(MODEL),
-            model_id=data.get(MODEL_ID),
             name=coordinator.api.smile.name,
-            sw_version=data.get(FIRMWARE),
-            hw_version=data.get(HARDWARE),
         )
         if device_id != coordinator.api.gateway_id:
@@ -83,10 +68,8 @@
     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
         )

 )
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
+from .const import AVAILABLE, DOMAIN
 from .coordinator import PlugwiseDataUpdateCoordinator
         self._dev_id = device_id
         configuration_url: str | None = None
+        if entry := self.coordinator.config_entry:
             configuration_url = f"http://{entry.data[CONF_HOST]}"
         data = coordinator.data[device_id]
         connections = set()
+        if mac := data.get("mac_address"):
             connections.add((CONNECTION_NETWORK_MAC, mac))
+        if mac := data.get("zigbee_mac_address"):
             connections.add((CONNECTION_ZIGBEE, mac))
         self._attr_device_info = DeviceInfo(
             configuration_url=configuration_url,
             identifiers={(DOMAIN, device_id)},
             connections=connections,
+            manufacturer=data.get("vendor"),
+            model=data.get("model"),
+            model_id=data.get("model_id"),
             name=coordinator.api.smile.name,
+            sw_version=data.get("firmware"),
+            hw_version=data.get("hardware"),
         )
         if device_id != coordinator.api.gateway_id:
     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
         )

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

@@ -66,11 +66,11 @@
       "dhw_mode": {
         "default": "mdi:shower",
         "state": {
           "comfort": "mdi:sofa",
           "eco": "mdi:leaf",
-          "off": "mdi:circle-off-outline",
-          "boost": "mdi:rocket-launch",
-          "auto": "mdi:auto-mode"
         }
       },
       "gateway_mode": {
@@ -84,11 +84,11 @@
       "regulation_mode": {
         "default": "mdi:hvac",
         "state": {
-          "bleeding_hot": "mdi:fire-circle",
           "bleeding_cold": "mdi:water-circle",
-          "off": "mdi:circle-off-outline",
           "heating": "mdi:radiator",
-          "cooling": "mdi:snowflake"
         }
       },
       "select_schedule": {
@@ -120,8 +120,5 @@
         "default": "mdi:lock"
       }
     }
-  },
-  "services": {
-    "delete_notification": "mdi:trash-can"
   }
 }

       "dhw_mode": {
         "default": "mdi:shower",
         "state": {
+          "auto": "mdi:auto-mode",
+          "boost": "mdi:rocket-launch",
           "comfort": "mdi:sofa",
           "eco": "mdi:leaf",
+          "off": "mdi:circle-off-outline"
         }
       },
       "gateway_mode": {
       "regulation_mode": {
         "default": "mdi:hvac",
         "state": {
           "bleeding_cold": "mdi:water-circle",
+          "bleeding_hot": "mdi:fire-circle",
+          "cooling": "mdi:snowflake",
           "heating": "mdi:radiator",
+          "off": "mdi:circle-off-outline"
         }
       },
       "select_schedule": {
         "default": "mdi:lock"
       }
     }
   }
 }

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

@@ -1,13 +1,13 @@
 {
   "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.11.0"],
-  "version": "0.62.0",
   "zeroconf": ["_plugwise._tcp.local."]
 }

 {
   "domain": "plugwise",
+  "name": "Plugwise",
   "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.10.0"],
   "zeroconf": ["_plugwise._tcp.local."]
 }

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

@@ -14,18 +14,7 @@
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from .const import (
-    LOGGER,
-    LOWER_BOUND,
-    MAX_BOILER_TEMP,
-    MAX_DHW_TEMP,
-    RESOLUTION,
-    TEMPERATURE_OFFSET,
-    UPPER_BOUND,
-    NumberType,
-)
-# Upstream consts
 from .coordinator import PlugwiseConfigEntry, PlugwiseDataUpdateCoordinator
 from .entity import PlugwiseEntity
 from .util import plugwise_command
@@ -40,25 +29,24 @@
     key: NumberType
-# Upstream + is there a reason we didn't rename this one prefixed?
 NUMBER_TYPES = (
     PlugwiseNumberEntityDescription(
-        key=MAX_BOILER_TEMP,
-        translation_key=MAX_BOILER_TEMP,
         device_class=NumberDeviceClass.TEMPERATURE,
         entity_category=EntityCategory.CONFIG,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
     ),
     PlugwiseNumberEntityDescription(
-        key=MAX_DHW_TEMP,
-        translation_key=MAX_DHW_TEMP,
         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,
@@ -71,8 +59,7 @@
     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
@@ -81,28 +68,12 @@
         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)
     _add_entities()
     entry.async_on_unload(coordinator.async_add_listener(_add_entities))
@@ -121,28 +92,26 @@
     ) -> 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
-        if description.key != TEMPERATURE_OFFSET:  # Upstream const
             native_step = max(native_step, 0.5)
         self._attr_native_step = native_step
     @property
-    def native_value(self) -> float | None:
         """Return the present setpoint value."""
-        return self.device.get(self.entity_description.key, {}).get("setpoint")
     @plugwise_command
     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
         )

 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from .const import NumberType
 from .coordinator import PlugwiseConfigEntry, PlugwiseDataUpdateCoordinator
 from .entity import PlugwiseEntity
 from .util import plugwise_command
     key: NumberType
 NUMBER_TYPES = (
     PlugwiseNumberEntityDescription(
+        key="maximum_boiler_temperature",
+        translation_key="maximum_boiler_temperature",
         device_class=NumberDeviceClass.TEMPERATURE,
         entity_category=EntityCategory.CONFIG,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
     ),
     PlugwiseNumberEntityDescription(
+        key="max_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,
     entry: PlugwiseConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
+    """Set up Plugwise number platform."""
     coordinator = entry.runtime_data
     @callback
         if not coordinator.new_devices:
             return
+        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[device_id]
+        )
     _add_entities()
     entry.async_on_unload(coordinator.async_add_listener(_add_entities))
     ) -> 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.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
+    def native_value(self) -> float:
         """Return the present setpoint value."""
+        return self.device[self.entity_description.key]["setpoint"]
     @plugwise_command
     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
         )

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

@@ -10,23 +10,14 @@
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from .const import (
-    AVAILABLE_SCHEDULES,
-    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
@@ -42,37 +33,36 @@
     options_key: SelectOptionsType
-# Upstream
 SELECT_TYPES = (
     PlugwiseSelectEntityDescription(
         key=SELECT_SCHEDULE,
         translation_key=SELECT_SCHEDULE,
         entity_category=EntityCategory.CONFIG,
-        options_key=AVAILABLE_SCHEDULES,
     ),
     PlugwiseSelectEntityDescription(
         key=SELECT_REGULATION_MODE,
         translation_key=SELECT_REGULATION_MODE,
         entity_category=EntityCategory.CONFIG,
-        options_key=REGULATION_MODES,
     ),
     PlugwiseSelectEntityDescription(
         key=SELECT_DHW_MODE,
         translation_key=SELECT_DHW_MODE,
         entity_category=EntityCategory.CONFIG,
-        options_key=DHW_MODES,
     ),
     PlugwiseSelectEntityDescription(
         key=SELECT_GATEWAY_MODE,
         translation_key=SELECT_GATEWAY_MODE,
         entity_category=EntityCategory.CONFIG,
-        options_key=GATEWAY_MODES,
     ),
     PlugwiseSelectEntityDescription(
         key=SELECT_ZONE_PROFILE,
         translation_key=SELECT_ZONE_PROFILE,
         entity_category=EntityCategory.CONFIG,
-        options_key=ZONE_PROFILES,
     ),
 )
@@ -82,7 +72,7 @@
     entry: PlugwiseConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
-    """Set up Plugwise selector from a config entry."""
     coordinator = entry.runtime_data
     @callback
@@ -91,27 +81,12 @@
         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.options_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))
@@ -134,30 +109,25 @@
         self.entity_description = entity_description
         self._location = device_id
-        if (location := self.device.get(LOCATION)) is not None:
             self._location = location
     @property
     def current_option(self) -> str | None:
         """Return the selected entity option to represent the entity state."""
-        return self.device.get(self.entity_description.key)
     @property
     def options(self) -> list[str]:
         """Return the available select-options."""
-        return self.device.get(self.entity_description.options_key, [])
     @plugwise_command
     async def async_select_option(self, option: str) -> None:
         """Change to the selected entity option.
-        Location ID and STATE_ON are required for the thermostat-schedule select.
         """
         await self.coordinator.api.set_select(
             self.entity_description.key, self._location, option, STATE_ON
         )
-        LOGGER.debug(
-            "Set %s to %s was successful",
-            self.entity_description.key,
-            option,
-        )

 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from .const import (
     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
     options_key: SelectOptionsType
 SELECT_TYPES = (
     PlugwiseSelectEntityDescription(
         key=SELECT_SCHEDULE,
         translation_key=SELECT_SCHEDULE,
         entity_category=EntityCategory.CONFIG,
+        options_key="available_schedules",
     ),
     PlugwiseSelectEntityDescription(
         key=SELECT_REGULATION_MODE,
         translation_key=SELECT_REGULATION_MODE,
         entity_category=EntityCategory.CONFIG,
+        options_key="regulation_modes",
     ),
     PlugwiseSelectEntityDescription(
         key=SELECT_DHW_MODE,
         translation_key=SELECT_DHW_MODE,
         entity_category=EntityCategory.CONFIG,
+        options_key="dhw_modes",
     ),
     PlugwiseSelectEntityDescription(
         key=SELECT_GATEWAY_MODE,
         translation_key=SELECT_GATEWAY_MODE,
         entity_category=EntityCategory.CONFIG,
+        options_key="gateway_modes",
     ),
     PlugwiseSelectEntityDescription(
         key=SELECT_ZONE_PROFILE,
         translation_key=SELECT_ZONE_PROFILE,
         entity_category=EntityCategory.CONFIG,
+        options_key="zone_profiles",
     ),
 )
     entry: PlugwiseConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
+    """Set up the Smile selector from a config entry."""
     coordinator = entry.runtime_data
     @callback
         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.options_key)
+        )
     _add_entities()
     entry.async_on_unload(coordinator.async_add_listener(_add_entities))
         self.entity_description = entity_description
         self._location = device_id
+        if (location := self.device.get("location")) is not None:
             self._location = location
     @property
     def current_option(self) -> str | None:
         """Return the selected entity option to represent the entity state."""
+        return self.device[self.entity_description.key]
     @property
     def options(self) -> list[str]:
         """Return the available select-options."""
+        return self.device[self.entity_description.options_key]
     @plugwise_command
     async def async_select_option(self, option: str) -> None:
         """Change to the selected entity option.
+        self._location and STATE_ON are required for the thermostat-schedule select.
         """
         await self.coordinator.api.set_select(
             self.entity_description.key, self._location, option, STATE_ON
         )

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

@@ -13,7 +13,6 @@
     SensorStateClass,
 )
 from homeassistant.const import (
-    ATTR_TEMPERATURE,  # Upstream
     LIGHT_LUX,
     PERCENTAGE,
     EntityCategory,
@@ -28,57 +27,6 @@
 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
@@ -93,301 +41,299 @@
     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,
@@ -407,22 +353,22 @@
         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,
@@ -435,16 +381,16 @@
         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,
@@ -458,8 +404,7 @@
     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
@@ -468,29 +413,13 @@
         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))
@@ -509,10 +438,10 @@
     ) -> None:
         """Initialise the sensor."""
         super().__init__(coordinator, device_id)
-        self.entity_description = description
         self._attr_unique_id = f"{device_id}-{description.key}"
     @property
-    def native_value(self) -> int | float | None:
         """Return the value reported by the sensor."""
-        return self.device.get(SENSORS, {}).get(self.entity_description.key)  # Upstream consts

     SensorStateClass,
 )
 from homeassistant.const import (
     LIGHT_LUX,
     PERCENTAGE,
     EntityCategory,
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from .coordinator import PlugwiseConfigEntry, PlugwiseDataUpdateCoordinator
 from .entity import PlugwiseEntity
     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,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key="modulation_level",
+        translation_key="modulation_level",
         native_unit_of_measurement=PERCENTAGE,
         entity_category=EntityCategory.DIAGNOSTIC,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key="valve_position",
+        translation_key="valve_position",
         native_unit_of_measurement=PERCENTAGE,
         entity_category=EntityCategory.DIAGNOSTIC,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key="water_pressure",
+        translation_key="water_pressure",
         native_unit_of_measurement=UnitOfPressure.BAR,
         device_class=SensorDeviceClass.PRESSURE,
         entity_category=EntityCategory.DIAGNOSTIC,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     PlugwiseSensorEntityDescription(
+        key="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,
     entry: PlugwiseConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
+    """Set up the Smile sensors from a config entry."""
     coordinator = entry.runtime_data
     @callback
         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))
     ) -> None:
         """Initialise the sensor."""
         super().__init__(coordinator, device_id)
         self._attr_unique_id = f"{device_id}-{description.key}"
+        self.entity_description = description
     @property
+    def native_value(self) -> int | float:
         """Return the value reported by the sensor."""
+        return self.device["sensors"][self.entity_description.key]

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

@@ -1,57 +1,47 @@
 {
-  "options": {
-    "step": {
-      "none": {
-        "title": "No Options available",
-        "description": "This Integration does not provide any Options"
-      },
-      "init": {
-        "description": "Adjust Smile/Stretch Options",
-        "data": {
-          "cooling_on": "Anna: cooling-mode is on",
-          "scan_interval": "Scan Interval (seconds) *) beta-only option",
-          "homekit_emulation": "Homekit emulation (i.e. on hvac_off => Away) *) beta-only option",
-          "refresh_interval": "Frontend refresh-time (1.5 - 5 seconds) *) beta-only option"
-        }
-      }
-    }
-  },
   "config": {
     "step": {
       "reconfigure": {
-        "description": "Update configuration for {title}.",
         "data": {
-          "host": "IP-address",
-          "port": "Port number"
-        }
       },
       "user": {
-        "title": "Set up Plugwise Adam/Smile/Stretch",
-        "description": "Enter your Plugwise device: (setup can take up to 90s)",
         "data": {
-          "password": "ID",
-          "username": "Username",
-          "host": "IP-address",
-          "port": "Port number"
-        }
       }
-    },
-    "error": {
-      "cannot_connect": "Failed to connect",
-      "invalid_auth": "Authentication failed",
-      "invalid_setup": "Add your Adam instead of your Anna, see the documentation",
-      "network_down": "Plugwise Zigbee network is down",
-      "network_timeout": "Network communication timeout",
-      "response_error": "Invalid XML data, or error indication received",
-      "stick_init": "Initialization of Plugwise USB-stick failed",
-      "unknown": "Unknown error!",
-      "unsupported": "Device with unsupported firmware"
-    },
-    "abort": {
-      "already_configured": "This device is already configured",
-      "anna_with_adam": "Both Anna and Adam detected. Add your Adam instead of your Anna",
-      "not_the_same_smile": "The configured Smile ID does not match the Smile ID on the requested IP address.",
-      "reconfigure_successful": "Reconfiguration successful"
     }
   },
   "entity": {
@@ -62,6 +52,9 @@
       "cooling_enabled": {
         "name": "Cooling enabled"
       },
       "dhw_state": {
         "name": "DHW state"
       },
@@ -69,16 +62,13 @@
         "name": "Flame state"
       },
       "heating_state": {
-        "name": "Heating"
       },
-      "cooling_state": {
-        "name": "Cooling"
       },
       "secondary_boiler_state": {
         "name": "Secondary boiler state"
-      },
-      "plugwise_notification": {
-        "name": "Plugwise notification"
       }
     },
     "button": {
@@ -89,25 +79,31 @@
     "climate": {
       "plugwise": {
         "state_attributes": {
           "preset_mode": {
             "state": {
               "asleep": "Night",
-              "away": "Away",
-              "home": "Home",
               "no_frost": "Anti-frost",
               "vacation": "Vacation"
             }
           }
         }
       }
     },
     "number": {
-      "maximum_boiler_temperature": {
-        "name": "Maximum boiler temperature setpoint"
-      },
       "max_dhw_temperature": {
         "name": "Domestic hot water setpoint"
       },
       "temperature_offset": {
         "name": "Temperature offset"
       }
@@ -116,194 +112,194 @@
       "select_dhw_mode": {
         "name": "DHW mode",
         "state": {
-          "auto": "Auto",
-          "boost": "Boost",
-          "comfort": "Comfort",
-          "off": "Off"
-        }
-      },
-      "select_regulation_mode": {
-        "name": "Regulation mode",
-        "state": {
-          "bleeding_cold": "Bleeding cold",
-          "bleeding_hot": "Bleeding hot",
-          "cooling": "Cooling",
-          "heating": "Heating",
-          "off": "Off"
         }
       },
       "select_gateway_mode": {
         "name": "Gateway mode",
         "state": {
           "away": "Pause",
-          "full": "Normal",
           "vacation": "Vacation"
         }
       },
       "select_schedule": {
         "name": "Thermostat schedule",
         "state": {
-          "off": "Off"
         }
       },
       "select_zone_profile": {
         "name": "Zone profile",
         "state": {
-          "active": "Active",
-          "off": "Off",
           "passive": "Passive"
         }
       }
     },
     "sensor": {
-      "setpoint": {
-        "name": "Setpoint"
-      },
       "cooling_setpoint": {
         "name": "Cooling setpoint"
       },
-      "heating_setpoint": {
-        "name": "Heating setpoint"
-      },
-      "intended_boiler_temperature": {
-        "name": "Intended boiler temperature"
-      },
-      "temperature_difference": {
-        "name": "Temperature difference"
-      },
-      "outdoor_temperature": {
-        "name": "Outdoor temperature"
-      },
-      "outdoor_air_temperature": {
-        "name": "Outdoor air temperature"
-      },
-      "water_temperature": {
-        "name": "Water temperature"
       },
-      "return_temperature": {
-        "name": "Return temperature"
       },
       "electricity_consumed": {
         "name": "Electricity consumed"
       },
-      "electricity_produced": {
-        "name": "Electricity produced"
-      },
-      "electricity_consumed_point": {
-        "name": "Electricity consumed point"
-      },
-      "electricity_produced_point": {
-        "name": "Electricity produced point"
-      },
       "electricity_consumed_interval": {
         "name": "Electricity consumed interval"
       },
-      "electricity_consumed_peak_interval": {
-        "name": "Electricity consumed peak interval"
       },
       "electricity_consumed_off_peak_interval": {
         "name": "Electricity consumed off-peak interval"
       },
-      "electricity_produced_interval": {
-        "name": "Electricity produced interval"
-      },
-      "electricity_produced_peak_interval": {
-        "name": "Electricity produced peak interval"
-      },
-      "electricity_produced_off_peak_interval": {
-        "name": "Electricity produced off-peak interval"
-      },
       "electricity_consumed_off_peak_point": {
         "name": "Electricity consumed off-peak point"
       },
-      "electricity_consumed_peak_point": {
-        "name": "Electricity consumed peak point"
-      },
-      "electricity_consumed_off_peak_cumulative": {
-        "name": "Electricity consumed off-peak cumulative"
-      },
       "electricity_consumed_peak_cumulative": {
         "name": "Electricity consumed peak cumulative"
       },
-      "electricity_produced_off_peak_point": {
-        "name": "Electricity produced off-peak point"
-      },
-      "electricity_produced_peak_point": {
-        "name": "Electricity produced peak point"
       },
-      "electricity_produced_off_peak_cumulative": {
-        "name": "Electricity produced off-peak cumulative"
       },
-      "electricity_produced_peak_cumulative": {
-        "name": "Electricity produced peak cumulative"
       },
       "electricity_phase_one_consumed": {
         "name": "Electricity phase one consumed"
       },
-      "electricity_phase_two_consumed": {
-        "name": "Electricity phase two consumed"
       },
       "electricity_phase_three_consumed": {
         "name": "Electricity phase three consumed"
       },
-      "electricity_phase_one_produced": {
-        "name": "Electricity phase one produced"
       },
       "electricity_phase_two_produced": {
         "name": "Electricity phase two produced"
       },
-      "electricity_phase_three_produced": {
-        "name": "Electricity phase three produced"
       },
-      "voltage_phase_one": {
-        "name": "Voltage phase one"
       },
-      "voltage_phase_two": {
-        "name": "Voltage phase two"
       },
-      "voltage_phase_three": {
-        "name": "Voltage phase three"
       },
-      "gas_consumed_interval": {
-        "name": "Gas consumed interval"
       },
       "gas_consumed_cumulative": {
         "name": "Gas consumed cumulative"
       },
-      "net_electricity_point": {
-        "name": "Net electricity point"
       },
-      "net_electricity_cumulative": {
-        "name": "Net electricity cumulative"
       },
       "modulation_level": {
         "name": "Modulation level"
       },
       "valve_position": {
         "name": "Valve position"
       },
-      "water_pressure": {
-        "name": "Water pressure"
       },
-      "dhw_temperature": {
-        "name": "DHW temperature"
       },
-      "domestic_hot_water_setpoint": {
-        "name": "DHW setpoint"
       },
-      "maximum_boiler_temperature": {
-        "name": "Maximum boiler temperature setpoint"
       }
     },
     "switch": {
       "cooling_ena_switch": {
-        "name": "Cooling"
       },
       "dhw_cm_switch": {
         "name": "DHW comfort mode"
       },
       "lock": {
-        "name": "Lock"
       },
       "relay": {
         "name": "Relay"
@@ -312,7 +308,7 @@
   },
   "exceptions": {
     "authentication_failed": {
-      "message": "Invalid authentication"
     },
     "data_incomplete_or_missing": {
       "message": "Data incomplete or missing."
@@ -321,22 +317,16 @@
       "message": "Error communicating with API: {error}."
     },
     "failed_to_connect": {
-      "message": "Failed to connect"
     },
     "invalid_xml_data": {
-      "message": "Invalid XML data, or error indication received from the Plugwise Adam/Smile/Stretch"
     },
     "set_schedule_first": {
       "message": "Failed setting HVACMode, set a schedule first."
     },
     "unsupported_firmware": {
-      "message": "Device with unsupported firmware"
-    }
-  },
-  "services": {
-    "delete_notification": {
-      "name": "Delete Plugwise notification",
-      "description": "Deletes a Plugwise Notification"
     }
   }
 }

 {
   "config": {
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_service%]",
+      "anna_with_adam": "Both Anna and Adam detected. Add your Adam instead of your Anna",
+      "not_the_same_smile": "The configured Smile ID does not match the Smile ID on the requested IP address.",
+      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]"
+    },
+    "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "invalid_setup": "Add your Adam instead of your Anna, see the documentation",
+      "response_error": "Invalid XML data, or error indication received",
+      "unknown": "[%key:common::config_flow::error::unknown%]",
+      "unsupported": "Device with unsupported firmware"
+    },
     "step": {
       "reconfigure": {
         "data": {
+          "host": "[%key:common::config_flow::data::ip%]",
+          "port": "[%key:common::config_flow::data::port%]"
+        },
+        "data_description": {
+          "host": "[%key:component::plugwise::config::step::user::data_description::host%]",
+          "port": "[%key:component::plugwise::config::step::user::data_description::port%]"
+        },
+        "description": "Update configuration for {title}."
       },
       "user": {
         "data": {
+          "host": "[%key:common::config_flow::data::ip%]",
+          "password": "Smile ID",
+          "port": "[%key:common::config_flow::data::port%]",
+          "username": "Smile username"
+        },
+        "data_description": {
+          "host": "The hostname or IP address of your Smile. You can find it in your router or the Plugwise app.",
+          "password": "The Smile ID printed on the label on the back of your Adam, Smile-T, or P1.",
+          "port": "By default your Smile uses port 80, normally you should not have to change this.",
+          "username": "Default is `smile`, or `stretch` for the legacy Stretch."
+        },
+        "description": "Please enter",
+        "title": "Connect to the Smile"
       }
     }
   },
   "entity": {
       "cooling_enabled": {
         "name": "Cooling enabled"
       },
+      "cooling_state": {
+        "name": "[%key:component::climate::entity_component::_::state_attributes::hvac_action::state::cooling%]"
+      },
       "dhw_state": {
         "name": "DHW state"
       },
         "name": "Flame state"
       },
       "heating_state": {
+        "name": "[%key:component::climate::entity_component::_::state_attributes::hvac_action::state::heating%]"
       },
+      "plugwise_notification": {
+        "name": "Plugwise notification"
       },
       "secondary_boiler_state": {
         "name": "Secondary boiler state"
       }
     },
     "button": {
     "climate": {
       "plugwise": {
         "state_attributes": {
+          "available_schemas": {
+            "name": "Available schemas"
+          },
           "preset_mode": {
             "state": {
               "asleep": "Night",
+              "away": "[%key:common::state::not_home%]",
+              "home": "[%key:common::state::home%]",
               "no_frost": "Anti-frost",
               "vacation": "Vacation"
             }
+          },
+          "selected_schema": {
+            "name": "Selected schema"
           }
         }
       }
     },
     "number": {
       "max_dhw_temperature": {
         "name": "Domestic hot water setpoint"
       },
+      "maximum_boiler_temperature": {
+        "name": "Maximum boiler temperature setpoint"
+      },
       "temperature_offset": {
         "name": "Temperature offset"
       }
       "select_dhw_mode": {
         "name": "DHW mode",
         "state": {
+          "auto": "[%key:common::state::auto%]",
+          "boost": "[%key:component::climate::entity_component::_::state_attributes::preset_mode::state::boost%]",
+          "comfort": "[%key:component::climate::entity_component::_::state_attributes::preset_mode::state::comfort%]",
+          "off": "[%key:common::state::off%]"
         }
       },
       "select_gateway_mode": {
         "name": "Gateway mode",
         "state": {
           "away": "Pause",
+          "full": "[%key:common::state::normal%]",
           "vacation": "Vacation"
         }
       },
+      "select_regulation_mode": {
+        "name": "Regulation mode",
+        "state": {
+          "bleeding_cold": "Bleeding cold",
+          "bleeding_hot": "Bleeding hot",
+          "cooling": "[%key:component::climate::entity_component::_::state_attributes::hvac_action::state::cooling%]",
+          "heating": "[%key:component::climate::entity_component::_::state_attributes::hvac_action::state::heating%]",
+          "off": "[%key:common::state::off%]"
+        }
+      },
       "select_schedule": {
         "name": "Thermostat schedule",
         "state": {
+          "off": "[%key:common::state::off%]"
         }
       },
       "select_zone_profile": {
         "name": "Zone profile",
         "state": {
+          "active": "[%key:common::state::active%]",
+          "off": "[%key:common::state::off%]",
           "passive": "Passive"
         }
       }
     },
     "sensor": {
       "cooling_setpoint": {
         "name": "Cooling setpoint"
       },
+      "dhw_temperature": {
+        "name": "DHW temperature"
       },
+      "domestic_hot_water_setpoint": {
+        "name": "DHW setpoint"
       },
       "electricity_consumed": {
         "name": "Electricity consumed"
       },
       "electricity_consumed_interval": {
         "name": "Electricity consumed interval"
       },
+      "electricity_consumed_off_peak_cumulative": {
+        "name": "Electricity consumed off-peak cumulative"
       },
       "electricity_consumed_off_peak_interval": {
         "name": "Electricity consumed off-peak interval"
       },
       "electricity_consumed_off_peak_point": {
         "name": "Electricity consumed off-peak point"
       },
       "electricity_consumed_peak_cumulative": {
         "name": "Electricity consumed peak cumulative"
       },
+      "electricity_consumed_peak_interval": {
+        "name": "Electricity consumed peak interval"
       },
+      "electricity_consumed_peak_point": {
+        "name": "Electricity consumed peak point"
       },
+      "electricity_consumed_point": {
+        "name": "Electricity consumed point"
       },
       "electricity_phase_one_consumed": {
         "name": "Electricity phase one consumed"
       },
+      "electricity_phase_one_produced": {
+        "name": "Electricity phase one produced"
       },
       "electricity_phase_three_consumed": {
         "name": "Electricity phase three consumed"
       },
+      "electricity_phase_three_produced": {
+        "name": "Electricity phase three produced"
+      },
+      "electricity_phase_two_consumed": {
+        "name": "Electricity phase two consumed"
       },
       "electricity_phase_two_produced": {
         "name": "Electricity phase two produced"
       },
+      "electricity_produced": {
+        "name": "Electricity produced"
       },
+      "electricity_produced_interval": {
+        "name": "Electricity produced interval"
       },
+      "electricity_produced_off_peak_cumulative": {
+        "name": "Electricity produced off-peak cumulative"
       },
+      "electricity_produced_off_peak_interval": {
+        "name": "Electricity produced off-peak interval"
       },
+      "electricity_produced_off_peak_point": {
+        "name": "Electricity produced off-peak point"
+      },
+      "electricity_produced_peak_cumulative": {
+        "name": "Electricity produced peak cumulative"
+      },
+      "electricity_produced_peak_interval": {
+        "name": "Electricity produced peak interval"
+      },
+      "electricity_produced_peak_point": {
+        "name": "Electricity produced peak point"
+      },
+      "electricity_produced_point": {
+        "name": "Electricity produced point"
       },
       "gas_consumed_cumulative": {
         "name": "Gas consumed cumulative"
       },
+      "gas_consumed_interval": {
+        "name": "Gas consumed interval"
       },
+      "heating_setpoint": {
+        "name": "Heating setpoint"
+      },
+      "intended_boiler_temperature": {
+        "name": "Intended boiler temperature"
+      },
+      "maximum_boiler_temperature": {
+        "name": "Maximum boiler temperature"
       },
       "modulation_level": {
         "name": "Modulation level"
       },
+      "net_electricity_cumulative": {
+        "name": "Net electricity cumulative"
+      },
+      "net_electricity_point": {
+        "name": "Net electricity point"
+      },
+      "outdoor_air_temperature": {
+        "name": "Outdoor air temperature"
+      },
+      "outdoor_temperature": {
+        "name": "Outdoor temperature"
+      },
+      "return_temperature": {
+        "name": "Return temperature"
+      },
+      "setpoint": {
+        "name": "Setpoint"
+      },
+      "temperature_difference": {
+        "name": "Temperature difference"
+      },
       "valve_position": {
         "name": "Valve position"
       },
+      "voltage_phase_one": {
+        "name": "Voltage phase one"
       },
+      "voltage_phase_three": {
+        "name": "Voltage phase three"
       },
+      "voltage_phase_two": {
+        "name": "Voltage phase two"
       },
+      "water_pressure": {
+        "name": "Water pressure"
+      },
+      "water_temperature": {
+        "name": "Water temperature"
       }
     },
     "switch": {
       "cooling_ena_switch": {
+        "name": "[%key:component::climate::entity_component::_::state_attributes::hvac_action::state::cooling%]"
       },
       "dhw_cm_switch": {
         "name": "DHW comfort mode"
       },
       "lock": {
+        "name": "[%key:component::lock::title%]"
       },
       "relay": {
         "name": "Relay"
   },
   "exceptions": {
     "authentication_failed": {
+      "message": "[%key:common::config_flow::error::invalid_auth%]"
     },
     "data_incomplete_or_missing": {
       "message": "Data incomplete or missing."
       "message": "Error communicating with API: {error}."
     },
     "failed_to_connect": {
+      "message": "[%key:common::config_flow::error::cannot_connect%]"
     },
     "invalid_xml_data": {
+      "message": "[%key:component::plugwise::config::error::response_error%]"
     },
     "set_schedule_first": {
       "message": "Failed setting HVACMode, set a schedule first."
     },
     "unsupported_firmware": {
+      "message": "[%key:component::plugwise::config::error::unsupported%]"
     }
   }
 }

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

@@ -16,17 +16,6 @@
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from .const import (
-    COOLING_ENA_SWITCH,
-    DHW_CM_SWITCH,
-    LOCK,
-    LOGGER,  # pw-beta
-    MEMBERS,
-    RELAY,
-    SWITCHES,
-)
-# Upstream consts
 from .coordinator import PlugwiseConfigEntry, PlugwiseDataUpdateCoordinator
 from .entity import PlugwiseEntity
 from .util import plugwise_command
@@ -41,29 +30,25 @@
     key: SwitchType
-# Upstream consts
-PLUGWISE_SWITCHES: tuple[PlugwiseSwitchEntityDescription, ...] = (
     PlugwiseSwitchEntityDescription(
-        key=DHW_CM_SWITCH,
-        translation_key=DHW_CM_SWITCH,
-        device_class=SwitchDeviceClass.SWITCH,
         entity_category=EntityCategory.CONFIG,
     ),
     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,
     ),
 )
@@ -74,7 +59,7 @@
     entry: PlugwiseConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
-    """Set up Plugwise switches from a config entry."""
     coordinator = entry.runtime_data
     @callback
@@ -83,28 +68,13 @@
         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()
     entry.async_on_unload(coordinator.async_add_listener(_add_entities))
@@ -123,30 +93,30 @@
     ) -> None:
         """Set up the Plugwise API."""
         super().__init__(coordinator, device_id)
-        self.entity_description = description
         self._attr_unique_id = f"{device_id}-{description.key}"
     @property
-    def is_on(self) -> bool | None:
         """Return True if entity is on."""
-        return self.device.get(SWITCHES, {}).get(self.entity_description.key) # Upstream const
     @plugwise_command
     async def async_turn_on(self, **kwargs: Any) -> None:
         """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
     async def async_turn_off(self, **kwargs: Any) -> None:
         """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

 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from .coordinator import PlugwiseConfigEntry, PlugwiseDataUpdateCoordinator
 from .entity import PlugwiseEntity
 from .util import plugwise_command
     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,
     ),
 )
     entry: PlugwiseConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
+    """Set up the Smile switches from a config entry."""
     coordinator = entry.runtime_data
     @callback
         if not coordinator.new_devices:
             return
+        async_add_entities(
+            PlugwiseSwitchEntity(coordinator, device_id, description)
+            for device_id in coordinator.new_devices
+            if (switches := coordinator.data[device_id].get("switches"))
+            for description in SWITCHES
+            if description.key in switches
+        )
     _add_entities()
     entry.async_on_unload(coordinator.async_add_listener(_add_entities))
     ) -> 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
+    def is_on(self) -> bool:
         """Return True if entity is on."""
+        return self.device["switches"][self.entity_description.key]
     @plugwise_command
     async def async_turn_on(self, **kwargs: Any) -> None:
         """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
     async def async_turn_off(self, **kwargs: Any) -> None:
         """Turn the device off."""
         await self.coordinator.api.set_switch_state(
             self._dev_id,
+            self.device.get("members"),
             self.entity_description.key,
             "off",
+        )

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

@@ -1,7 +1,5 @@
 """Utilities for Plugwise."""
-from __future__ import annotations
 from collections.abc import Awaitable, Callable, Coroutine
 from typing import Any, Concatenate
@@ -12,15 +10,10 @@
 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,
@@ -28,8 +21,8 @@
     """
     async def handler(
-        self: PlugwiseEntityT, *args: P.args, **kwargs: P.kwargs
-    ) -> R:
         try:
             return await func(self, *args, **kwargs)
         except PlugwiseException as err:

 """Utilities for Plugwise."""
 from collections.abc import Awaitable, Callable, Coroutine
 from typing import Any, Concatenate
 from .const import DOMAIN
 from .entity import PlugwiseEntity
+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: