Bump version to 2026.7.0b2

Co-authored-by: Claude <noreply@anthropic.com>

CODEOWNERS

@@ -181,7 +181,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/asuswrt/ @kennedyshead @ollo69 @Vaskivskyi
 /homeassistant/components/atag/ @MatsNL
 /tests/components/atag/ @MatsNL
-/homeassistant/components/aten_pe/ @mtdcr
 /homeassistant/components/atome/ @baqs
 /homeassistant/components/august/ @bdraco
 /tests/components/august/ @bdraco
@@ -230,7 +229,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/battery/ @home-assistant/core
 /homeassistant/components/bayesian/ @HarvsG
 /tests/components/bayesian/ @HarvsG
-/homeassistant/components/beewi_smartclim/ @alemuro
 /homeassistant/components/binary_sensor/ @home-assistant/core
 /tests/components/binary_sensor/ @home-assistant/core
 /homeassistant/components/bizkaibus/ @UgaitzEtxebarria

homeassistant/components/aemet/coordinator.py

@@ -27,7 +27,7 @@ from .const import CONDITIONS_MAP, DOMAIN, FORECAST_MAP
 _LOGGER = logging.getLogger(__name__)
 
 API_TIMEOUT: Final[int] = 120
-WEATHER_UPDATE_INTERVAL = timedelta(minutes=10)
+WEATHER_UPDATE_INTERVAL = timedelta(minutes=20)
 
 type AemetConfigEntry = ConfigEntry[AemetData]
 

homeassistant/components/alexa_devices/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["aioamazondevices"],
   "quality_scale": "platinum",
-  "requirements": ["aioamazondevices==14.1.3"]
+  "requirements": ["aioamazondevices==14.1.8"]
 }

homeassistant/components/alexa_devices/utils.py

@@ -28,7 +28,7 @@ async def async_update_unique_id(
     for serial_num in coordinator.data:
         unique_id = f"{serial_num}-{old_key}"
         if entity_id := entity_registry.async_get_entity_id(
-            DOMAIN, platform, unique_id
+            platform, DOMAIN, unique_id
         ):
             _LOGGER.debug("Updating unique_id for %s", entity_id)
             new_unique_id = unique_id.replace(old_key, new_key)
@@ -48,7 +48,7 @@ async def async_remove_entity_from_virtual_group(
 
     for serial_num in coordinator.data:
         unique_id = f"{serial_num}-{key}"
-        entity_id = entity_registry.async_get_entity_id(DOMAIN, platform, unique_id)
+        entity_id = entity_registry.async_get_entity_id(platform, DOMAIN, unique_id)
         is_group = coordinator.data[serial_num].device_family == SPEAKER_GROUP_FAMILY
         if entity_id and is_group:
             entity_registry.async_remove(entity_id)
@@ -70,7 +70,7 @@ async def async_remove_unsupported_notification_sensors(
         ):
             unique_id = f"{serial_num}-{notification_key}"
             entity_id = entity_registry.async_get_entity_id(
-                DOMAIN, SENSOR_DOMAIN, unique_id=unique_id
+                SENSOR_DOMAIN, DOMAIN, unique_id=unique_id
             )
             is_unsupported = not coordinator.data[serial_num].notifications_supported
 

homeassistant/components/anglian_water/manifest.json

@@ -9,5 +9,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["pyanglianwater"],
   "quality_scale": "bronze",
-  "requirements": ["pyanglianwater==3.2.2"]
+  "requirements": ["pyanglianwater==3.2.3"]
 }

homeassistant/components/aten_pe/__init__.py

@@ -1 +0,0 @@
-"""The ATEN PE component."""

homeassistant/components/aten_pe/manifest.json

@@ -1,9 +0,0 @@
-{
-  "domain": "aten_pe",
-  "name": "ATEN Rack PDU",
-  "codeowners": ["@mtdcr"],
-  "documentation": "https://www.home-assistant.io/integrations/aten_pe",
-  "iot_class": "local_polling",
-  "quality_scale": "legacy",
-  "requirements": ["atenpdu==0.3.6"]
-}

homeassistant/components/aten_pe/switch.py

@@ -1,119 +0,0 @@
-"""The ATEN PE switch component."""
-
-import logging
-from typing import Any, override
-
-from atenpdu import AtenPE, AtenPEError
-import voluptuous as vol
-
-from homeassistant.components.switch import (
-    PLATFORM_SCHEMA as SWITCH_PLATFORM_SCHEMA,
-    SwitchDeviceClass,
-    SwitchEntity,
-)
-from homeassistant.const import CONF_HOST, CONF_PORT, CONF_USERNAME
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import PlatformNotReady
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC, DeviceInfo
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
-
-_LOGGER = logging.getLogger(__name__)
-
-CONF_AUTH_KEY = "auth_key"
-CONF_COMMUNITY = "community"
-CONF_PRIV_KEY = "priv_key"
-DEFAULT_COMMUNITY = "private"
-DEFAULT_PORT = "161"
-DEFAULT_USERNAME = "administrator"
-
-PLATFORM_SCHEMA = SWITCH_PLATFORM_SCHEMA.extend(
-    {
-        vol.Required(CONF_HOST): cv.string,
-        vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
-        vol.Optional(CONF_COMMUNITY, default=DEFAULT_COMMUNITY): cv.string,
-        vol.Optional(CONF_USERNAME, default=DEFAULT_USERNAME): cv.string,
-        vol.Optional(CONF_AUTH_KEY): cv.string,
-        vol.Optional(CONF_PRIV_KEY): cv.string,
-    }
-)
-
-
-async def async_setup_platform(
-    hass: HomeAssistant,
-    config: ConfigType,
-    async_add_entities: AddEntitiesCallback,
-    discovery_info: DiscoveryInfoType | None = None,
-) -> None:
-    """Set up the ATEN PE switch."""
-    node = config[CONF_HOST]
-    serv = config[CONF_PORT]
-
-    dev = AtenPE(
-        node=node,
-        serv=serv,
-        community=config[CONF_COMMUNITY],
-        username=config[CONF_USERNAME],
-        authkey=config.get(CONF_AUTH_KEY),
-        privkey=config.get(CONF_PRIV_KEY),
-    )
-
-    try:
-        await hass.async_add_executor_job(dev.initialize)
-        mac = await dev.deviceMAC()
-        outlets = dev.outlets()
-        name = await dev.deviceName()
-        model = await dev.modelName()
-        sw_version = await dev.deviceFWversion()
-    except AtenPEError as exc:
-        _LOGGER.error("Failed to initialize %s:%s: %s", node, serv, str(exc))
-        raise PlatformNotReady from exc
-
-    info = DeviceInfo(
-        connections={(CONNECTION_NETWORK_MAC, mac)},
-        manufacturer="ATEN",
-        model=model,
-        name=name,
-        sw_version=sw_version,
-    )
-
-    async_add_entities(
-        (AtenSwitch(dev, info, mac, outlet.id, outlet.name) for outlet in outlets), True
-    )
-
-
-class AtenSwitch(SwitchEntity):
-    """Represents an ATEN PE switch."""
-
-    _attr_device_class = SwitchDeviceClass.OUTLET
-
-    def __init__(
-        self, device: AtenPE, info: DeviceInfo, mac: str, outlet: str, name: str
-    ) -> None:
-        """Initialize an ATEN PE switch."""
-        self._device = device
-        self._outlet = outlet
-        self._attr_device_info = info
-        self._attr_unique_id = f"{mac}-{outlet}"
-        self._attr_name = name or f"Outlet {outlet}"
-
-    @override
-    async def async_turn_on(self, **kwargs: Any) -> None:
-        """Turn the switch on."""
-        await self._device.setOutletStatus(self._outlet, "on")
-        self._attr_is_on = True
-
-    @override
-    async def async_turn_off(self, **kwargs: Any) -> None:
-        """Turn the switch off."""
-        await self._device.setOutletStatus(self._outlet, "off")
-        self._attr_is_on = False
-
-    async def async_update(self) -> None:
-        """Process update from entity."""
-        status = await self._device.displayOutletStatus(self._outlet)
-        if status == "on":
-            self._attr_is_on = True
-        elif status == "off":
-            self._attr_is_on = False

homeassistant/components/automation/__init__.py

@@ -731,17 +731,32 @@ class AutomationEntity(BaseAutomationEntity, RestoreEntity):
             trace_element = TraceElement(variables, trigger_path)
             trace_append_element(trace_element)
 
-            if (
-                not skip_condition
-                and self._condition is not None
-                and not self._condition.async_check(variables=variables)
-            ):
-                self._logger.debug(
-                    "Conditions not met, aborting automation. Condition summary: %s",
-                    trace_get(clear=False),
-                )
-                script_execution_set("failed_conditions")
-                return None
+            if not skip_condition and self._condition is not None:
+                try:
+                    conditions_pass = self._condition.async_check(variables=variables)
+                except (vol.Invalid, HomeAssistantError) as err:
+                    self._logger.error(
+                        "Error while checking conditions of automation %s: %s",
+                        self.entity_id,
+                        err,
+                    )
+                    automation_trace.set_error(err)
+                    return None
+                except Exception as err:
+                    self._logger.exception(
+                        "Unexpected error while checking conditions of automation %s",
+                        self.entity_id,
+                    )
+                    automation_trace.set_error(err)
+                    return None
+
+                if not conditions_pass:
+                    self._logger.debug(
+                        "Conditions not met, aborting automation. Condition summary: %s",
+                        trace_get(clear=False),
+                    )
+                    script_execution_set("failed_conditions")
+                    return None
 
             self.async_set_context(trigger_context)
             event_data = {
@@ -794,7 +809,9 @@ class AutomationEntity(BaseAutomationEntity, RestoreEntity):
                 )
                 automation_trace.set_error(err)
             except Exception as err:
-                self._logger.exception("While executing automation %s", self.entity_id)
+                self._logger.exception(
+                    "Unexpected error while executing automation %s", self.entity_id
+                )
                 automation_trace.set_error(err)
 
             return None

homeassistant/components/avion/__init__.py

@@ -1 +0,0 @@
-"""The avion component."""

homeassistant/components/avion/light.py

@@ -1,123 +0,0 @@
-"""Support for Avion dimmers."""
-
-import importlib
-import time
-from typing import Any, override
-
-import voluptuous as vol
-
-from homeassistant.components.light import (
-    ATTR_BRIGHTNESS,
-    PLATFORM_SCHEMA as LIGHT_PLATFORM_SCHEMA,
-    ColorMode,
-    LightEntity,
-)
-from homeassistant.const import (
-    CONF_API_KEY,
-    CONF_DEVICES,
-    CONF_ID,
-    CONF_NAME,
-    CONF_PASSWORD,
-    CONF_USERNAME,
-)
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
-
-DEVICE_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_API_KEY): cv.string,
-        vol.Optional(CONF_ID): cv.positive_int,
-        vol.Optional(CONF_NAME): cv.string,
-    }
-)
-
-PLATFORM_SCHEMA = LIGHT_PLATFORM_SCHEMA.extend(
-    {
-        vol.Optional(CONF_DEVICES, default={}): {cv.string: DEVICE_SCHEMA},
-        vol.Optional(CONF_USERNAME): cv.string,
-        vol.Optional(CONF_PASSWORD): cv.string,
-    }
-)
-
-
-def setup_platform(
-    hass: HomeAssistant,
-    config: ConfigType,
-    add_entities: AddEntitiesCallback,
-    discovery_info: DiscoveryInfoType | None = None,
-) -> None:
-    """Set up an Avion switch."""
-    avion = importlib.import_module("avion")
-
-    lights = [
-        AvionLight(
-            avion.Avion(
-                mac=address,
-                passphrase=device_config[CONF_API_KEY],
-                name=device_config.get(CONF_NAME),
-                object_id=device_config.get(CONF_ID),
-                connect=False,
-            )
-        )
-        for address, device_config in config[CONF_DEVICES].items()
-    ]
-    if CONF_USERNAME in config and CONF_PASSWORD in config:
-        lights.extend(
-            AvionLight(device)
-            for device in avion.get_devices(
-                config[CONF_USERNAME], config[CONF_PASSWORD]
-            )
-        )
-
-    add_entities(lights)
-
-
-class AvionLight(LightEntity):
-    """Representation of an Avion light."""
-
-    _attr_support_color_mode = ColorMode.BRIGHTNESS
-    _attr_support_color_modes = {ColorMode.BRIGHTNESS}
-    _attr_should_poll = False
-    _attr_assumed_state = True
-    _attr_is_on = True
-
-    def __init__(self, device):
-        """Initialize the light."""
-        self._attr_name = device.name
-        self._attr_unique_id = device.mac
-        self._attr_brightness = 255
-        self._switch = device
-
-    def set_state(self, brightness):
-        """Set the state of this lamp to the provided brightness."""
-        avion = importlib.import_module("avion")
-
-        # Bluetooth LE is unreliable, and the connection may drop at any
-        # time. Make an effort to re-establish the link.
-        initial = time.monotonic()
-        while True:
-            if time.monotonic() - initial >= 10:
-                return False
-            try:
-                self._switch.set_brightness(brightness)
-                break
-            except avion.AvionException:
-                self._switch.connect()
-        return True
-
-    @override
-    def turn_on(self, **kwargs: Any) -> None:
-        """Turn the specified or all lights on."""
-        if (brightness := kwargs.get(ATTR_BRIGHTNESS)) is not None:
-            self._attr_brightness = brightness
-
-        self.set_state(self.brightness)
-        self._attr_is_on = True
-
-    @override
-    def turn_off(self, **kwargs: Any) -> None:
-        """Turn the specified or all lights off."""
-        self.set_state(0)
-        self._attr_is_on = False

homeassistant/components/avion/manifest.json

@@ -1,9 +0,0 @@
-{
-  "domain": "avion",
-  "name": "Avi-on",
-  "codeowners": [],
-  "documentation": "https://www.home-assistant.io/integrations/avion",
-  "iot_class": "assumed_state",
-  "quality_scale": "legacy",
-  "requirements": ["avion==0.10"]
-}

homeassistant/components/beewi_smartclim/__init__.py

@@ -1 +0,0 @@
-"""The beewi_smartclim component."""

homeassistant/components/beewi_smartclim/manifest.json

@@ -1,10 +0,0 @@
-{
-  "domain": "beewi_smartclim",
-  "name": "BeeWi SmartClim BLE sensor",
-  "codeowners": ["@alemuro"],
-  "documentation": "https://www.home-assistant.io/integrations/beewi_smartclim",
-  "iot_class": "local_polling",
-  "loggers": ["beewi_smartclim"],
-  "quality_scale": "legacy",
-  "requirements": ["beewi-smartclim==0.0.10"]
-}

homeassistant/components/beewi_smartclim/sensor.py

@@ -1,84 +0,0 @@
-"""Platform for beewi_smartclim integration."""
-
-from beewi_smartclim import BeewiSmartClimPoller
-import voluptuous as vol
-
-from homeassistant.components.sensor import (
-    PLATFORM_SCHEMA as SENSOR_PLATFORM_SCHEMA,
-    SensorDeviceClass,
-    SensorEntity,
-)
-from homeassistant.const import CONF_MAC, CONF_NAME, PERCENTAGE, UnitOfTemperature
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
-
-# Default values
-DEFAULT_NAME = "BeeWi SmartClim"
-
-# Sensor config
-SENSOR_TYPES = [
-    [SensorDeviceClass.TEMPERATURE, "Temperature", UnitOfTemperature.CELSIUS],
-    [SensorDeviceClass.HUMIDITY, "Humidity", PERCENTAGE],
-    [SensorDeviceClass.BATTERY, "Battery", PERCENTAGE],
-]
-
-PLATFORM_SCHEMA = SENSOR_PLATFORM_SCHEMA.extend(
-    {
-        vol.Required(CONF_MAC): cv.string,
-        vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
-    }
-)
-
-
-def setup_platform(
-    hass: HomeAssistant,
-    config: ConfigType,
-    add_entities: AddEntitiesCallback,
-    discovery_info: DiscoveryInfoType | None = None,
-) -> None:
-    """Set up the beewi_smartclim platform."""
-
-    mac = config[CONF_MAC]
-    prefix = config[CONF_NAME]
-    poller = BeewiSmartClimPoller(mac)
-
-    sensors = []
-
-    for sensor_type in SENSOR_TYPES:
-        device = sensor_type[0]
-        name = sensor_type[1]
-        unit = sensor_type[2]
-        # `prefix` is the name configured by the user for the sensor, we're appending
-        #  the device type at the end of the name (garden -> garden temperature)
-        if prefix:
-            name = f"{prefix} {name}"
-
-        sensors.append(BeewiSmartclimSensor(poller, name, mac, device, unit))
-
-    add_entities(sensors)
-
-
-class BeewiSmartclimSensor(SensorEntity):
-    """Representation of a Sensor."""
-
-    def __init__(self, poller, name, mac, device, unit):
-        """Initialize the sensor."""
-        self._poller = poller
-        self._attr_name = name
-        self._device = device
-        self._attr_native_unit_of_measurement = unit
-        self._attr_device_class = self._device
-        self._attr_unique_id = f"{mac}_{device}"
-
-    def update(self) -> None:
-        """Fetch new state data from the poller."""
-        self._poller.update_sensor()
-        self._attr_native_value = None
-        if self._device == SensorDeviceClass.TEMPERATURE:
-            self._attr_native_value = self._poller.get_temperature()
-        if self._device == SensorDeviceClass.HUMIDITY:
-            self._attr_native_value = self._poller.get_humidity()
-        if self._device == SensorDeviceClass.BATTERY:
-            self._attr_native_value = self._poller.get_battery()

homeassistant/components/bluetooth/manifest.json

@@ -21,6 +21,6 @@
     "bluetooth-auto-recovery==1.6.4",
     "bluetooth-data-tools==1.29.18",
     "dbus-fast==5.0.22",
-    "habluetooth==6.23.1"
+    "habluetooth==6.25.1"
   ]
 }

homeassistant/components/conversation/default_agent.py

@@ -805,6 +805,10 @@ class DefaultAgent(ConversationEntity):
                 else:
                     num_unmatched_entities += 1
 
+            # Literal text matched is the dominant signal
+            same_text_matched = (maybe_result is not None) and (
+                result.text_chunks_matched == maybe_result.text_chunks_matched
+            )
             if (
                 (maybe_result is None)  # first result
                 or (
@@ -813,22 +817,25 @@ class DefaultAgent(ConversationEntity):
                 )
                 or (
                     # More entities matched
-                    num_matched_entities > best_num_matched_entities
+                    same_text_matched
+                    and (num_matched_entities > best_num_matched_entities)
                 )
                 or (
                     # Fewer unmatched entities
-                    (num_matched_entities == best_num_matched_entities)
+                    same_text_matched
+                    and (num_matched_entities == best_num_matched_entities)
                     and (num_unmatched_entities < best_num_unmatched_entities)
                 )
                 or (
                     # Prefer unmatched ranges
-                    (num_matched_entities == best_num_matched_entities)
+                    same_text_matched
+                    and (num_matched_entities == best_num_matched_entities)
                     and (num_unmatched_entities == best_num_unmatched_entities)
                     and (num_unmatched_ranges > best_num_unmatched_ranges)
                 )
                 or (
                     # Prefer match failures with entities
-                    (result.text_chunks_matched == maybe_result.text_chunks_matched)
+                    same_text_matched
                     and (num_unmatched_entities == best_num_unmatched_entities)
                     and (num_unmatched_ranges == best_num_unmatched_ranges)
                     and (

homeassistant/components/conversation/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/conversation",
   "integration_type": "entity",
   "quality_scale": "internal",
-  "requirements": ["hassil==3.8.0", "home-assistant-intents==2026.6.1"]
+  "requirements": ["hassil==3.8.0", "home-assistant-intents==2026.6.24"]
 }

homeassistant/components/dovado/__init__.py

@@ -1,87 +0,0 @@
-"""Support for Dovado router."""
-
-# mypy: ignore-errors
-from datetime import timedelta
-import logging
-
-# import dovado
-import voluptuous as vol
-
-from homeassistant.const import (
-    CONF_HOST,
-    CONF_PASSWORD,
-    CONF_PORT,
-    CONF_USERNAME,
-    DEVICE_DEFAULT_NAME,
-)
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.typing import ConfigType
-from homeassistant.util import Throttle
-
-_LOGGER = logging.getLogger(__name__)
-
-DOMAIN = "dovado"
-
-CONFIG_SCHEMA = vol.Schema(
-    {
-        DOMAIN: vol.Schema(
-            {
-                vol.Required(CONF_USERNAME): cv.string,
-                vol.Required(CONF_PASSWORD): cv.string,
-                vol.Optional(CONF_HOST): cv.string,
-                vol.Optional(CONF_PORT): cv.port,
-            }
-        )
-    },
-    extra=vol.ALLOW_EXTRA,
-)
-
-MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=30)
-
-
-def setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up the Dovado component."""
-
-    hass.data[DOMAIN] = DovadoData(
-        dovado.Dovado(
-            config[DOMAIN][CONF_USERNAME],
-            config[DOMAIN][CONF_PASSWORD],
-            config[DOMAIN].get(CONF_HOST),
-            config[DOMAIN].get(CONF_PORT),
-        )
-    )
-    return True
-
-
-class DovadoData:
-    """Maintain a connection to the router."""
-
-    def __init__(self, client):
-        """Set up a new Dovado connection."""
-        self._client = client
-        self.state = {}
-
-    @property
-    def name(self):
-        """Name of the router."""
-        return self.state.get("product name", DEVICE_DEFAULT_NAME)
-
-    @Throttle(MIN_TIME_BETWEEN_UPDATES)
-    def update(self):
-        """Update device state."""
-        try:
-            self.state = self._client.state or {}
-            if not self.state:
-                return False
-            self.state.update(connected=self.state.get("modem status") == "CONNECTED")
-        except OSError as error:
-            _LOGGER.warning("Could not contact the router: %s", error)
-            return None
-        _LOGGER.debug("Received: %s", self.state)
-        return True
-
-    @property
-    def client(self):
-        """Dovado client instance."""
-        return self._client

homeassistant/components/dovado/manifest.json

@@ -1,10 +0,0 @@
-{
-  "domain": "dovado",
-  "name": "Dovado",
-  "codeowners": [],
-  "disabled": "This integration is disabled because it uses non-open source code to operate.",
-  "documentation": "https://www.home-assistant.io/integrations/dovado",
-  "iot_class": "local_polling",
-  "quality_scale": "legacy",
-  "requirements": ["dovado==0.4.1"]
-}

homeassistant/components/dovado/notify.py

@@ -1,38 +0,0 @@
-"""Support for SMS notifications from the Dovado router."""
-
-import logging
-from typing import Any, override
-
-from homeassistant.components.notify import ATTR_TARGET, BaseNotificationService
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
-
-from . import DOMAIN
-
-_LOGGER = logging.getLogger(__name__)
-
-
-def get_service(
-    hass: HomeAssistant,
-    config: ConfigType,
-    discovery_info: DiscoveryInfoType | None = None,
-) -> DovadoSMSNotificationService:
-    """Get the Dovado Router SMS notification service."""
-    return DovadoSMSNotificationService(hass.data[DOMAIN].client)
-
-
-class DovadoSMSNotificationService(BaseNotificationService):
-    """Implement the notification service for the Dovado SMS component."""
-
-    def __init__(self, client):
-        """Initialize the service."""
-        self._client = client
-
-    @override
-    def send_message(self, message: str, **kwargs: Any) -> None:
-        """Send SMS to the specified target phone number."""
-        if not (target := kwargs.get(ATTR_TARGET)):
-            _LOGGER.error("One target is required")
-            return
-
-        self._client.send_sms(target, message)

homeassistant/components/dovado/ruff.toml

@@ -1,5 +0,0 @@
-extend = "../../../pyproject.toml"
-
-lint.extend-ignore = [
-  "F821"
-]

homeassistant/components/dovado/sensor.py

@@ -1,143 +0,0 @@
-"""Support for sensors from the Dovado router."""
-
-from dataclasses import dataclass
-from datetime import timedelta
-import re
-from typing import Any, override
-
-import voluptuous as vol
-
-from homeassistant.components.sensor import (
-    PLATFORM_SCHEMA as SENSOR_PLATFORM_SCHEMA,
-    SensorDeviceClass,
-    SensorEntity,
-    SensorEntityDescription,
-)
-from homeassistant.const import CONF_SENSORS, PERCENTAGE, UnitOfInformation
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
-
-from . import DOMAIN
-
-MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=30)
-
-SENSOR_UPLOAD = "upload"
-SENSOR_DOWNLOAD = "download"
-SENSOR_SIGNAL = "signal"
-SENSOR_NETWORK = "network"
-SENSOR_SMS_UNREAD = "sms"
-
-
-@dataclass(frozen=True, kw_only=True)
-class DovadoSensorEntityDescription(SensorEntityDescription):
-    """Describes Dovado sensor entity."""
-
-    identifier: str
-
-
-SENSOR_TYPES: tuple[DovadoSensorEntityDescription, ...] = (
-    DovadoSensorEntityDescription(
-        identifier=SENSOR_NETWORK,
-        key="signal strength",
-        name="Network",
-        icon="mdi:access-point-network",
-    ),
-    DovadoSensorEntityDescription(
-        identifier=SENSOR_SIGNAL,
-        key="signal strength",
-        name="Signal Strength",
-        native_unit_of_measurement=PERCENTAGE,
-        icon="mdi:signal",
-    ),
-    DovadoSensorEntityDescription(
-        identifier=SENSOR_SMS_UNREAD,
-        key="sms unread",
-        name="SMS unread",
-        icon="mdi:message-text-outline",
-    ),
-    DovadoSensorEntityDescription(
-        identifier=SENSOR_UPLOAD,
-        key="traffic modem tx",
-        name="Sent",
-        native_unit_of_measurement=UnitOfInformation.GIGABYTES,
-        device_class=SensorDeviceClass.DATA_SIZE,
-        icon="mdi:cloud-upload",
-    ),
-    DovadoSensorEntityDescription(
-        identifier=SENSOR_DOWNLOAD,
-        key="traffic modem rx",
-        name="Received",
-        native_unit_of_measurement=UnitOfInformation.GIGABYTES,
-        device_class=SensorDeviceClass.DATA_SIZE,
-        icon="mdi:cloud-download",
-    ),
-)
-
-SENSOR_KEYS: list[str] = [desc.key for desc in SENSOR_TYPES]
-
-PLATFORM_SCHEMA = SENSOR_PLATFORM_SCHEMA.extend(
-    {vol.Required(CONF_SENSORS): vol.All(cv.ensure_list, [vol.In(SENSOR_KEYS)])}
-)
-
-
-def setup_platform(
-    hass: HomeAssistant,
-    config: ConfigType,
-    add_entities: AddEntitiesCallback,
-    discovery_info: DiscoveryInfoType | None = None,
-) -> None:
-    """Set up the Dovado sensor platform."""
-    dovado = hass.data[DOMAIN]
-
-    sensors = config[CONF_SENSORS]
-    entities = [
-        DovadoSensor(dovado, description)
-        for description in SENSOR_TYPES
-        if description.key in sensors
-    ]
-    add_entities(entities)
-
-
-class DovadoSensor(SensorEntity):
-    """Representation of a Dovado sensor."""
-
-    entity_description: DovadoSensorEntityDescription
-
-    def __init__(self, data, description: DovadoSensorEntityDescription) -> None:
-        """Initialize the sensor."""
-        self.entity_description = description
-        self._data = data
-
-        self._attr_name = f"{data.name} {description.name}"
-        self._attr_native_value = self._compute_state()
-
-    def _compute_state(self):
-        """Compute the state of the sensor."""
-        state = self._data.state.get(self.entity_description.key)
-        sensor_identifier = self.entity_description.identifier
-        if sensor_identifier == SENSOR_NETWORK:
-            match = re.search(r"\((.+)\)", state)
-            return match.group(1) if match else None
-        if sensor_identifier == SENSOR_SIGNAL:
-            try:
-                return int(state.split()[0])
-            except ValueError:
-                return None
-        if sensor_identifier == SENSOR_SMS_UNREAD:
-            return int(state)
-        if sensor_identifier in [SENSOR_UPLOAD, SENSOR_DOWNLOAD]:
-            return round(float(state) / 1e6, 1)
-        return state
-
-    def update(self) -> None:
-        """Update sensor values."""
-        self._data.update()
-        self._attr_native_value = self._compute_state()
-
-    @property
-    @override
-    def extra_state_attributes(self) -> dict[str, Any]:
-        """Return the state attributes."""
-        return {k: v for k, v in self._data.state.items() if k not in ["date", "time"]}

homeassistant/components/dropbox/__init__.py

@@ -17,7 +17,7 @@ from homeassistant.helpers.config_entry_oauth2_flow import (
 )
 
 from .auth import DropboxConfigEntryAuth
-from .const import DATA_BACKUP_AGENT_LISTENERS, DOMAIN
+from .const import DATA_BACKUP_AGENT_LISTENERS, DOMAIN, OAUTH2_SCOPES
 
 type DropboxConfigEntry = ConfigEntry[DropboxAPIClient]
 
@@ -31,6 +31,19 @@ async def async_setup_entry(hass: HomeAssistant, entry: DropboxConfigEntry) -> b
             translation_domain=DOMAIN,
             translation_key="oauth2_implementation_unavailable",
         ) from err
+
+    token = entry.data["token"]
+    if not set(token.get("scope", "").split()).issuperset(OAUTH2_SCOPES):
+        raise ConfigEntryAuthFailed(
+            translation_domain=DOMAIN,
+            translation_key="missing_scopes",
+        )
+    if "refresh_token" not in token:
+        raise ConfigEntryAuthFailed(
+            translation_domain=DOMAIN,
+            translation_key="missing_refresh_token",
+        )
+
     oauth2_session = OAuth2Session(hass, entry, oauth2_implementation)
 
     auth = DropboxConfigEntryAuth(

homeassistant/components/dropbox/application_credentials.py

@@ -1,7 +1,5 @@
 """Application credentials platform for the Dropbox integration."""
 
-from typing import override
-
 from homeassistant.components.application_credentials import ClientCredential
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.config_entry_oauth2_flow import (
@@ -9,14 +7,14 @@ from homeassistant.helpers.config_entry_oauth2_flow import (
     LocalOAuth2ImplementationWithPkce,
 )
 
-from .const import OAUTH2_AUTHORIZE, OAUTH2_SCOPES, OAUTH2_TOKEN
+from .const import OAUTH2_AUTHORIZE, OAUTH2_TOKEN
 
 
 async def async_get_auth_implementation(
     hass: HomeAssistant, auth_domain: str, credential: ClientCredential
 ) -> AbstractOAuth2Implementation:
-    """Return custom auth implementation."""
-    return DropboxOAuth2Implementation(
+    """Return auth implementation."""
+    return LocalOAuth2ImplementationWithPkce(
         hass,
         auth_domain,
         credential.client_id,
@@ -24,21 +22,3 @@ async def async_get_auth_implementation(
         OAUTH2_TOKEN,
         credential.client_secret,
     )
-
-
-class DropboxOAuth2Implementation(LocalOAuth2ImplementationWithPkce):
-    """Custom Dropbox OAuth2 implementation.
-
-    Adds the necessary authorize url parameters.
-    """
-
-    @property
-    @override
-    def extra_authorize_data(self) -> dict:
-        """Extra data that needs to be appended to the authorize url."""
-        data: dict = {
-            "token_access_type": "offline",
-            "scope": " ".join(OAUTH2_SCOPES),
-        }
-        data.update(super().extra_authorize_data)
-        return data

homeassistant/components/dropbox/config_flow.py

@@ -12,7 +12,7 @@ from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.config_entry_oauth2_flow import AbstractOAuth2FlowHandler
 
 from .auth import DropboxConfigFlowAuth
-from .const import DOMAIN
+from .const import DOMAIN, OAUTH2_SCOPES
 
 
 class DropboxConfigFlow(AbstractOAuth2FlowHandler, domain=DOMAIN):
@@ -26,6 +26,15 @@ class DropboxConfigFlow(AbstractOAuth2FlowHandler, domain=DOMAIN):
         """Return logger."""
         return logging.getLogger(__name__)
 
+    @property
+    @override
+    def extra_authorize_data(self) -> dict:
+        """Extra data that needs to be appended to the authorize url."""
+        return {
+            "token_access_type": "offline",
+            "scope": " ".join(OAUTH2_SCOPES),
+        }
+
     @override
     async def async_oauth_create_entry(self, data: dict[str, Any]) -> ConfigFlowResult:
         """Create an entry for the flow, or update existing entry."""
@@ -51,6 +60,9 @@ class DropboxConfigFlow(AbstractOAuth2FlowHandler, domain=DOMAIN):
         self, entry_data: Mapping[str, Any]
     ) -> ConfigFlowResult:
         """Perform reauth upon an API authentication error."""
+        token = entry_data[CONF_TOKEN]
+        if not set(token.get("scope", "").split()).issuperset(OAUTH2_SCOPES):
+            return await self.async_step_reauth_permissions()
         return await self.async_step_reauth_confirm()
 
     async def async_step_reauth_confirm(
@@ -60,3 +72,11 @@ class DropboxConfigFlow(AbstractOAuth2FlowHandler, domain=DOMAIN):
         if user_input is None:
             return self.async_show_form(step_id="reauth_confirm")
         return await self.async_step_user()
+
+    async def async_step_reauth_permissions(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Dialog that informs the user that additional permissions are required."""
+        if user_input is None:
+            return self.async_show_form(step_id="reauth_permissions")
+        return await self.async_step_user()

homeassistant/components/dropbox/const.py

@@ -12,6 +12,7 @@ OAUTH2_SCOPES = [
     "account_info.read",
     "files.content.read",
     "files.content.write",
+    "files.metadata.read",
 ]
 
 DATA_BACKUP_AGENT_LISTENERS: HassKey[list[Callable[[], None]]] = HassKey(

homeassistant/components/dropbox/strings.json

@@ -24,10 +24,20 @@
       "reauth_confirm": {
         "description": "The Dropbox integration needs to re-authenticate your account.",
         "title": "[%key:common::config_flow::title::reauth%]"
+      },
+      "reauth_permissions": {
+        "description": "The Dropbox integration requires additional permissions to function correctly.",
+        "title": "[%key:common::config_flow::title::reauth%]"
       }
     }
   },
   "exceptions": {
+    "missing_refresh_token": {
+      "message": "[%key:component::dropbox::config::step::reauth_confirm::description%]"
+    },
+    "missing_scopes": {
+      "message": "[%key:component::dropbox::config::step::reauth_permissions::description%]"
+    },
     "oauth2_implementation_unavailable": {
       "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
     }

homeassistant/components/duco/select.py

@@ -27,6 +27,19 @@ _LOGGER = logging.getLogger(__name__)
 
 PARALLEL_UPDATES = 1
 
+SUPPORTED_SELECT_NODE_TYPES = {
+    NodeType.BOX,
+    NodeType.VLV,
+    NodeType.VLVRH,
+    NodeType.VLVVOC,
+    NodeType.VLVCO2,
+    NodeType.VLVCO2RH,
+    NodeType.EAV,
+    NodeType.EAVRH,
+    NodeType.EAVVOC,
+    NodeType.EAVCO2,
+}
+
 
 def _get_ventilation_options(action: ActionItem) -> tuple[str, ...] | None:
     """Return ventilation options advertised by a node action."""
@@ -71,7 +84,9 @@ async def async_setup_entry(
             if node.node_id in known_nodes:
                 continue
 
-            if node.general.node_type is not NodeType.BOX:
+            # Duco advertises SetVentilationState broadly, so keep the select
+            # limited to the box and known valve node families.
+            if node.general.node_type not in SUPPORTED_SELECT_NODE_TYPES:
                 continue
 
             options = options_by_node.get(node.node_id)

homeassistant/components/ecobee/climate.py

@@ -641,25 +641,34 @@ class Thermostat(ClimateEntity):
             for device in device_registry.devices.values()
             for sensor_info in sensors_info
             if device.name == sensor_info["name"]
+            and any(identifier[0] == DOMAIN for identifier in device.identifiers)
         ]
 
+    def _active_climate_name(self) -> str:
+        """Return the ecobee climate name of the active comfort setting.
+
+        ``preset_mode`` is the climate *name*, but ``_preset_modes`` is keyed by
+        climateRef, so the built-in presets are translated back to their ecobee
+        name. Holds that are not a comfort setting (temperature/vacation/
+        indefinite away) are not real climates; per ecobee they follow the Home
+        comfort setting's sensor participation, so fall back to "Home".
+        """
+        # https://support.ecobee.com/s/articles/SmartSensors-Sensor-Participation
+        preset_mode = self.preset_mode
+        if preset_mode is None:
+            return "Home"
+        mode = HASS_TO_ECOBEE_PRESET.get(preset_mode, preset_mode)
+        return mode if mode in self._preset_modes.values() else "Home"
+
     @property
     def active_sensors_in_preset_mode(self) -> list:
         """Return the currently active/participating sensors."""
-        # https://support.ecobee.com/s/articles/SmartSensors-Sensor-Participation
-        # During a manual hold, the ecobee will follow the Sensor Participation
-        # rules for the Home Comfort Settings
-        mode = self._preset_modes.get(self.preset_mode, "Home")
-        return self._sensors_in_preset_mode(mode)
+        return self._sensors_in_preset_mode(self._active_climate_name())
 
     @property
     def active_sensor_devices_in_preset_mode(self) -> list:
         """Return the currently active/participating sensor devices."""
-        # https://support.ecobee.com/s/articles/SmartSensors-Sensor-Participation
-        # During a manual hold, the ecobee will follow the Sensor Participation
-        # rules for the Home Comfort Settings
-        mode = self._preset_modes.get(self.preset_mode, "Home")
-        return self._sensor_devices_in_preset_mode(mode)
+        return self._sensor_devices_in_preset_mode(self._active_climate_name())
 
     @override
     def set_preset_mode(self, preset_mode: str) -> None:
@@ -950,6 +959,7 @@ class Thermostat(ClimateEntity):
                 for device in device_registry.devices.values()
                 for sensor_name in sensor_names
                 if device.name == sensor_name
+                and any(identifier[0] == DOMAIN for identifier in device.identifiers)
             ]
         )
 

homeassistant/components/elevenlabs/strings.json

@@ -31,14 +31,14 @@
     "step": {
       "init": {
         "data": {
-          "configure_voice": "Configure advanced voice settings",
+          "configure_voice": "Configure voice settings",
           "model": "Model",
           "stt_auto_language": "Auto-detect language",
           "stt_model": "Speech-to-text model",
           "voice": "Voice"
         },
         "data_description": {
-          "configure_voice": "Configure advanced voice settings. Find more information in the ElevenLabs documentation.",
+          "configure_voice": "Configure voice settings. Find more information in the ElevenLabs documentation.",
           "model": "ElevenLabs model to use. Please note that not all models support all languages equally well.",
           "stt_auto_language": "Automatically detect the spoken language for speech-to-text.",
           "stt_model": "Speech-to-text model to use.",

homeassistant/components/enphase_envoy/diagnostics.py

@@ -65,6 +65,14 @@ async def _get_fixture_collection(envoy: Envoy, serial: str) -> dict[str, Any]:
         "/ivp/meters/readings",
         "/ivp/pdm/device_data",
         "/home",
+        "/inventory.json?deleted=1",
+        "/admin/lib/acb_config",
+        "/ivp/sc/sched",
+        "/admin/lib/network_display",
+        "/admin/lib/wireless_display",
+        "/ivp/ensemble/relay",
+        "/ivp/livedata/status",
+        "/ivp/pdm/energy",
     ]
 
     for end_point in end_points:
@@ -134,16 +142,15 @@ async def async_get_config_entry_diagnostics(
         "encharge_power": envoy_data.encharge_power,
         "encharge_aggregate": envoy_data.encharge_aggregate,
         "enpower": envoy_data.enpower,
+        "acb_power": envoy_data.acb_power,
+        "acb_inventory": envoy_data.acb_inventory,
+        "battery_aggregate": envoy_data.battery_aggregate,
+        "collar": envoy_data.collar,
+        "c6cc": envoy_data.c6cc,
         "system_consumption": envoy_data.system_consumption,
         "system_production": envoy_data.system_production,
         "system_consumption_phases": envoy_data.system_consumption_phases,
         "system_production_phases": envoy_data.system_production_phases,
-        "ctmeter_production": envoy_data.ctmeter_production,
-        "ctmeter_consumption": envoy_data.ctmeter_consumption,
-        "ctmeter_storage": envoy_data.ctmeter_storage,
-        "ctmeter_production_phases": envoy_data.ctmeter_production_phases,
-        "ctmeter_consumption_phases": envoy_data.ctmeter_consumption_phases,
-        "ctmeter_storage_phases": envoy_data.ctmeter_storage_phases,
         "ctmeters": envoy_data.ctmeters,
         "ctmeters_phases": envoy_data.ctmeters_phases,
         "dry_contact_status": envoy_data.dry_contact_status,

homeassistant/components/frontend/manifest.json

@@ -21,5 +21,5 @@
   "integration_type": "system",
   "preview_features": { "winter_mode": {} },
   "quality_scale": "internal",
-  "requirements": ["home-assistant-frontend==20260527.7"]
+  "requirements": ["home-assistant-frontend==20260624.1"]
 }

homeassistant/components/greenwave/__init__.py

@@ -1 +0,0 @@
-"""The greenwave component."""

homeassistant/components/greenwave/light.py

@@ -1,123 +0,0 @@
-"""Support for Greenwave Reality (TCP Connected) lights."""
-
-from datetime import timedelta
-import logging
-import os
-from typing import Any, override
-
-import greenwavereality as greenwave
-import voluptuous as vol
-
-from homeassistant.components.light import (
-    ATTR_BRIGHTNESS,
-    PLATFORM_SCHEMA as LIGHT_PLATFORM_SCHEMA,
-    ColorMode,
-    LightEntity,
-)
-from homeassistant.const import CONF_HOST
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
-from homeassistant.util import Throttle
-
-_LOGGER = logging.getLogger(__name__)
-
-CONF_VERSION = "version"
-
-PLATFORM_SCHEMA = LIGHT_PLATFORM_SCHEMA.extend(
-    {vol.Required(CONF_HOST): cv.string, vol.Required(CONF_VERSION): cv.positive_int}
-)
-
-MIN_TIME_BETWEEN_UPDATES = timedelta(minutes=1)
-
-
-def setup_platform(
-    hass: HomeAssistant,
-    config: ConfigType,
-    add_entities: AddEntitiesCallback,
-    discovery_info: DiscoveryInfoType | None = None,
-) -> None:
-    """Set up the Greenwave Reality Platform."""
-    host = config.get(CONF_HOST)
-    tokenfilename = hass.config.path(".greenwave")
-    if config.get(CONF_VERSION) == 3:
-        if os.path.exists(tokenfilename):
-            with open(tokenfilename, encoding="utf8") as tokenfile:
-                token = tokenfile.read()
-        else:
-            try:
-                token = greenwave.grab_token(host, "hass", "homeassistant")
-            except PermissionError:
-                _LOGGER.error("The Gateway Is Not In Sync Mode")
-                raise
-            with open(tokenfilename, "w+", encoding="utf8") as tokenfile:
-                tokenfile.write(token)
-    else:
-        token = None
-    bulbs = greenwave.grab_bulbs(host, token)
-    add_entities(
-        GreenwaveLight(device, host, token, GatewayData(host, token))
-        for device in bulbs.values()
-    )
-
-
-class GreenwaveLight(LightEntity):
-    """Representation of an Greenwave Reality Light."""
-
-    _attr_color_mode = ColorMode.BRIGHTNESS
-    _attr_supported_color_modes = {ColorMode.BRIGHTNESS}
-
-    def __init__(self, light, host, token, gatewaydata):
-        """Initialize a Greenwave Reality Light."""
-        self._did = int(light["did"])
-        self._attr_name = light["name"]
-        self._attr_is_on = bool(int(light["state"]))
-        self._attr_brightness = greenwave.hass_brightness(light)
-        self._host = host
-        self._attr_available = greenwave.check_online(light)
-        self._token = token
-        self._gatewaydata = gatewaydata
-
-    @override
-    def turn_on(self, **kwargs: Any) -> None:
-        """Instruct the light to turn on."""
-        temp_brightness = int((kwargs.get(ATTR_BRIGHTNESS, 255) / 255) * 100)
-        greenwave.set_brightness(self._host, self._did, temp_brightness, self._token)
-        greenwave.turn_on(self._host, self._did, self._token)
-
-    @override
-    def turn_off(self, **kwargs: Any) -> None:
-        """Instruct the light to turn off."""
-        greenwave.turn_off(self._host, self._did, self._token)
-
-    def update(self) -> None:
-        """Fetch new state data for this light."""
-        self._gatewaydata.update()
-        bulbs = self._gatewaydata.greenwave
-
-        self._attr_is_on = bool(int(bulbs[self._did]["state"]))
-        self._attr_brightness = greenwave.hass_brightness(bulbs[self._did])
-        self._attr_available = greenwave.check_online(bulbs[self._did])
-        self._attr_name = bulbs[self._did]["name"]
-
-
-class GatewayData:
-    """Handle Gateway data and limit updates."""
-
-    def __init__(self, host, token):
-        """Initialize the data object."""
-        self._host = host
-        self._token = token
-        self._greenwave = greenwave.grab_bulbs(host, token)
-
-    @property
-    def greenwave(self):
-        """Return Gateway API object."""
-        return self._greenwave
-
-    @Throttle(MIN_TIME_BETWEEN_UPDATES)
-    def update(self):
-        """Get the latest data from the gateway."""
-        self._greenwave = greenwave.grab_bulbs(self._host, self._token)
-        return self._greenwave

homeassistant/components/greenwave/manifest.json

@@ -1,10 +0,0 @@
-{
-  "domain": "greenwave",
-  "name": "Greenwave Reality",
-  "codeowners": [],
-  "documentation": "https://www.home-assistant.io/integrations/greenwave",
-  "iot_class": "local_polling",
-  "loggers": ["greenwavereality"],
-  "quality_scale": "legacy",
-  "requirements": ["greenwavereality==0.5.1"]
-}

homeassistant/components/hassio/jobs.py

@@ -92,7 +92,7 @@ class SupervisorJobs:
         # We catch all errors to prevent an error in one from stopping the others
         for match in [job for job in self._jobs.values() if subscription.matches(job)]:
             try:
-                return subscription.event_callback(match)
+                subscription.event_callback(match)
             except Exception as err:  # noqa: BLE001
                 _LOGGER.error(
                     "Error encountered processing Supervisor Job (%s %s %s) - %s",

homeassistant/components/home_connect/sensor.py

@@ -13,7 +13,7 @@ from homeassistant.components.sensor import (
     SensorEntityDescription,
     SensorStateClass,
 )
-from homeassistant.const import PERCENTAGE, EntityCategory, UnitOfVolume
+from homeassistant.const import EntityCategory, UnitOfRatio, UnitOfVolume
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import dt as dt_util, slugify
@@ -67,7 +67,7 @@ BSH_PROGRAM_SENSORS = (
     ),
     HomeConnectSensorEntityDescription(
         key=EventKey.BSH_COMMON_OPTION_PROGRAM_PROGRESS,
-        native_unit_of_measurement=PERCENTAGE,
+        native_unit_of_measurement=UnitOfRatio.PERCENTAGE,
         translation_key="program_progress",
         appliance_types=APPLIANCES_WITH_PROGRAMS,
     ),
@@ -158,6 +158,7 @@ SENSORS = (
     HomeConnectSensorEntityDescription(
         key=StatusKey.BSH_COMMON_BATTERY_LEVEL,
         device_class=SensorDeviceClass.BATTERY,
+        native_unit_of_measurement=UnitOfRatio.PERCENTAGE,
     ),
     HomeConnectSensorEntityDescription(
         key=StatusKey.BSH_COMMON_VIDEO_CAMERA_STATE,

homeassistant/components/homeassistant_hardware/strings.json

@@ -127,7 +127,7 @@
           "data": {
             "channel": "Channel"
           },
-          "description": "Start a channel change for your Zigbee and Thread networks.\n\nNote: this is an advanced operation and can leave your Thread and Zigbee networks inoperable if the new channel is congested. Depending on existing network conditions, many of your devices may not migrate to the new channel and will require re-joining before they start working again. Use with caution.\n\nOnce you have selected **Submit**, the channel change starts quietly in the background and will finish after a few minutes.",
+          "description": "Start a channel change for your Zigbee and Thread networks.\n\nNote: this operation can leave your Thread and Zigbee networks inoperable if the new channel is congested. Depending on existing network conditions, many of your devices may not migrate to the new channel and will require re-joining before they start working again. Use with caution.\n\nOnce you have selected **Submit**, the channel change starts quietly in the background and will finish after a few minutes.",
           "title": "[%key:component::homeassistant_hardware::silabs_multiprotocol_hardware::options::step::reconfigure_addon::title%]"
         },
         "install_addon": {

homeassistant/components/homematicip_cloud/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_push",
   "loggers": ["homematicip"],
-  "requirements": ["homematicip==2.13.1"]
+  "requirements": ["homematicip==2.13.2"]
 }

homeassistant/components/input_datetime/__init__.py

@@ -389,7 +389,9 @@ class InputDatetime(collection.CollectionEntity, RestoreEntity):
 
         elif not self.has_time:
             extended = py_datetime.datetime.combine(
-                self._current_datetime, py_datetime.time(0, 0)
+                self._current_datetime,
+                py_datetime.time(0, 0),
+                dt_util.get_default_time_zone(),
             )
             attrs[InputDatetimeEntityStateAttribute.TIMESTAMP] = extended.timestamp()
 

homeassistant/components/logentries/__init__.py

@@ -1,56 +0,0 @@
-"""Support for sending data to Logentries webhook endpoint."""
-
-import json
-import logging
-
-import requests
-import voluptuous as vol
-
-from homeassistant.const import CONF_TOKEN, EVENT_STATE_CHANGED
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers import config_validation as cv, state as state_helper
-from homeassistant.helpers.typing import ConfigType
-
-_LOGGER = logging.getLogger(__name__)
-
-DOMAIN = "logentries"
-
-DEFAULT_HOST = "https://webhook.logentries.com/noformat/logs/"
-
-CONFIG_SCHEMA = vol.Schema(
-    {DOMAIN: vol.Schema({vol.Required(CONF_TOKEN): cv.string})}, extra=vol.ALLOW_EXTRA
-)
-
-
-def setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up the Logentries component."""
-    conf = config[DOMAIN]
-    token = conf.get(CONF_TOKEN)
-    le_wh = f"{DEFAULT_HOST}{token}"
-
-    def logentries_event_listener(event):
-        """Listen for new messages on the bus and sends them to Logentries."""
-        if (state := event.data.get("new_state")) is None:
-            return
-        try:
-            _state = state_helper.state_as_number(state)
-        except ValueError:
-            _state = state.state
-        json_body = [
-            {
-                "domain": state.domain,
-                "entity_id": state.object_id,
-                "attributes": dict(state.attributes),
-                "time": str(event.time_fired),
-                "value": _state,
-            }
-        ]
-        try:
-            payload = {"host": le_wh, "event": json_body}
-            requests.post(le_wh, data=json.dumps(payload), timeout=10)
-        except requests.exceptions.RequestException:
-            _LOGGER.exception("Error sending to Logentries")
-
-    hass.bus.listen(EVENT_STATE_CHANGED, logentries_event_listener)
-
-    return True

homeassistant/components/logentries/manifest.json

@@ -1,8 +0,0 @@
-{
-  "domain": "logentries",
-  "name": "Logentries",
-  "codeowners": [],
-  "documentation": "https://www.home-assistant.io/integrations/logentries",
-  "iot_class": "cloud_push",
-  "quality_scale": "legacy"
-}

homeassistant/components/matter/__init__.py

@@ -4,6 +4,7 @@ import asyncio
 from functools import cache
 from typing import TYPE_CHECKING
 
+from aiohasupervisor.models import InterfaceMethod
 from matter_server.client import MatterClient
 from matter_server.client.exceptions import (
     CannotConnect,
@@ -15,13 +16,20 @@ from matter_server.client.exceptions import (
 from matter_server.common.errors import MatterError, NodeNotExists
 from yarl import URL
 
-from homeassistant.components.hassio import AddonError, AddonManager, AddonState
+from homeassistant.components.hassio import (
+    AddonError,
+    AddonManager,
+    AddonState,
+    SupervisorError,
+    get_supervisor_client,
+)
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.const import CONF_URL, EVENT_HOMEASSISTANT_STOP
 from homeassistant.core import Event, HomeAssistant, callback
 from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers import config_validation as cv, device_registry as dr
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.hassio import is_hassio
 from homeassistant.helpers.issue_registry import (
     IssueSeverity,
     async_create_issue,
@@ -123,6 +131,8 @@ async def async_setup_entry(hass: HomeAssistant, entry: MatterConfigEntry) -> bo
     async_delete_issue(hass, DOMAIN, "server_version_version_too_old")
     async_delete_issue(hass, DOMAIN, "server_version_version_too_new")
 
+    await _async_check_ipv6_enabled(hass)
+
     ble_proxy: MatterBleProxy | None = None
 
     async def on_hass_stop(event: Event) -> None:
@@ -252,6 +262,53 @@ def _derive_ble_proxy_url(matter_ws_url: str) -> str | None:
     return str(parsed.with_path(new_path))
 
 
+async def _async_check_ipv6_enabled(hass: HomeAssistant) -> None:
+    """Raise a repair issue when IPv6 is disabled in Supervisor network settings.
+
+    Matter relies on IPv6 to communicate with devices. On Supervised/HAOS
+    installations the host network IPv6 method can be disabled per interface,
+    which silently breaks Matter, so we surface a repair pointing the user at
+    the network settings.
+    """
+    if not is_hassio(hass):
+        return
+
+    client = get_supervisor_client(hass)
+    try:
+        network_info = await client.network.info()
+    except SupervisorError as err:
+        LOGGER.debug("Failed to fetch Supervisor network info: %s", err)
+        return
+
+    connected_interfaces = [
+        interface
+        for interface in network_info.interfaces
+        if interface.enabled and interface.connected
+    ]
+    # Without a connected interface we can't tell whether IPv6 is disabled or
+    # the network is simply not up yet, so avoid raising a false repair.
+    if not connected_interfaces:
+        return
+
+    if any(
+        interface.ipv6 is not None
+        and interface.ipv6.method is not InterfaceMethod.DISABLED
+        for interface in connected_interfaces
+    ):
+        async_delete_issue(hass, DOMAIN, "ipv6_disabled")
+        return
+
+    async_create_issue(
+        hass,
+        DOMAIN,
+        "ipv6_disabled",
+        is_fixable=False,
+        severity=IssueSeverity.WARNING,
+        translation_key="ipv6_disabled",
+        learn_more_url="homeassistant://config/network",
+    )
+
+
 async def _client_listen(
     hass: HomeAssistant,
     entry: MatterConfigEntry,

homeassistant/components/matter/strings.json

@@ -721,6 +721,10 @@
     }
   },
   "issues": {
+    "ipv6_disabled": {
+      "description": "Matter relies on IPv6 to communicate with some devices, but IPv6 is disabled on all of your connected network interfaces. Locally connected Wi-Fi and Ethernet devices may still work, but features such as using an external Thread border router need IPv6 enabled. Select \"Learn more\" to open the network settings.",
+      "title": "IPv6 is disabled but required by Matter"
+    },
     "server_version_version_too_new": {
       "description": "The version of the Matter Server you are currently running is too new for this version of Home Assistant. Please update Home Assistant or downgrade the Matter Server to an older version to fix this issue.",
       "title": "Older version of Matter Server needed"

homeassistant/components/mycroft/__init__.py

@@ -1,21 +0,0 @@
-"""Support for Mycroft AI."""
-
-import voluptuous as vol
-
-from homeassistant.const import CONF_HOST, Platform
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers import config_validation as cv, discovery
-from homeassistant.helpers.typing import ConfigType
-
-DOMAIN = "mycroft"
-
-CONFIG_SCHEMA = vol.Schema(
-    {DOMAIN: vol.Schema({vol.Required(CONF_HOST): cv.string})}, extra=vol.ALLOW_EXTRA
-)
-
-
-def setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up the Mycroft component."""
-    hass.data[DOMAIN] = config[DOMAIN][CONF_HOST]
-    discovery.load_platform(hass, Platform.NOTIFY, DOMAIN, {}, config)
-    return True

homeassistant/components/mycroft/manifest.json

@@ -1,11 +0,0 @@
-{
-  "domain": "mycroft",
-  "name": "Mycroft",
-  "codeowners": [],
-  "disabled": "Dependencies not compatible with the new pip resolver",
-  "documentation": "https://www.home-assistant.io/integrations/mycroft",
-  "iot_class": "local_push",
-  "loggers": ["mycroftapi"],
-  "quality_scale": "legacy",
-  "requirements": ["mycroftapi==2.0"]
-}

homeassistant/components/mycroft/notify.py

@@ -1,42 +0,0 @@
-"""Mycroft AI notification platform."""
-
-import logging
-from typing import Any, override
-
-from mycroftapi import MycroftAPI
-
-from homeassistant.components.notify import BaseNotificationService
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
-
-from . import DOMAIN
-
-_LOGGER = logging.getLogger(__name__)
-
-
-def get_service(
-    hass: HomeAssistant,
-    config: ConfigType,
-    discovery_info: DiscoveryInfoType | None = None,
-) -> MycroftNotificationService:
-    """Get the Mycroft notification service."""
-    return MycroftNotificationService(hass.data[DOMAIN])
-
-
-class MycroftNotificationService(BaseNotificationService):
-    """The Mycroft Notification Service."""
-
-    def __init__(self, mycroft_ip: str) -> None:
-        """Initialize the service."""
-        self.mycroft_ip = mycroft_ip
-
-    @override
-    def send_message(self, message: str = "", **kwargs: Any) -> None:
-        """Send a message mycroft to speak on instance."""
-
-        text = message
-        mycroft = MycroftAPI(self.mycroft_ip)
-        if mycroft is not None:
-            mycroft.speak_text(text)
-        else:
-            _LOGGER.warning("Could not reach this instance of mycroft")

homeassistant/components/overkiz/__init__.py

@@ -5,6 +5,7 @@ from dataclasses import dataclass
 from typing import cast
 
 from aiohttp import ClientError
+from pyoverkiz.action_queue import ActionQueueSettings
 from pyoverkiz.auth.credentials import (
     LocalTokenCredentials,
     RexelTokenCredentials,
@@ -317,7 +318,9 @@ def create_local_client(
         credentials=LocalTokenCredentials(token),
         session=session,
         verify_ssl=verify_ssl,
-        settings=OverkizClientSettings(default_rts_command_duration=0),
+        settings=OverkizClientSettings(
+            action_queue=ActionQueueSettings(), default_rts_command_duration=0
+        ),
     )
 
 
@@ -333,7 +336,9 @@ def create_cloud_client(
         server=server,
         credentials=UsernamePasswordCredentials(username, password),
         session=session,
-        settings=OverkizClientSettings(default_rts_command_duration=0),
+        settings=OverkizClientSettings(
+            action_queue=ActionQueueSettings(), default_rts_command_duration=0
+        ),
     )
 
 
@@ -360,4 +365,7 @@ async def create_rexel_client(
             gateway_id=entry.data[CONF_GATEWAY_ID],
         ),
         session=async_create_clientsession(hass),
+        settings=OverkizClientSettings(
+            action_queue=ActionQueueSettings(), default_rts_command_duration=0
+        ),
     )

homeassistant/components/overkiz/coordinator.py

@@ -76,7 +76,7 @@ class OverkizDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Device]]):
         self.data = {}
         self.client = client
         self.devices: dict[str, Device] = {d.device_url: d for d in devices}
-        self.executions: dict[str, dict[str, str]] = {}
+        self.executions: dict[str, list[dict[str, str]]] = {}
         self.areas = self._places_to_area(places) if places else None
         self._default_update_interval = UPDATE_INTERVAL
 
@@ -228,7 +228,7 @@ async def on_execution_registered(
 ) -> None:
     """Handle execution registered event."""
     if event.exec_id not in coordinator.executions:
-        coordinator.executions[event.exec_id] = {}
+        coordinator.executions[event.exec_id] = []
 
     if not coordinator.is_stateless:
         coordinator.update_interval = timedelta(seconds=1)

homeassistant/components/overkiz/cover.py

@@ -857,7 +857,8 @@ class OverkizCover(OverkizDescriptiveEntity, CoverEntity):
         return any(
             execution.get("device_url") == self.device.device_url
             and execution.get("command_name") == command
-            for execution in self.coordinator.executions.values()
+            for executions in self.coordinator.executions.values()
+            for execution in executions
         )
 
     @property

homeassistant/components/overkiz/executor.py

@@ -71,12 +71,15 @@ class OverkizExecutor:
         ) as exception:
             raise HomeAssistantError("Failed to connect") from exception
 
-        # ExecutionRegisteredEvent doesn't contain the
-        # device_url, thus we need to register it here
-        self.coordinator.executions[exec_id] = {
-            "device_url": self.device.device_url,
-            "command_name": command_name,
-        }
+        # ExecutionRegisteredEvent doesn't contain the device_url, thus we need
+        # to register it here. The action queue can merge concurrent action
+        # groups under one exec_id, so accumulate rather than overwrite.
+        self.coordinator.executions.setdefault(exec_id, []).append(
+            {
+                "device_url": self.device.device_url,
+                "command_name": command_name,
+            }
+        )
         if refresh_afterwards:
             await self.coordinator.async_refresh()
 
@@ -110,10 +113,12 @@ class OverkizExecutor:
         ) as exception:
             raise HomeAssistantError("Failed to connect") from exception
 
-        self.coordinator.executions[exec_id] = {
-            "device_url": self.device.device_url,
-            "command_name": commands[-1].name,
-        }
+        self.coordinator.executions.setdefault(exec_id, []).append(
+            {
+                "device_url": self.device.device_url,
+                "command_name": commands[-1].name,
+            }
+        )
         if refresh_afterwards:
             await self.coordinator.async_refresh()
 
@@ -129,7 +134,8 @@ class OverkizExecutor:
             (
                 exec_id
                 # Reverse dictionary to cancel the last added execution
-                for exec_id, execution in reversed(self.coordinator.executions.items())
+                for exec_id, executions in reversed(self.coordinator.executions.items())
+                for execution in executions
                 if execution.get("device_url") == self.device.device_url
                 and execution.get("command_name") in commands_to_cancel
             ),

homeassistant/components/recorder/__init__.py

@@ -30,6 +30,7 @@ from homeassistant.util.event_type import EventType
 # startup
 from . import (
     backup,  # noqa: F401
+    entity_options,
     entity_registry,
     websocket_api,
 )
@@ -42,6 +43,7 @@ from .const import (  # noqa: F401
     SupportedDialect,
 )
 from .core import Recorder
+from .entity_options import is_entity_recorded  # noqa: F401
 from .services import async_setup_services
 from .tasks import AddRecorderPlatformTask
 from .util import get_instance
@@ -125,15 +127,6 @@ CONFIG_SCHEMA = vol.Schema(
 )
 
 
-def is_entity_recorded(hass: HomeAssistant, entity_id: str) -> bool:
-    """Check if an entity is being recorded.
-
-    Async friendly.
-    """
-    instance = get_instance(hass)
-    return instance.entity_filter is None or instance.entity_filter(entity_id)
-
-
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the recorder."""
     conf = config[DOMAIN]
@@ -167,6 +160,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     )
     get_instance.cache_clear()
     entity_registry.async_setup(hass)
+    entity_options.async_setup(hass)
     instance.async_initialize()
     instance.async_register()
     instance.start()

homeassistant/components/recorder/entity_options.py

@@ -0,0 +1,68 @@
+"""Control recorder entity options."""
+
+import dataclasses
+from enum import StrEnum
+from typing import Any
+
+import voluptuous as vol
+
+from homeassistant.components import websocket_api
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import config_validation as cv
+
+from .util import get_instance
+
+
+def is_entity_recorded(hass: HomeAssistant, entity_id: str) -> bool:
+    """Check if an entity is being recorded.
+
+    Async friendly.
+    """
+    instance = get_instance(hass)
+    return instance.entity_filter is None or instance.entity_filter(entity_id)
+
+
+@callback
+def async_setup(hass: HomeAssistant) -> None:
+    """Set up the recorder entity options."""
+    websocket_api.async_register_command(hass, ws_get_entity_options)
+
+
+class EntityRecordingDisabler(StrEnum):
+    """What disabled recording of an entity."""
+
+    USER = "user"
+
+
+@dataclasses.dataclass(frozen=True)
+class RecorderEntityOptions:
+    """Recorder options for an entity."""
+
+    recording_disabled_by: EntityRecordingDisabler | None = None
+
+    def to_json(self) -> dict[str, Any]:
+        """Return a JSON serializable representation for storage."""
+        return {
+            "recording_disabled_by": self.recording_disabled_by,
+        }
+
+
+@websocket_api.require_admin
+@websocket_api.websocket_command(
+    {
+        vol.Required("type"): "recorder/entity_options/get",
+        vol.Required("entity_id"): cv.strict_entity_id,
+    }
+)
+@callback
+def ws_get_entity_options(
+    hass: HomeAssistant, connection: websocket_api.ActiveConnection, msg: dict[str, Any]
+) -> None:
+    """Get recorder settings for a single entity."""
+    entity_id: str = msg["entity_id"]
+    recording_disabled = (
+        None if is_entity_recorded(hass, entity_id) else EntityRecordingDisabler.USER
+    )
+
+    options = RecorderEntityOptions(recording_disabled_by=recording_disabled)
+    connection.send_result(msg["id"], options.to_json())

homeassistant/components/renault/sensor.py

@@ -321,6 +321,7 @@ SENSOR_TYPES: tuple[RenaultSensorEntityDescription[Any], ...] = (
         options=[
             "always",
             "delayed",
+            "delegated",
             "scheduled",
         ],
         value_lambda=_get_charging_settings_mode_formatted,

homeassistant/components/renault/strings.json

@@ -157,6 +157,7 @@
         "state": {
           "always": "Always",
           "delayed": "Delayed",
+          "delegated": "Delegated",
           "scheduled": "Scheduled"
         }
       },

homeassistant/components/reolink/__init__.py

@@ -286,7 +286,10 @@ async def register_callbacks(
         return async_camera_wake
 
     host.api.baichuan.register_callback(
-        "privacy_mode_change", async_privacy_mode_change, 623
+        "privacy_mode_change_623", async_privacy_mode_change, 623
+    )
+    host.api.baichuan.register_callback(
+        "privacy_mode_change_574", async_privacy_mode_change, 574
     )
     for channel in host.api.channels:
         if host.api.supported(channel, "battery"):
@@ -306,7 +309,8 @@ async def async_unload_entry(
 
     await host.stop()
 
-    host.api.baichuan.unregister_callback("privacy_mode_change")
+    host.api.baichuan.unregister_callback("privacy_mode_change_623")
+    host.api.baichuan.unregister_callback("privacy_mode_change_574")
     for channel in host.api.channels:
         if host.api.supported(channel, "battery"):
             host.api.baichuan.unregister_callback(f"camera_{channel}_wake")

homeassistant/components/reolink/light.py

@@ -75,6 +75,7 @@ LIGHT_ENTITIES = (
     ReolinkLightEntityDescription(
         key="status_led",
         cmd_key="GetPowerLed",
+        cmd_id=208,
         translation_key="status_led",
         entity_category=EntityCategory.CONFIG,
         supported=lambda api, ch: api.supported(ch, "power_led"),

homeassistant/components/reolink/manifest.json

@@ -20,5 +20,5 @@
   "iot_class": "local_push",
   "loggers": ["reolink_aio"],
   "quality_scale": "platinum",
-  "requirements": ["reolink-aio==0.21.2"]
+  "requirements": ["reolink-aio==0.21.3"]
 }

homeassistant/components/reolink/number.py

@@ -195,6 +195,7 @@ NUMBER_ENTITIES = (
         key="volume",
         cmd_key="GetAudioCfg",
         translation_key="volume",
+        cmd_id=264,
         entity_category=EntityCategory.CONFIG,
         native_step=1,
         native_min_value=0,
@@ -206,6 +207,7 @@ NUMBER_ENTITIES = (
     ReolinkNumberEntityDescription(
         key="volume_speak",
         cmd_key="GetAudioCfg",
+        cmd_id=264,
         translation_key="volume_speak",
         entity_category=EntityCategory.CONFIG,
         native_step=1,
@@ -218,6 +220,7 @@ NUMBER_ENTITIES = (
     ReolinkNumberEntityDescription(
         key="volume_doorbell",
         cmd_key="GetAudioCfg",
+        cmd_id=264,
         translation_key="volume_doorbell",
         entity_category=EntityCategory.CONFIG,
         native_step=1,
@@ -269,6 +272,7 @@ NUMBER_ENTITIES = (
     ReolinkNumberEntityDescription(
         key="pir_sensitivity",
         cmd_key="GetPirInfo",
+        cmd_id=212,
         translation_key="pir_sensitivity",
         entity_category=EntityCategory.CONFIG,
         native_step=1,
@@ -281,6 +285,7 @@ NUMBER_ENTITIES = (
     ReolinkNumberEntityDescription(
         key="pir_interval",
         cmd_key="GetPirInfo",
+        cmd_id=212,
         translation_key="pir_interval",
         entity_category=EntityCategory.CONFIG,
         device_class=NumberDeviceClass.DURATION,
@@ -296,6 +301,7 @@ NUMBER_ENTITIES = (
     ReolinkNumberEntityDescription(
         key="ai_face_sensititvity",
         cmd_key="GetAiAlarm",
+        cmd_id=342,
         translation_key="ai_face_sensitivity",
         entity_category=EntityCategory.CONFIG,
         native_step=1,
@@ -310,6 +316,7 @@ NUMBER_ENTITIES = (
     ReolinkNumberEntityDescription(
         key="ai_person_sensititvity",
         cmd_key="GetAiAlarm",
+        cmd_id=342,
         translation_key="ai_person_sensitivity",
         entity_category=EntityCategory.CONFIG,
         native_step=1,
@@ -324,6 +331,7 @@ NUMBER_ENTITIES = (
     ReolinkNumberEntityDescription(
         key="ai_vehicle_sensititvity",
         cmd_key="GetAiAlarm",
+        cmd_id=342,
         translation_key="ai_vehicle_sensitivity",
         entity_category=EntityCategory.CONFIG,
         native_step=1,
@@ -338,6 +346,7 @@ NUMBER_ENTITIES = (
     ReolinkNumberEntityDescription(
         key="ai_non_motor_vehicle_sensitivity",
         cmd_key="GetAiAlarm",
+        cmd_id=342,
         translation_key="ai_non_motor_vehicle_sensitivity",
         entity_category=EntityCategory.CONFIG,
         native_step=1,
@@ -355,6 +364,7 @@ NUMBER_ENTITIES = (
     ReolinkNumberEntityDescription(
         key="ai_package_sensititvity",
         cmd_key="GetAiAlarm",
+        cmd_id=342,
         translation_key="ai_package_sensitivity",
         entity_category=EntityCategory.CONFIG,
         native_step=1,
@@ -369,6 +379,7 @@ NUMBER_ENTITIES = (
     ReolinkNumberEntityDescription(
         key="ai_pet_sensititvity",
         cmd_key="GetAiAlarm",
+        cmd_id=342,
         translation_key="ai_pet_sensitivity",
         entity_category=EntityCategory.CONFIG,
         native_step=1,
@@ -385,6 +396,7 @@ NUMBER_ENTITIES = (
     ReolinkNumberEntityDescription(
         key="ai_pet_sensititvity",
         cmd_key="GetAiAlarm",
+        cmd_id=342,
         translation_key="ai_animal_sensitivity",
         entity_category=EntityCategory.CONFIG,
         native_step=1,
@@ -411,6 +423,7 @@ NUMBER_ENTITIES = (
     ReolinkNumberEntityDescription(
         key="ai_face_delay",
         cmd_key="GetAiAlarm",
+        cmd_id=342,
         translation_key="ai_face_delay",
         entity_category=EntityCategory.CONFIG,
         device_class=NumberDeviceClass.DURATION,
@@ -428,6 +441,7 @@ NUMBER_ENTITIES = (
     ReolinkNumberEntityDescription(
         key="ai_person_delay",
         cmd_key="GetAiAlarm",
+        cmd_id=342,
         translation_key="ai_person_delay",
         entity_category=EntityCategory.CONFIG,
         device_class=NumberDeviceClass.DURATION,
@@ -445,6 +459,7 @@ NUMBER_ENTITIES = (
     ReolinkNumberEntityDescription(
         key="ai_non_motor_vehicle_delay",
         cmd_key="GetAiAlarm",
+        cmd_id=342,
         translation_key="ai_non_motor_vehicle_delay",
         entity_category=EntityCategory.CONFIG,
         device_class=NumberDeviceClass.DURATION,
@@ -464,6 +479,7 @@ NUMBER_ENTITIES = (
     ReolinkNumberEntityDescription(
         key="ai_vehicle_delay",
         cmd_key="GetAiAlarm",
+        cmd_id=342,
         translation_key="ai_vehicle_delay",
         entity_category=EntityCategory.CONFIG,
         device_class=NumberDeviceClass.DURATION,
@@ -481,6 +497,7 @@ NUMBER_ENTITIES = (
     ReolinkNumberEntityDescription(
         key="ai_package_delay",
         cmd_key="GetAiAlarm",
+        cmd_id=342,
         translation_key="ai_package_delay",
         entity_category=EntityCategory.CONFIG,
         device_class=NumberDeviceClass.DURATION,
@@ -498,6 +515,7 @@ NUMBER_ENTITIES = (
     ReolinkNumberEntityDescription(
         key="ai_pet_delay",
         cmd_key="GetAiAlarm",
+        cmd_id=342,
         translation_key="ai_pet_delay",
         entity_category=EntityCategory.CONFIG,
         device_class=NumberDeviceClass.DURATION,
@@ -517,6 +535,7 @@ NUMBER_ENTITIES = (
     ReolinkNumberEntityDescription(
         key="ai_pet_delay",
         cmd_key="GetAiAlarm",
+        cmd_id=342,
         translation_key="ai_animal_delay",
         entity_category=EntityCategory.CONFIG,
         device_class=NumberDeviceClass.DURATION,

homeassistant/components/reolink/select.py

@@ -185,6 +185,7 @@ SELECT_ENTITIES = (
     ReolinkSelectEntityDescription(
         key="status_led",
         cmd_key="GetPowerLed",
+        cmd_id=208,
         translation_key="doorbell_led",
         entity_category=EntityCategory.CONFIG,
         get_options=lambda api, ch: api.doorbell_led_list(ch),
@@ -232,6 +233,7 @@ SELECT_ENTITIES = (
     ReolinkSelectEntityDescription(
         key="main_frame_rate",
         cmd_key="GetEnc",
+        cmd_id=56,
         translation_key="main_frame_rate",
         entity_category=EntityCategory.CONFIG,
         entity_registry_enabled_default=False,
@@ -244,6 +246,7 @@ SELECT_ENTITIES = (
     ReolinkSelectEntityDescription(
         key="sub_frame_rate",
         cmd_key="GetEnc",
+        cmd_id=56,
         translation_key="sub_frame_rate",
         entity_category=EntityCategory.CONFIG,
         entity_registry_enabled_default=False,
@@ -256,6 +259,7 @@ SELECT_ENTITIES = (
     ReolinkSelectEntityDescription(
         key="main_bit_rate",
         cmd_key="GetEnc",
+        cmd_id=56,
         translation_key="main_bit_rate",
         entity_category=EntityCategory.CONFIG,
         entity_registry_enabled_default=False,
@@ -268,6 +272,7 @@ SELECT_ENTITIES = (
     ReolinkSelectEntityDescription(
         key="sub_bit_rate",
         cmd_key="GetEnc",
+        cmd_id=56,
         translation_key="sub_bit_rate",
         entity_category=EntityCategory.CONFIG,
         entity_registry_enabled_default=False,
@@ -280,6 +285,7 @@ SELECT_ENTITIES = (
     ReolinkSelectEntityDescription(
         key="main_encoding",
         cmd_key="GetEnc",
+        cmd_id=56,
         translation_key="main_encoding",
         entity_category=EntityCategory.CONFIG,
         entity_registry_enabled_default=False,
@@ -291,6 +297,7 @@ SELECT_ENTITIES = (
     ReolinkSelectEntityDescription(
         key="sub_encoding",
         cmd_key="GetEnc",
+        cmd_id=56,
         translation_key="sub_encoding",
         entity_category=EntityCategory.CONFIG,
         entity_registry_enabled_default=False,
@@ -316,6 +323,7 @@ SELECT_ENTITIES = (
     ReolinkSelectEntityDescription(
         key="post_rec_time",
         cmd_key="GetRec",
+        cmd_id=54,
         translation_key="post_rec_time",
         entity_category=EntityCategory.CONFIG,
         entity_registry_enabled_default=False,
@@ -340,6 +348,7 @@ HOST_SELECT_ENTITIES = (
     ReolinkHostSelectEntityDescription(
         key="packing_time",
         cmd_key="GetRec",
+        cmd_id=54,
         translation_key="packing_time",
         entity_category=EntityCategory.CONFIG,
         entity_registry_enabled_default=False,

homeassistant/components/reolink/switch.py

@@ -74,6 +74,7 @@ SWITCH_ENTITIES = (
     ReolinkSwitchEntityDescription(
         key="ir_lights",
         cmd_key="GetIrLights",
+        cmd_id=208,
         translation_key="ir_lights",
         entity_category=EntityCategory.CONFIG,
         supported=lambda api, ch: api.supported(ch, "ir_lights"),
@@ -83,6 +84,7 @@ SWITCH_ENTITIES = (
     ReolinkSwitchEntityDescription(
         key="record_audio",
         cmd_key="GetEnc",
+        cmd_id=56,
         translation_key="record_audio",
         entity_category=EntityCategory.CONFIG,
         supported=lambda api, ch: api.supported(ch, "audio"),
@@ -92,6 +94,7 @@ SWITCH_ENTITIES = (
     ReolinkSwitchEntityDescription(
         key="siren_on_event",
         cmd_key="GetAudioAlarm",
+        cmd_id=232,
         translation_key="siren_on_event",
         entity_category=EntityCategory.CONFIG,
         supported=lambda api, ch: api.supported(ch, "siren"),
@@ -136,6 +139,7 @@ SWITCH_ENTITIES = (
     ReolinkSwitchEntityDescription(
         key="email",
         cmd_key="GetEmail",
+        cmd_id=217,
         translation_key="email",
         entity_category=EntityCategory.CONFIG,
         supported=lambda api, ch: api.supported(ch, "email") and api.is_nvr,
@@ -145,6 +149,7 @@ SWITCH_ENTITIES = (
     ReolinkSwitchEntityDescription(
         key="ftp_upload",
         cmd_key="GetFtp",
+        cmd_id=70,
         translation_key="ftp_upload",
         entity_category=EntityCategory.CONFIG,
         supported=lambda api, ch: api.supported(ch, "ftp") and api.is_nvr,
@@ -163,6 +168,7 @@ SWITCH_ENTITIES = (
     ReolinkSwitchEntityDescription(
         key="record",
         cmd_key="GetRec",
+        cmd_id=81,
         translation_key="record",
         entity_category=EntityCategory.CONFIG,
         supported=lambda api, ch: api.supported(ch, "rec_enable") and api.is_nvr,
@@ -200,6 +206,7 @@ SWITCH_ENTITIES = (
     ReolinkSwitchEntityDescription(
         key="doorbell_button_sound",
         cmd_key="GetAudioCfg",
+        cmd_id=264,
         translation_key="doorbell_button_sound",
         entity_category=EntityCategory.CONFIG,
         supported=lambda api, ch: api.supported(ch, "doorbell_button_sound"),
@@ -209,6 +216,7 @@ SWITCH_ENTITIES = (
     ReolinkSwitchEntityDescription(
         key="pir_enabled",
         cmd_key="GetPirInfo",
+        cmd_id=212,
         translation_key="pir_enabled",
         entity_category=EntityCategory.CONFIG,
         entity_registry_enabled_default=False,
@@ -219,6 +227,7 @@ SWITCH_ENTITIES = (
     ReolinkSwitchEntityDescription(
         key="pir_reduce_alarm",
         cmd_key="GetPirInfo",
+        cmd_id=212,
         translation_key="pir_reduce_alarm",
         entity_category=EntityCategory.CONFIG,
         entity_registry_enabled_default=False,
@@ -260,6 +269,7 @@ HOST_SWITCH_ENTITIES = (
     ReolinkHostSwitchEntityDescription(
         key="email",
         cmd_key="GetEmail",
+        cmd_id=217,
         translation_key="email",
         entity_category=EntityCategory.CONFIG,
         supported=lambda api: api.supported(None, "email") and not api.is_hub,
@@ -269,6 +279,7 @@ HOST_SWITCH_ENTITIES = (
     ReolinkHostSwitchEntityDescription(
         key="ftp_upload",
         cmd_key="GetFtp",
+        cmd_id=70,
         translation_key="ftp_upload",
         entity_category=EntityCategory.CONFIG,
         supported=lambda api: api.supported(None, "ftp") and not api.is_hub,
@@ -287,6 +298,7 @@ HOST_SWITCH_ENTITIES = (
     ReolinkHostSwitchEntityDescription(
         key="record",
         cmd_key="GetRec",
+        cmd_id=81,
         translation_key="record",
         entity_category=EntityCategory.CONFIG,
         supported=lambda api: api.supported(None, "rec_enable") and not api.is_hub,

homeassistant/components/risco/strings.json

@@ -27,7 +27,7 @@
       "user": {
         "menu_options": {
           "cloud": "Risco Cloud (recommended)",
-          "local": "Local Risco Panel (advanced)"
+          "local": "Local Risco Panel"
         }
       }
     }

homeassistant/components/roborock/manifest.json

@@ -20,7 +20,7 @@
   "loggers": ["roborock"],
   "quality_scale": "silver",
   "requirements": [
-    "python-roborock==5.14.2",
+    "python-roborock==5.21.0",
     "vacuum-map-parser-roborock==0.1.5"
   ]
 }

homeassistant/components/roborock/number.py

@@ -35,7 +35,7 @@ class RoborockNumberDescription(NumberEntityDescription):
     trait: Callable[[PropertiesApi], Any | None]
     """Function to determine if number entity is supported by the device."""
 
-    get_value: Callable[[Any], float]
+    get_value: Callable[[Any], float | None]
     """Function to get the value from the trait."""
 
     set_value: Callable[[Any, float], Coroutine[Any, Any, None]]
@@ -51,7 +51,9 @@ NUMBER_DESCRIPTIONS: list[RoborockNumberDescription] = [
         native_unit_of_measurement=PERCENTAGE,
         entity_category=EntityCategory.CONFIG,
         trait=lambda api: api.sound_volume,
-        get_value=lambda trait: float(trait.volume),
+        get_value=lambda trait: (
+            float(trait.volume) if trait.volume is not None else None
+        ),
         set_value=lambda trait, value: trait.set_volume(int(value)),
     )
 ]

homeassistant/components/roborock/time.py

@@ -37,7 +37,7 @@ class RoborockTimeDescription(TimeEntityDescription):
     trait: Callable[[Any], Any | None]
     """Function to determine if time entity is supported by the device."""
 
-    get_value: Callable[[Any], datetime.time]
+    get_value: Callable[[Any], datetime.time | None]
     """Function to get the value from the trait."""
 
     update_value: Callable[[Any, datetime.time], Coroutine[Any, Any, None]]
@@ -58,9 +58,7 @@ TIME_DESCRIPTIONS: list[RoborockTimeDescription] = [
                 end_minute=trait.end_minute,
             )
         ),
-        get_value=lambda trait: datetime.time(
-            hour=trait.start_hour, minute=trait.start_minute
-        ),
+        get_value=lambda trait: trait.start_time,
         entity_category=EntityCategory.CONFIG,
     ),
     RoborockTimeDescription(
@@ -76,9 +74,7 @@ TIME_DESCRIPTIONS: list[RoborockTimeDescription] = [
                 end_minute=desired_time.minute,
             )
         ),
-        get_value=lambda trait: datetime.time(
-            hour=trait.end_hour, minute=trait.end_minute
-        ),
+        get_value=lambda trait: trait.end_time,
         entity_category=EntityCategory.CONFIG,
     ),
     RoborockTimeDescription(
@@ -94,9 +90,7 @@ TIME_DESCRIPTIONS: list[RoborockTimeDescription] = [
                 end_minute=trait.end_minute,
             )
         ),
-        get_value=lambda trait: datetime.time(
-            hour=trait.start_hour, minute=trait.start_minute
-        ),
+        get_value=lambda trait: trait.start_time,
         entity_category=EntityCategory.CONFIG,
         entity_registry_enabled_default=False,
     ),
@@ -113,9 +107,7 @@ TIME_DESCRIPTIONS: list[RoborockTimeDescription] = [
                 end_minute=desired_time.minute,
             )
         ),
-        get_value=lambda trait: datetime.time(
-            hour=trait.end_hour, minute=trait.end_minute
-        ),
+        get_value=lambda trait: trait.end_time,
         entity_category=EntityCategory.CONFIG,
         entity_registry_enabled_default=False,
     ),

homeassistant/components/smlight/manifest.json

@@ -12,7 +12,7 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "quality_scale": "silver",
-  "requirements": ["pysmlight==0.3.2"],
+  "requirements": ["pysmlight==0.4.0"],
   "zeroconf": [
     {
       "type": "_slzb-06._tcp.local."

homeassistant/components/steam_online/config_flow.py

@@ -3,14 +3,13 @@
 from collections.abc import Iterator, Mapping
 from typing import Any, override
 
-import steam
+import steam.api
 import voluptuous as vol
 
 from homeassistant.config_entries import (
-    SOURCE_REAUTH,
     ConfigFlow,
     ConfigFlowResult,
-    OptionsFlow,
+    OptionsFlowWithReload,
 )
 from homeassistant.const import CONF_API_KEY, Platform
 from homeassistant.core import callback
@@ -22,6 +21,14 @@ from .coordinator import SteamConfigEntry
 # To avoid too long request URIs, the amount of ids to request is limited
 MAX_IDS_TO_REQUEST = 275
 
+STEP_USER_DATA_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_API_KEY): str,
+        vol.Required(CONF_ACCOUNT): str,
+    }
+)
+STEP_REAUTH_DATA_SCHEMA = vol.Schema({vol.Required(CONF_API_KEY): str})
+
 
 def validate_input(user_input: dict[str, str]) -> dict[str, str | int]:
     """Handle common flow input validation."""
@@ -49,29 +56,23 @@ class SteamFlowHandler(ConfigFlow, domain=DOMAIN):
     ) -> ConfigFlowResult:
         """Handle a flow initiated by the user."""
         errors = {}
-        if user_input is None and self.source == SOURCE_REAUTH:
-            user_input = {CONF_ACCOUNT: self._get_reauth_entry().data[CONF_ACCOUNT]}
-        elif user_input is not None:
+        if user_input is not None:
+            await self.async_set_unique_id(user_input[CONF_ACCOUNT])
+            self._abort_if_unique_id_configured()
             try:
                 res = await self.hass.async_add_executor_job(validate_input, user_input)
                 if res is not None:
                     name = str(res["personaname"])
                 else:
                     errors["base"] = "invalid_account"
-            except (steam.api.HTTPError, steam.api.HTTPTimeoutError) as ex:
-                errors["base"] = "cannot_connect"
-                if "403" in str(ex):
-                    errors["base"] = "invalid_auth"
+            except steam.api.HTTPError as ex:
+                errors["base"] = (
+                    "invalid_auth" if "403" in str(ex) else "cannot_connect"
+                )
             except Exception as ex:  # noqa: BLE001
                 LOGGER.exception("Unknown exception: %s", ex)
                 errors["base"] = "unknown"
             if not errors:
-                entry = await self.async_set_unique_id(user_input[CONF_ACCOUNT])
-                if entry and self.source == SOURCE_REAUTH:
-                    self.hass.config_entries.async_update_entry(entry, data=user_input)
-                    await self.hass.config_entries.async_reload(entry.entry_id)
-                    return self.async_abort(reason="reauth_successful")
-                self._abort_if_unique_id_configured()
                 return self.async_create_entry(
                     title=name,
                     data=user_input,
@@ -80,15 +81,8 @@ class SteamFlowHandler(ConfigFlow, domain=DOMAIN):
         user_input = user_input or {}
         return self.async_show_form(
             step_id="user",
-            data_schema=vol.Schema(
-                {
-                    vol.Required(
-                        CONF_API_KEY, default=user_input.get(CONF_API_KEY) or ""
-                    ): str,
-                    vol.Required(
-                        CONF_ACCOUNT, default=user_input.get(CONF_ACCOUNT) or ""
-                    ): str,
-                }
+            data_schema=self.add_suggested_values_to_schema(
+                data_schema=STEP_USER_DATA_SCHEMA, suggested_values=user_input
             ),
             errors=errors,
             description_placeholders=PLACEHOLDERS,
@@ -104,12 +98,34 @@ class SteamFlowHandler(ConfigFlow, domain=DOMAIN):
         self, user_input: dict[str, str] | None = None
     ) -> ConfigFlowResult:
         """Confirm reauth dialog."""
-        if user_input is not None:
-            return await self.async_step_user()
+        errors: dict[str, str] = {}
+        entry = self._get_reauth_entry()
 
-        self._set_confirm_only()
+        if user_input is not None:
+            try:
+                if not await self.hass.async_add_executor_job(
+                    validate_input, {**entry.data, **user_input}
+                ):
+                    errors["base"] = "invalid_account"
+            except steam.api.HTTPError as ex:
+                errors["base"] = (
+                    "invalid_auth" if "403" in str(ex) else "cannot_connect"
+                )
+            except Exception as ex:  # noqa: BLE001
+                LOGGER.exception("Unknown exception: %s", ex)
+                errors["base"] = "unknown"
+
+            if not errors:
+                return self.async_update_reload_and_abort(
+                    entry, data_updates=user_input
+                )
         return self.async_show_form(
-            step_id="reauth_confirm", description_placeholders=PLACEHOLDERS
+            step_id="reauth_confirm",
+            data_schema=self.add_suggested_values_to_schema(
+                data_schema=STEP_REAUTH_DATA_SCHEMA, suggested_values=user_input
+            ),
+            errors=errors,
+            description_placeholders=PLACEHOLDERS,
         )
 
 
@@ -118,7 +134,7 @@ def _batch_ids(ids: list[str]) -> Iterator[list[str]]:
         yield ids[i : i + MAX_IDS_TO_REQUEST]
 
 
-class SteamOptionsFlowHandler(OptionsFlow):
+class SteamOptionsFlowHandler(OptionsFlowWithReload):
     """Handle Steam client options."""
 
     def __init__(self, entry: SteamConfigEntry) -> None:
@@ -145,7 +161,6 @@ class SteamOptionsFlowHandler(OptionsFlow):
                     if _id in user_input[CONF_ACCOUNTS]
                 }
             }
-            await self.hass.config_entries.async_reload(self.config_entry.entry_id)
             return self.async_create_entry(title="", data=channel_data)
         error = None
         try:

homeassistant/components/steam_online/coordinator.py

@@ -3,7 +3,7 @@
 from datetime import timedelta
 from typing import override
 
-import steam
+import steam.api
 from steam.api import _interface_method as INTMethod
 
 from homeassistant.config_entries import ConfigEntry
@@ -70,7 +70,7 @@ class SteamDataUpdateCoordinator(
         try:
             return await self.hass.async_add_executor_job(self._update)
 
-        except (steam.api.HTTPError, steam.api.HTTPTimeoutError) as ex:
+        except steam.api.HTTPError as ex:
             if "401" in str(ex):
                 raise ConfigEntryAuthFailed from ex
             raise UpdateFailed(ex) from ex

homeassistant/components/steam_online/strings.json

@@ -12,7 +12,13 @@
     },
     "step": {
       "reauth_confirm": {
-        "description": "The Steam integration needs to be manually re-authenticated\n\nYou can find your Steam Web API key [**here**]({api_key_url}).",
+        "data": {
+          "api_key": "[%key:component::steam_online::config::step::user::data::api_key%]"
+        },
+        "data_description": {
+          "api_key": "[%key:component::steam_online::config::step::user::data_description::api_key%]"
+        },
+        "description": "The Steam integration requires re-authentication.\n\nYou can find your Steam Web API key [**here**]({api_key_url}).",
         "title": "[%key:common::config_flow::title::reauth%]"
       },
       "user": {

homeassistant/components/sun/condition.py

@@ -3,23 +3,52 @@
 from datetime import datetime, timedelta
 from typing import Any, Unpack, cast, override
 
+import astral.sun
 import voluptuous as vol
 
-from homeassistant.const import CONF_OPTIONS, SUN_EVENT_SUNRISE, SUN_EVENT_SUNSET
+from homeassistant.const import (
+    CONF_ENTITY_ID,
+    CONF_OPTIONS,
+    CONF_TARGET,
+    CONF_TYPE,
+    DEGREE,
+    SUN_EVENT_SUNRISE,
+    SUN_EVENT_SUNSET,
+)
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.automation import move_top_level_schema_fields_to_options
+from homeassistant.helpers.automation import (
+    DomainSpec,
+    move_top_level_schema_fields_to_options,
+)
 from homeassistant.helpers.condition import (
+    ATTR_BEHAVIOR,
+    BEHAVIOR_ANY,
     Condition,
     ConditionCheckParams,
     ConditionConfig,
+    EntityNumericalConditionBase,
     condition_trace_set_result,
     condition_trace_update_result,
 )
-from homeassistant.helpers.sun import get_astral_event_date
+from homeassistant.helpers.selector import (
+    NumericThresholdMode,
+    NumericThresholdSelector,
+    NumericThresholdSelectorConfig,
+)
+from homeassistant.helpers.sun import get_astral_event_date, get_astral_observer
 from homeassistant.helpers.typing import ConfigType
 from homeassistant.util import dt as dt_util
 
+from .const import (
+    DOMAIN,
+    ELEVATION_ASTRONOMICAL,
+    ELEVATION_CIVIL,
+    ELEVATION_HORIZON,
+    ELEVATION_NAUTICAL,
+    STATE_ATTR_ELEVATION,
+)
+
 _OPTIONS_SCHEMA_DICT: dict[vol.Marker, Any] = {
     vol.Optional("before"): cv.sun_event,
     vol.Optional("before_offset"): cv.time_period,
@@ -56,34 +85,18 @@ def sun(
     has_sunrise_condition = SUN_EVENT_SUNRISE in (before, after)
     has_sunset_condition = SUN_EVENT_SUNSET in (before, after)
 
-    after_sunrise = today > dt_util.as_local(cast(datetime, sunrise)).date()
+    after_sunrise = sunrise is not None and today > dt_util.as_local(sunrise).date()
     if after_sunrise and has_sunrise_condition:
         tomorrow = today + timedelta(days=1)
         sunrise = get_astral_event_date(hass, SUN_EVENT_SUNRISE, tomorrow)
 
-    after_sunset = today > dt_util.as_local(cast(datetime, sunset)).date()
+    after_sunset = sunset is not None and today > dt_util.as_local(sunset).date()
     if after_sunset and has_sunset_condition:
         tomorrow = today + timedelta(days=1)
         sunset = get_astral_event_date(hass, SUN_EVENT_SUNSET, tomorrow)
 
-    # Special case: before sunrise OR after sunset
-    # This will handle the very rare case in the polar region when the sun rises/sets
-    # but does not set/rise.
-    # However this entire condition does not handle those full days of darkness
-    # or light, the following should be used instead:
-    #
-    #    condition:
-    #      condition: state
-    #      entity_id: sun.sun
-    #      state: 'above_horizon' (or 'below_horizon')
-    #
-    if before == SUN_EVENT_SUNRISE and after == SUN_EVENT_SUNSET:
-        wanted_time_before = cast(datetime, sunrise) + before_offset
-        condition_trace_update_result(wanted_time_before=wanted_time_before)
-        wanted_time_after = cast(datetime, sunset) + after_offset
-        condition_trace_update_result(wanted_time_after=wanted_time_after)
-        return utcnow < wanted_time_before or utcnow > wanted_time_after
-
+    # A missing sunrise/sunset means the sun doesn't rise/set on this day, which
+    # happens in polar regions.
     if sunrise is None and has_sunrise_condition:
         # There is no sunrise today
         condition_trace_set_result(False, message="no sunrise today")
@@ -94,6 +107,16 @@ def sun(
         condition_trace_set_result(False, message="no sunset today")
         return False
 
+    # "before: sunrise" combined with "after: sunset" describes the dark period
+    # around midnight, so it is evaluated as an OR (true before sunrise or after
+    # sunset) rather than the usual AND of the two bounds.
+    if before == SUN_EVENT_SUNRISE and after == SUN_EVENT_SUNSET:
+        wanted_time_before = cast(datetime, sunrise) + before_offset
+        condition_trace_update_result(wanted_time_before=wanted_time_before)
+        wanted_time_after = cast(datetime, sunset) + after_offset
+        condition_trace_update_result(wanted_time_after=wanted_time_after)
+        return utcnow < wanted_time_before or utcnow > wanted_time_after
+
     if before == SUN_EVENT_SUNRISE:
         wanted_time_before = cast(datetime, sunrise) + before_offset
         condition_trace_update_result(wanted_time_before=wanted_time_before)
@@ -167,8 +190,193 @@ class SunCondition(Condition):
         )
 
 
+# The sun is a singleton, so these conditions take no target and no options.
+_STATE_CONDITION_SCHEMA = vol.Schema({vol.Required(CONF_OPTIONS, default=dict): {}})
+
+# The sun is a singleton, so the elevation condition always targets sun.sun
+# instead of asking the user to pick an entity.
+_SUN_ENTITY_ID = f"{DOMAIN}.{DOMAIN}"
+_ELEVATION_DOMAIN_SPECS = {DOMAIN: DomainSpec(value_source=STATE_ATTR_ELEVATION)}
+
+
+def _solar_position(hass: HomeAssistant) -> tuple[float, bool]:
+    """Return the sun's current elevation in degrees and whether it is rising."""
+    observer = get_astral_observer(hass)
+    now = dt_util.utcnow()
+    elevation = astral.sun.elevation(observer, now)
+    rising = astral.sun.elevation(observer, now + timedelta(minutes=1)) > elevation
+    return elevation, rising
+
+
+class _SunStateCondition(Condition):
+    """Base class for the option-less sun state conditions."""
+
+    @classmethod
+    @override
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, _STATE_CONDITION_SCHEMA(config))
+
+
+class _UpCondition(_SunStateCondition):
+    """Test if the sun is up."""
+
+    @override
+    def _async_check(self, **kwargs: Unpack[ConditionCheckParams]) -> bool:
+        """Check the condition."""
+        elevation, _ = _solar_position(self._hass)
+        return elevation >= ELEVATION_HORIZON
+
+
+class _SetCondition(_SunStateCondition):
+    """Test if the sun is set."""
+
+    @override
+    def _async_check(self, **kwargs: Unpack[ConditionCheckParams]) -> bool:
+        """Check the condition."""
+        elevation, _ = _solar_position(self._hass)
+        return elevation < ELEVATION_HORIZON
+
+
+class _AscendingCondition(_SunStateCondition):
+    """Test if the sun is ascending."""
+
+    @override
+    def _async_check(self, **kwargs: Unpack[ConditionCheckParams]) -> bool:
+        """Check the condition."""
+        _, rising = _solar_position(self._hass)
+        return rising
+
+
+class _DescendingCondition(_SunStateCondition):
+    """Test if the sun is descending."""
+
+    @override
+    def _async_check(self, **kwargs: Unpack[ConditionCheckParams]) -> bool:
+        """Check the condition."""
+        _, rising = _solar_position(self._hass)
+        return not rising
+
+
+class _NightCondition(_SunStateCondition):
+    """Test if it is night (the sun is below all twilight)."""
+
+    @override
+    def _async_check(self, **kwargs: Unpack[ConditionCheckParams]) -> bool:
+        """Check the condition."""
+        elevation, _ = _solar_position(self._hass)
+        return elevation <= ELEVATION_ASTRONOMICAL
+
+
+_TWILIGHT_ANY = "any"
+_TWILIGHT_CIVIL = "civil"
+_TWILIGHT_NAUTICAL = "nautical"
+_TWILIGHT_ASTRONOMICAL = "astronomical"
+
+# Elevation band (min, max) in degrees for each twilight type, bounded by the
+# horizon and the twilight elevations.
+_TWILIGHT_BANDS = {
+    _TWILIGHT_ANY: (ELEVATION_ASTRONOMICAL, ELEVATION_HORIZON),
+    _TWILIGHT_CIVIL: (ELEVATION_CIVIL, ELEVATION_HORIZON),
+    _TWILIGHT_NAUTICAL: (ELEVATION_NAUTICAL, ELEVATION_CIVIL),
+    _TWILIGHT_ASTRONOMICAL: (ELEVATION_ASTRONOMICAL, ELEVATION_NAUTICAL),
+}
+
+_TWILIGHT_CONDITION_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_OPTIONS, default=dict): {
+            vol.Optional(CONF_TYPE, default=_TWILIGHT_ANY): vol.In(_TWILIGHT_BANDS),
+        }
+    }
+)
+
+
+class _TwilightCondition(Condition):
+    """Base class for the morning and evening twilight conditions.
+
+    The sun is in twilight when its elevation is within the selected band;
+    morning twilight requires the sun to be rising and evening twilight to be
+    descending.
+    """
+
+    _rising: bool
+
+    @classmethod
+    @override
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, _TWILIGHT_CONDITION_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: ConditionConfig) -> None:
+        """Initialize condition."""
+        super().__init__(hass, config)
+        assert config.options is not None
+        self._low, self._high = _TWILIGHT_BANDS[config.options[CONF_TYPE]]
+
+    @override
+    def _async_check(self, **kwargs: Unpack[ConditionCheckParams]) -> bool:
+        """Check the condition."""
+        elevation, rising = _solar_position(self._hass)
+        return rising == self._rising and self._low <= elevation <= self._high
+
+
+class _MorningTwilightCondition(_TwilightCondition):
+    """Test if it is morning twilight (the sun is rising through twilight)."""
+
+    _rising = True
+
+
+class _EveningTwilightCondition(_TwilightCondition):
+    """Test if it is evening twilight (the sun is descending through twilight)."""
+
+    _rising = False
+
+
+_ELEVATION_CONDITION_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_OPTIONS, default=dict): {
+            vol.Required("threshold"): NumericThresholdSelector(
+                NumericThresholdSelectorConfig(mode=NumericThresholdMode.IS)
+            ),
+        }
+    }
+)
+
+
+class _ElevationCondition(EntityNumericalConditionBase):
+    """Test the sun's elevation against a threshold."""
+
+    _domain_specs = _ELEVATION_DOMAIN_SPECS
+    _valid_unit = DEGREE
+    _schema = _ELEVATION_CONDITION_SCHEMA
+
+    @classmethod
+    @override
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config and target the singleton sun entity."""
+        config = cast(ConfigType, cls._schema(config))
+        config[CONF_TARGET] = {CONF_ENTITY_ID: [_SUN_ENTITY_ID]}
+        # `behavior` is needed by `EntityConditionBase.__init__`.
+        config[CONF_OPTIONS][ATTR_BEHAVIOR] = BEHAVIOR_ANY
+        return config
+
+
 CONDITIONS: dict[str, type[Condition]] = {
     "_": SunCondition,
+    "is_up": _UpCondition,
+    "is_set": _SetCondition,
+    "is_ascending": _AscendingCondition,
+    "is_descending": _DescendingCondition,
+    "elevation": _ElevationCondition,
+    "is_night": _NightCondition,
+    "is_morning_twilight": _MorningTwilightCondition,
+    "is_evening_twilight": _EveningTwilightCondition,
 }
 
 

homeassistant/components/sun/conditions.yaml

@@ -0,0 +1,46 @@
+.type: &condition_type
+  required: true
+  default: any
+  selector:
+    select:
+      translation_key: twilight_type
+      options:
+        - any
+        - civil
+        - nautical
+        - astronomical
+
+.elevation_threshold_entity: &condition_elevation_threshold_entity
+  - domain: input_number
+    unit_of_measurement: "°"
+  - domain: number
+    unit_of_measurement: "°"
+  - domain: sensor
+    unit_of_measurement: "°"
+
+.elevation_threshold_number: &condition_elevation_threshold_number
+  min: -90
+  max: 90
+  mode: box
+  unit_of_measurement: "°"
+
+is_up: {}
+is_set: {}
+is_ascending: {}
+is_descending: {}
+is_night: {}
+elevation:
+  fields:
+    threshold:
+      required: true
+      selector:
+        numeric_threshold:
+          entity: *condition_elevation_threshold_entity
+          mode: is
+          number: *condition_elevation_threshold_number
+is_morning_twilight:
+  fields:
+    type: *condition_type
+is_evening_twilight:
+  fields:
+    type: *condition_type

homeassistant/components/sun/const.py

@@ -2,10 +2,21 @@
 
 from typing import Final
 
+import astral
+
 DOMAIN: Final = "sun"
 
 DEFAULT_NAME: Final = "Sun"
 
+# Elevation of the sun's center at the horizon, in degrees. This is the value
+# astral uses for sunrise/sunset (atmospheric refraction plus the sun's radius).
+ELEVATION_HORIZON: Final = -0.833
+
+# Sun elevation, in degrees, at each twilight boundary
+ELEVATION_CIVIL: Final[float] = -astral.Depression.CIVIL.value
+ELEVATION_NAUTICAL: Final[float] = -astral.Depression.NAUTICAL.value
+ELEVATION_ASTRONOMICAL: Final[float] = -astral.Depression.ASTRONOMICAL.value
+
 SIGNAL_POSITION_CHANGED = f"{DOMAIN}_position_changed"
 SIGNAL_EVENTS_CHANGED = f"{DOMAIN}_events_changed"
 

homeassistant/components/sun/entity.py

@@ -24,6 +24,10 @@ from homeassistant.helpers.sun import (
 from homeassistant.util import dt as dt_util
 
 from .const import (
+    ELEVATION_ASTRONOMICAL,
+    ELEVATION_CIVIL,
+    ELEVATION_HORIZON,
+    ELEVATION_NAUTICAL,
     SIGNAL_EVENTS_CHANGED,
     SIGNAL_POSITION_CHANGED,
     STATE_ABOVE_HORIZON,
@@ -67,12 +71,8 @@ PHASE_SMALL_DAY = "small_day"
 # > 10° above horizon
 PHASE_DAY = "day"
 
-# Depression angle (degrees below the horizon) of the sun at each dawn/dusk
-# phase boundary. A negative value means the sun is above the horizon.
-DEPRESSION_ASTRONOMICAL = 18.0
-DEPRESSION_NAUTICAL = 12.0
-DEPRESSION_CIVIL = 6.0
-DEPRESSION_SMALL_DAY = -10.0
+# Sun elevation (degrees above the horizon) at the start of the "small day" phase.
+_ELEVATION_SMALL_DAY = 10.0
 
 # 4 mins is one degree of arc change of the sun on its circle.
 # During the night and the middle of the day we don't update
@@ -162,8 +162,7 @@ class Sun(Entity):
     @override
     def state(self) -> str:
         """Return the state of the sun."""
-        # 0.8333 is the same value as astral uses
-        if self.solar_elevation > -0.833:
+        if self.solar_elevation > ELEVATION_HORIZON:
             return STATE_ABOVE_HORIZON
 
         return STATE_BELOW_HORIZON
@@ -189,8 +188,11 @@ class Sun(Entity):
         utc_point_in_time: datetime,
         sun_event: str,
         before: str | None,
-        depression: float | None = None,
+        elevation: float | None = None,
     ) -> datetime:
+        # astral takes a depression (degrees below the horizon), i.e. the
+        # negated elevation.
+        depression = None if elevation is None else -elevation
         next_utc = get_observer_astral_event_next(
             self.observer, sun_event, utc_point_in_time, depression=depression
         )
@@ -209,36 +211,36 @@ class Sun(Entity):
         # Work our way around the solar cycle, figure out the next
         # phase. Some of these are stored.
         self._check_event(
-            utc_point_in_time, "dawn", PHASE_NIGHT, DEPRESSION_ASTRONOMICAL
+            utc_point_in_time, "dawn", PHASE_NIGHT, ELEVATION_ASTRONOMICAL
         )
         self._check_event(
-            utc_point_in_time, "dawn", PHASE_ASTRONOMICAL_TWILIGHT, DEPRESSION_NAUTICAL
+            utc_point_in_time, "dawn", PHASE_ASTRONOMICAL_TWILIGHT, ELEVATION_NAUTICAL
         )
         self.next_dawn = self._check_event(
-            utc_point_in_time, "dawn", PHASE_NAUTICAL_TWILIGHT, DEPRESSION_CIVIL
+            utc_point_in_time, "dawn", PHASE_NAUTICAL_TWILIGHT, ELEVATION_CIVIL
         )
         self.next_rising = self._check_event(
             utc_point_in_time, SUN_EVENT_SUNRISE, PHASE_TWILIGHT
         )
         self._check_event(
-            utc_point_in_time, "dawn", PHASE_SMALL_DAY, DEPRESSION_SMALL_DAY
+            utc_point_in_time, "dawn", PHASE_SMALL_DAY, _ELEVATION_SMALL_DAY
         )
         self.next_noon = self._check_event(utc_point_in_time, "noon", None)
-        self._check_event(utc_point_in_time, "dusk", PHASE_DAY, DEPRESSION_SMALL_DAY)
+        self._check_event(utc_point_in_time, "dusk", PHASE_DAY, _ELEVATION_SMALL_DAY)
         self.next_setting = self._check_event(
             utc_point_in_time, SUN_EVENT_SUNSET, PHASE_SMALL_DAY
         )
         self.next_dusk = self._check_event(
-            utc_point_in_time, "dusk", PHASE_TWILIGHT, DEPRESSION_CIVIL
+            utc_point_in_time, "dusk", PHASE_TWILIGHT, ELEVATION_CIVIL
         )
         self._check_event(
-            utc_point_in_time, "dusk", PHASE_NAUTICAL_TWILIGHT, DEPRESSION_NAUTICAL
+            utc_point_in_time, "dusk", PHASE_NAUTICAL_TWILIGHT, ELEVATION_NAUTICAL
         )
         self._check_event(
             utc_point_in_time,
             "dusk",
             PHASE_ASTRONOMICAL_TWILIGHT,
-            DEPRESSION_ASTRONOMICAL,
+            ELEVATION_ASTRONOMICAL,
         )
         self.next_midnight = self._check_event(utc_point_in_time, "midnight", None)
 
@@ -252,11 +254,11 @@ class Sun(Entity):
                 self.phase = PHASE_DAY
             elif elevation >= 0:
                 self.phase = PHASE_SMALL_DAY
-            elif elevation >= -6:
+            elif elevation >= ELEVATION_CIVIL:
                 self.phase = PHASE_TWILIGHT
-            elif elevation >= -12:
+            elif elevation >= ELEVATION_NAUTICAL:
                 self.phase = PHASE_NAUTICAL_TWILIGHT
-            elif elevation >= -18:
+            elif elevation >= ELEVATION_ASTRONOMICAL:
                 self.phase = PHASE_ASTRONOMICAL_TWILIGHT
             else:
                 self.phase = PHASE_NIGHT

homeassistant/components/sun/icons.json

@@ -1,4 +1,30 @@
 {
+  "conditions": {
+    "elevation": {
+      "condition": "mdi:sun-angle"
+    },
+    "is_ascending": {
+      "condition": "mdi:weather-sunset-up"
+    },
+    "is_descending": {
+      "condition": "mdi:weather-sunset-down"
+    },
+    "is_evening_twilight": {
+      "condition": "mdi:weather-sunset-down"
+    },
+    "is_morning_twilight": {
+      "condition": "mdi:weather-sunset-up"
+    },
+    "is_night": {
+      "condition": "mdi:weather-night"
+    },
+    "is_set": {
+      "condition": "mdi:weather-sunny-off"
+    },
+    "is_up": {
+      "condition": "mdi:weather-sunny"
+    }
+  },
   "entity": {
     "binary_sensor": {
       "solar_rising": {

homeassistant/components/sun/strings.json

@@ -1,10 +1,62 @@
 {
   "common": {
+    "condition_threshold_name": "Threshold type",
     "trigger_for_name": "For at least",
     "trigger_threshold_name": "Threshold type",
     "twilight_type_description": "The phase of twilight.",
     "twilight_type_name": "Twilight type"
   },
+  "conditions": {
+    "elevation": {
+      "description": "Tests the sun's elevation against a threshold you set.",
+      "fields": {
+        "threshold": {
+          "name": "[%key:component::sun::common::condition_threshold_name%]"
+        }
+      },
+      "name": "Sun elevation"
+    },
+    "is_ascending": {
+      "description": "Tests if the sun is ascending.",
+      "name": "Sun is ascending"
+    },
+    "is_descending": {
+      "description": "Tests if the sun is descending.",
+      "name": "Sun is descending"
+    },
+    "is_evening_twilight": {
+      "description": "Tests if it is evening twilight, optionally of a specific type.",
+      "fields": {
+        "type": {
+          "description": "[%key:component::sun::common::twilight_type_description%]",
+          "name": "[%key:component::sun::common::twilight_type_name%]"
+        }
+      },
+      "name": "It is evening twilight"
+    },
+    "is_morning_twilight": {
+      "description": "Tests if it is morning twilight, optionally of a specific type.",
+      "fields": {
+        "type": {
+          "description": "[%key:component::sun::common::twilight_type_description%]",
+          "name": "[%key:component::sun::common::twilight_type_name%]"
+        }
+      },
+      "name": "It is morning twilight"
+    },
+    "is_night": {
+      "description": "Tests if it is night.",
+      "name": "It is night"
+    },
+    "is_set": {
+      "description": "Tests if the sun is set.",
+      "name": "Sun is set"
+    },
+    "is_up": {
+      "description": "Tests if the sun is up.",
+      "name": "Sun is up"
+    }
+  },
   "config": {
     "step": {
       "user": {
@@ -45,6 +97,7 @@
   "selector": {
     "twilight_type": {
       "options": {
+        "any": "Any",
         "astronomical": "Astronomical",
         "civil": "Civil",
         "nautical": "Nautical"

homeassistant/components/sun/trigger.py

@@ -3,7 +3,6 @@
 from datetime import datetime, timedelta
 from typing import Any, cast, override
 
-import astral
 import voluptuous as vol
 
 from homeassistant.const import (
@@ -47,7 +46,13 @@ from homeassistant.helpers.trigger import (
 from homeassistant.helpers.typing import ConfigType
 from homeassistant.util import dt as dt_util
 
-from .const import DOMAIN, STATE_ATTR_ELEVATION
+from .const import (
+    DOMAIN,
+    ELEVATION_ASTRONOMICAL,
+    ELEVATION_CIVIL,
+    ELEVATION_NAUTICAL,
+    STATE_ATTR_ELEVATION,
+)
 
 # Names of solar events supported by the astral.sun module
 _SUN_EVENT_SOLAR_NOON = "noon"
@@ -59,11 +64,11 @@ _TWILIGHT_CIVIL = "civil"
 _TWILIGHT_NAUTICAL = "nautical"
 _TWILIGHT_ASTRONOMICAL = "astronomical"
 
-# Sun depression below the horizon for each twilight phase, as defined by astral.
-_TWILIGHT_DEPRESSIONS = {
-    _TWILIGHT_CIVIL: astral.Depression.CIVIL,
-    _TWILIGHT_NAUTICAL: astral.Depression.NAUTICAL,
-    _TWILIGHT_ASTRONOMICAL: astral.Depression.ASTRONOMICAL,
+# Sun elevation at each twilight boundary.
+_TWILIGHT_ELEVATIONS = {
+    _TWILIGHT_CIVIL: ELEVATION_CIVIL,
+    _TWILIGHT_NAUTICAL: ELEVATION_NAUTICAL,
+    _TWILIGHT_ASTRONOMICAL: ELEVATION_ASTRONOMICAL,
 }
 
 # The sun is a singleton, so the elevation triggers always target sun.sun
@@ -228,7 +233,7 @@ _DAWN_DUSK_TRIGGER_SCHEMA = vol.Schema(
     {
         vol.Required(CONF_OPTIONS, default=dict): {
             vol.Optional(CONF_TYPE, default=_TWILIGHT_CIVIL): vol.In(
-                _TWILIGHT_DEPRESSIONS
+                _TWILIGHT_ELEVATIONS
             ),
         }
     }
@@ -244,7 +249,7 @@ class SunDawnDuskTrigger(SunEventTrigger):
         """Initialize the trigger."""
         super().__init__(hass, config)
         self._twilight: str = self._options[CONF_TYPE]
-        self._depression = _TWILIGHT_DEPRESSIONS[self._twilight]
+        self._elevation = _TWILIGHT_ELEVATIONS[self._twilight]
 
     @override
     def _get_next_event(self, utc_point_in_time: datetime) -> datetime:
@@ -252,7 +257,9 @@ class SunDawnDuskTrigger(SunEventTrigger):
             get_astral_observer(self._hass),
             self._event,
             utc_point_in_time,
-            depression=self._depression,
+            # astral takes a depression (degrees below the horizon), i.e. the
+            # negated elevation.
+            depression=-self._elevation,
         )
 
     @override

homeassistant/components/switchbot_cloud/manifest.json

@@ -14,5 +14,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["switchbot_api"],
-  "requirements": ["switchbot-api==2.11.1"]
+  "requirements": ["switchbot-api==2.12.0"]
 }

homeassistant/components/synology_dsm/icons.json

@@ -11,6 +11,7 @@
         "state": {
           "cool": "mdi:fan-speed-2",
           "full_speed": "mdi:fan-speed-3",
+          "low_power": "mdi:fan-chevron-down",
           "quiet": "mdi:fan-speed-1"
         }
       }

homeassistant/components/synology_dsm/manifest.json

@@ -8,7 +8,7 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["synology_dsm"],
-  "requirements": ["py-synologydsm-api==2.10.0"],
+  "requirements": ["py-synologydsm-api==2.10.1"],
   "ssdp": [
     {
       "deviceType": "urn:schemas-upnp-org:device:Basic:1",

homeassistant/components/synology_dsm/select.py

@@ -15,6 +15,7 @@ from .coordinator import SynologyDSMCentralUpdateCoordinator, SynologyDSMConfigE
 from .entity import SynologyDSMBaseEntity, SynologyDSMEntityDescription
 
 FAN_SPEED_MAP = {
+    FanSpeed.QUIET_STOP: "low_power",
     FanSpeed.QUIET: "quiet",
     FanSpeed.COOL: "cool",
     FanSpeed.FULL: "full_speed",
@@ -47,7 +48,6 @@ class SynologyDSMFanSpeedMode(
 ):
     """Represent a Synology DSM fan speed mode select entity."""
 
-    _attr_options = list(FAN_SPEED_MAP.values())
     entity_description: SynologyDSMSelectEntityDescription
 
     def __init__(
@@ -62,6 +62,11 @@ class SynologyDSMFanSpeedMode(
             translation_key="fan_speed_mode",
             entity_category=EntityCategory.CONFIG,
         )
+        self._attr_options = [
+            val
+            for fs, val in FAN_SPEED_MAP.items()
+            if fs in api.dsm.hardware.supported_fan_speeds
+        ]
         super().__init__(api, coordinator, description)
 
     @property

homeassistant/components/synology_dsm/strings.json

@@ -87,6 +87,7 @@
         "state": {
           "cool": "Cool mode",
           "full_speed": "Full-speed mode",
+          "low_power": "Low-Power mode",
           "quiet": "Quiet mode"
         }
       }

homeassistant/components/tami4/config_flow.py

@@ -67,12 +67,13 @@ class Tami4ConfigFlow(ConfigFlow, domain=DOMAIN):
         if user_input is not None:
             otp = user_input["otp"]
             try:
-                refresh_token = await self.hass.async_add_executor_job(
-                    Tami4EdgeAPI.submit_otp, self.phone, otp
-                )
-                # pylint: disable-next=home-assistant-sequential-executor-jobs
-                api = await self.hass.async_add_executor_job(
-                    Tami4EdgeAPI, refresh_token
+
+                def _submit_otp_and_create_api() -> tuple[str, Tami4EdgeAPI]:
+                    refresh_token = Tami4EdgeAPI.submit_otp(self.phone, otp)
+                    return refresh_token, Tami4EdgeAPI(refresh_token)
+
+                refresh_token, api = await self.hass.async_add_executor_job(
+                    _submit_otp_and_create_api
                 )
             except exceptions.OTPFailedException:
                 errors["base"] = "invalid_auth"

homeassistant/components/template/alarm_control_panel.py

@@ -15,14 +15,8 @@ from homeassistant.components.alarm_control_panel import (
     CodeFormat,
 )
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import (
-    ATTR_CODE,
-    CONF_NAME,
-    CONF_STATE,
-    STATE_UNAVAILABLE,
-    STATE_UNKNOWN,
-)
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.const import ATTR_CODE, CONF_NAME, CONF_STATE
+from homeassistant.core import HomeAssistant, State, callback
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.entity_platform import (
     AddConfigEntryEntitiesCallback,
@@ -171,6 +165,7 @@ class AbstractTemplateAlarmControlPanel(
     _entity_id_format = ENTITY_ID_FORMAT
     _optimistic_entity = True
     _state_option = CONF_STATE
+    _restore_state_properties = ("_attr_alarm_state",)
 
     # The super init is not called because
     # TemplateEntity calls AbstractTemplateEntity.__init__.
@@ -204,17 +199,6 @@ class AbstractTemplateAlarmControlPanel(
                 self.add_script(action_id, action_config, name, DOMAIN)
                 self._attr_supported_features |= supported_feature
 
-    async def _async_handle_restored_state(self) -> None:
-        if (
-            (last_state := await self.async_get_last_state()) is not None
-            and last_state.state not in (STATE_UNKNOWN, STATE_UNAVAILABLE)
-            and last_state.state in AlarmControlPanelState
-            # The trigger might have fired already while we waited for stored data,
-            # then we should not restore state
-            and self._attr_alarm_state is None
-        ):
-            self._attr_alarm_state = AlarmControlPanelState(last_state.state)
-
     async def _async_alarm_arm(self, state: Any, script: Script | None, code: Any):
         """Arm the panel to specified state with supplied script."""
 
@@ -290,6 +274,15 @@ class AbstractTemplateAlarmControlPanel(
             code=code,
         )
 
+    @override
+    def restore_last_state_state(self, last_state: State) -> bool:
+        """Restore the state from the last state."""
+        if last_state.state in AlarmControlPanelState:
+            self._attr_alarm_state = AlarmControlPanelState(last_state.state)
+            return True
+
+        return False
+
 
 class StateAlarmControlPanelEntity(TemplateEntity, AbstractTemplateAlarmControlPanel):
     """Representation of a templated Alarm Control Panel."""
@@ -310,12 +303,6 @@ class StateAlarmControlPanelEntity(TemplateEntity, AbstractTemplateAlarmControlP
 
         AbstractTemplateAlarmControlPanel.__init__(self, name)
 
-    @override
-    async def async_added_to_hass(self) -> None:
-        """Restore last state."""
-        await super().async_added_to_hass()
-        await self._async_handle_restored_state()
-
 
 class TriggerAlarmControlPanelEntity(TriggerEntity, AbstractTemplateAlarmControlPanel):
     """Alarm Control Panel entity based on trigger data."""
@@ -332,9 +319,3 @@ class TriggerAlarmControlPanelEntity(TriggerEntity, AbstractTemplateAlarmControl
         TriggerEntity.__init__(self, hass, coordinator, config)
         self._attr_name = name = self._rendered.get(CONF_NAME, DEFAULT_NAME)
         AbstractTemplateAlarmControlPanel.__init__(self, name)
-
-    @override
-    async def async_added_to_hass(self) -> None:
-        """Restore last state."""
-        await super().async_added_to_hass()
-        await self._async_handle_restored_state()

homeassistant/components/template/binary_sensor.py

@@ -21,10 +21,8 @@ from homeassistant.const import (
     CONF_STATE,
     CONF_UNIT_OF_MEASUREMENT,
     STATE_ON,
-    STATE_UNAVAILABLE,
-    STATE_UNKNOWN,
 )
-from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback
+from homeassistant.core import CALLBACK_TYPE, HomeAssistant, State, callback
 from homeassistant.exceptions import TemplateError
 from homeassistant.helpers import config_validation as cv, template
 from homeassistant.helpers.entity_platform import (
@@ -129,6 +127,7 @@ class AbstractTemplateBinarySensor(
 
     _entity_id_format = ENTITY_ID_FORMAT
     _state_option = CONF_STATE
+    _restore_state_properties = ("_attr_is_on",)
 
     # The super init is not called because TemplateEntity
     # and TriggerEntity will call
@@ -160,6 +159,12 @@ class AbstractTemplateBinarySensor(
         except vol.Invalid:
             self.setup_template(CONF_DELAY_OFF, "_delay_off", cv.positive_time_period)
 
+    @override
+    def restore_last_state_state(self, last_state: State) -> bool:
+        """Restore the state from the last state."""
+        self._attr_is_on = last_state.state == STATE_ON
+        return True
+
     @callback
     @abstractmethod
     def _update_state(self, result: Any) -> None:
@@ -181,22 +186,6 @@ class StateBinarySensorEntity(TemplateEntity, AbstractTemplateBinarySensor):
         TemplateEntity.__init__(self, hass, config, unique_id)
         AbstractTemplateBinarySensor.__init__(self, config)
 
-    @override
-    async def async_added_to_hass(self) -> None:
-        """Restore state."""
-        if (
-            (
-                CONF_DELAY_ON in self._templates
-                or CONF_DELAY_OFF in self._templates
-                or self._delay_on is not None
-                or self._delay_off is not None
-            )
-            and (last_state := await self.async_get_last_state()) is not None
-            and last_state.state not in (STATE_UNKNOWN, STATE_UNAVAILABLE)
-        ):
-            self._attr_is_on = last_state.state == STATE_ON
-        await super().async_added_to_hass()
-
     @callback
     @override
     def _update_state(self, result):
@@ -233,10 +222,49 @@ class StateBinarySensorEntity(TemplateEntity, AbstractTemplateBinarySensor):
         self._delay_cancel = async_call_later(self.hass, delay, _set_state)
 
 
+@dataclass
+class AutoOffExtraStoredData(ExtraStoredData):
+    """Object to hold extra stored data."""
+
+    auto_off_time: datetime | None
+
+    @override
+    def as_dict(self) -> dict[str, Any]:
+        """Return a dict representation of additional data."""
+        auto_off_time: datetime | dict[str, str] | None = self.auto_off_time
+        if isinstance(auto_off_time, datetime):
+            auto_off_time = {
+                "__type": str(type(auto_off_time)),
+                "isoformat": auto_off_time.isoformat(),
+            }
+        return {
+            "auto_off_time": auto_off_time,
+        }
+
+    @classmethod
+    def from_dict(cls, restored: dict[str, Any]) -> Self | None:
+        """Initialize a stored binary sensor state from a dict."""
+        try:
+            auto_off_time = restored["auto_off_time"]
+        except KeyError:
+            return None
+        try:
+            type_ = auto_off_time["__type"]
+            if type_ == "<class 'datetime.datetime'>":
+                auto_off_time = dt_util.parse_datetime(auto_off_time["isoformat"])
+        except TypeError:
+            pass
+        except KeyError:
+            return None
+
+        return cls(auto_off_time)
+
+
 class TriggerBinarySensorEntity(TriggerEntity, AbstractTemplateBinarySensor):
     """Sensor entity based on trigger data."""
 
     domain = BINARY_SENSOR_DOMAIN
+    _restore_state_extra_data = AutoOffExtraStoredData
 
     # delay on and delay off are validated when the state is validated.
     skip_rendered_result = (CONF_DELAY_ON, CONF_DELAY_OFF)
@@ -264,32 +292,19 @@ class TriggerBinarySensorEntity(TriggerEntity, AbstractTemplateBinarySensor):
             self._parse_result.add(CONF_AUTO_OFF)
 
     @override
-    async def async_added_to_hass(self) -> None:
-        """Restore last state."""
-        await super().async_added_to_hass()
+    def restore_extra_data(self, extra_data: AutoOffExtraStoredData) -> None:
+        """Restore extra data from the last state."""
+        if CONF_AUTO_OFF not in self._config:
+            return
+
         if (
-            (last_state := await self.async_get_last_state()) is not None
-            and (extra_data := await self.async_get_last_binary_sensor_data())
-            is not None
-            and last_state.state not in (STATE_UNKNOWN, STATE_UNAVAILABLE)
-            # The trigger might have fired already while we waited for stored data,
-            # then we should not restore state
-            and self._attr_is_on is None
-        ):
-            self._attr_is_on = last_state.state == STATE_ON
-            self.restore_attributes(last_state)
+            auto_off_time := extra_data.auto_off_time
+        ) is not None and auto_off_time <= dt_util.utcnow():
+            # It's already past the saved auto off time
+            self._attr_is_on = False
 
-            if CONF_AUTO_OFF not in self._config:
-                return
-
-            if (
-                auto_off_time := extra_data.auto_off_time
-            ) is not None and auto_off_time <= dt_util.utcnow():
-                # It's already past the saved auto off time
-                self._attr_is_on = False
-
-            if self._attr_is_on and auto_off_time is not None:
-                self._set_auto_off(auto_off_time)
+        if self._attr_is_on and auto_off_time is not None:
+            self._set_auto_off(auto_off_time)
 
     @callback
     def _cancel_delays(self):
@@ -401,51 +416,3 @@ class TriggerBinarySensorEntity(TriggerEntity, AbstractTemplateBinarySensor):
     def extra_restore_state_data(self) -> AutoOffExtraStoredData:
         """Return specific state data to be restored."""
         return AutoOffExtraStoredData(self._auto_off_time)
-
-    async def async_get_last_binary_sensor_data(
-        self,
-    ) -> AutoOffExtraStoredData | None:
-        """Restore auto_off_time."""
-        if (restored_last_extra_data := await self.async_get_last_extra_data()) is None:
-            return None
-        return AutoOffExtraStoredData.from_dict(restored_last_extra_data.as_dict())
-
-
-@dataclass
-class AutoOffExtraStoredData(ExtraStoredData):
-    """Object to hold extra stored data."""
-
-    auto_off_time: datetime | None
-
-    @override
-    def as_dict(self) -> dict[str, Any]:
-        """Return a dict representation of additional data."""
-        auto_off_time: datetime | dict[str, str] | None = self.auto_off_time
-        if isinstance(auto_off_time, datetime):
-            auto_off_time = {
-                "__type": str(type(auto_off_time)),
-                "isoformat": auto_off_time.isoformat(),
-            }
-        return {
-            "auto_off_time": auto_off_time,
-        }
-
-    @classmethod
-    def from_dict(cls, restored: dict[str, Any]) -> Self | None:
-        """Initialize a stored binary sensor state from a dict."""
-        try:
-            auto_off_time = restored["auto_off_time"]
-        except KeyError:
-            return None
-        try:
-            type_ = auto_off_time["__type"]
-            if type_ == "<class 'datetime.datetime'>":
-                auto_off_time = dt_util.parse_datetime(auto_off_time["isoformat"])
-        except TypeError:
-            # native_value is not a dict
-            pass
-        except KeyError:
-            # native_value is a dict, but does not have all values
-            return None
-
-        return cls(auto_off_time)

homeassistant/components/template/entity.py

@@ -5,15 +5,27 @@ from collections.abc import Callable, Sequence
 from dataclasses import dataclass
 from typing import Any, override
 
-from homeassistant.const import CONF_DEVICE_ID, CONF_OPTIMISTIC
-from homeassistant.core import Context, HomeAssistant, callback
+from homeassistant.const import (
+    ATTR_ENTITY_PICTURE,
+    ATTR_FRIENDLY_NAME,
+    ATTR_ICON,
+    CONF_DEVICE_ID,
+    CONF_ICON,
+    CONF_NAME,
+    CONF_OPTIMISTIC,
+    STATE_UNAVAILABLE,
+    STATE_UNKNOWN,
+)
+from homeassistant.core import Context, HomeAssistant, State, callback
 from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.entity import Entity, async_generate_entity_id
 from homeassistant.helpers.script import Script, _VarsType
 from homeassistant.helpers.template import Template, TemplateStateFromEntityId
 from homeassistant.helpers.typing import ConfigType
 
-from .const import CONF_DEFAULT_ENTITY_ID
+from .const import CONF_ATTRIBUTES, CONF_DEFAULT_ENTITY_ID, CONF_PICTURE
+
+_SENTINEL = object()
 
 
 @dataclass
@@ -34,6 +46,11 @@ class AbstractTemplateEntity(Entity):
     _optimistic_entity: bool = False
     _extra_optimistic_options: tuple[str, ...] | None = None
     _state_option: str | None = None
+    _restore_state_extra_data: Any | None = None
+
+    # Restore state properties. The state will be restored if set to None.
+    # If a tuple is supplied, all properties must be None for the state to restore.
+    _restore_state_properties: tuple[str, ...] | None = None
 
     def __init__(
         self,
@@ -46,6 +63,10 @@ class AbstractTemplateEntity(Entity):
         self._config = config
         self._templates: dict[str, EntityTemplate] = {}
         self._action_scripts: dict[str, Script] = {}
+        self._attr_extra_state_attributes = {}
+        self._attribute_templates: dict[str, Template] | None = config.get(
+            CONF_ATTRIBUTES
+        )
 
         if self._optimistic_entity:
             optimistic = config.get(CONF_OPTIMISTIC)
@@ -200,3 +221,87 @@ class AbstractTemplateEntity(Entity):
             },
             context=context,
         )
+
+    async def _async_get_last_template_data(
+        self,
+    ) -> Any | None:
+        """Get the last template data."""
+        if self._restore_state_extra_data is None or not hasattr(
+            self, "async_get_last_extra_data"
+        ):
+            return _SENTINEL
+
+        if (restored_last_extra_data := await self.async_get_last_extra_data()) is None:
+            return None
+
+        return self._restore_state_extra_data.from_dict(
+            restored_last_extra_data.as_dict()
+        )
+
+    def restore_extra_data(self, extra_data: Any) -> None:
+        """Restore extra data from the last state."""
+
+    async def async_restore_last_state(self) -> None:
+        """Restore the state from the last state."""
+        if not hasattr(self, "async_get_last_state"):
+            return
+
+        last_state: State | None = await self.async_get_last_state()
+        if last_state is None:
+            return
+
+        # Handle extra data.
+        extra_data = _SENTINEL
+        if self._restore_state_extra_data is not None:
+            extra_data = await self._async_get_last_template_data()
+
+        if (
+            extra_data is None
+            or last_state.state in (STATE_UNKNOWN, STATE_UNAVAILABLE)
+            or (
+                self._restore_state_properties is not None
+                and any(
+                    getattr(self, attr) is not None
+                    for attr in self._restore_state_properties
+                )
+            )
+        ):
+            return
+
+        if not self.restore_last_state_state(last_state):
+            return
+
+        self.restore_last_state_attributes(last_state)
+
+        # Extra data should be loaded last
+        if extra_data is not _SENTINEL:
+            self.restore_extra_data(extra_data)
+
+    def restore_last_state_state(self, last_state: State) -> bool:
+        """Restore the state from the last state."""
+        return True
+
+    @abstractmethod
+    def restore_attribute(self, conf_attr: str, attr: str, restored_value: Any) -> None:
+        """Restore an attribute from the last value."""
+
+    def restore_last_state_attributes(self, last_state: State) -> None:
+        """Restore attributes from the last state."""
+        # Restore built-in attributes from templates
+        for conf_key, attr, _attr in (
+            (CONF_ICON, ATTR_ICON, "_attr_icon"),
+            (CONF_NAME, ATTR_FRIENDLY_NAME, "_attr_name"),
+            (CONF_PICTURE, ATTR_ENTITY_PICTURE, "_attr_entity_picture"),
+        ):
+            if conf_key not in self._config or attr not in last_state.attributes:
+                continue
+            value = last_state.attributes[attr]
+            self.restore_attribute(conf_key, _attr, value)
+
+        self._attr_extra_state_attributes = {}
+        # Restore attributes from template attributes
+        if self._attribute_templates:
+            for attr in self._config[CONF_ATTRIBUTES]:
+                if attr not in last_state.attributes:
+                    continue
+                self._attr_extra_state_attributes[attr] = last_state.attributes[attr]

homeassistant/components/template/sensor.py

@@ -16,16 +16,11 @@ from homeassistant.components.sensor import (
     STATE_CLASSES_SCHEMA,
     RestoreSensor,
     SensorDeviceClass,
+    SensorExtraStoredData,
     SensorStateClass,
 )
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import (
-    CONF_DEVICE_CLASS,
-    CONF_STATE,
-    CONF_UNIT_OF_MEASUREMENT,
-    STATE_UNAVAILABLE,
-    STATE_UNKNOWN,
-)
+from homeassistant.const import CONF_DEVICE_CLASS, CONF_STATE, CONF_UNIT_OF_MEASUREMENT
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.entity_platform import (
@@ -186,6 +181,8 @@ class AbstractTemplateSensor(AbstractTemplateEntity, RestoreSensor):
 
     _entity_id_format = ENTITY_ID_FORMAT
     _state_option = CONF_STATE
+    _restore_state_extra_data = SensorExtraStoredData
+    _restore_state_properties = ("_attr_native_value",)
 
     # The super init is not called because TemplateEntity
     # and TriggerEntity will call
@@ -230,6 +227,13 @@ class AbstractTemplateSensor(AbstractTemplateEntity, RestoreSensor):
 
         return validate_datetime(self, CONF_STATE, self.device_class)(result)
 
+    @override
+    def restore_extra_data(self, extra_data: SensorExtraStoredData) -> None:
+        """Restore the extra data."""
+        # Do not restore native_unit_of_measurement, this is always pulled from the
+        # sensor configuration.
+        self._attr_native_value = extra_data.native_value
+
 
 class StateSensorEntity(TemplateEntity, AbstractTemplateSensor):
     """Representation of a Template Sensor."""
@@ -262,18 +266,3 @@ class TriggerSensorEntity(TriggerEntity, AbstractTemplateSensor):
         """Initialize."""
         TriggerEntity.__init__(self, hass, coordinator, config)
         AbstractTemplateSensor.__init__(self, config)
-
-    @override
-    async def async_added_to_hass(self) -> None:
-        """Restore last state."""
-        await super().async_added_to_hass()
-        if (
-            (last_state := await self.async_get_last_state()) is not None
-            and (extra_data := await self.async_get_last_sensor_data()) is not None
-            and last_state.state not in (STATE_UNKNOWN, STATE_UNAVAILABLE)
-            # The trigger might have fired already while we waited for stored data,
-            # then we should not restore state
-            and CONF_STATE not in self._rendered
-        ):
-            self._attr_native_value = extra_data.native_value
-            self.restore_attributes(last_state)

homeassistant/components/template/switch.py

@@ -10,14 +10,8 @@ from homeassistant.components.switch import (
     SwitchEntity,
 )
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import (
-    CONF_NAME,
-    CONF_STATE,
-    STATE_ON,
-    STATE_UNAVAILABLE,
-    STATE_UNKNOWN,
-)
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.const import CONF_NAME, CONF_STATE, STATE_ON
+from homeassistant.core import HomeAssistant, State, callback
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.entity_platform import (
     AddConfigEntryEntitiesCallback,
@@ -124,6 +118,7 @@ class AbstractTemplateSwitch(AbstractTemplateEntity, SwitchEntity, RestoreEntity
     _entity_id_format = ENTITY_ID_FORMAT
     _optimistic_entity = True
     _state_option = CONF_STATE
+    _restore_state_properties = ("_attr_is_on",)
 
     # The super init is not called because TemplateEntity
     # and TriggerEntity will call
@@ -162,6 +157,12 @@ class AbstractTemplateSwitch(AbstractTemplateEntity, SwitchEntity, RestoreEntity
             self._attr_is_on = False
             self.async_write_ha_state()
 
+    @override
+    def restore_last_state_state(self, last_state: State) -> bool:
+        """Restore the state from the last state."""
+        self._attr_is_on = last_state.state == STATE_ON
+        return True
+
 
 class StateSwitchEntity(TemplateEntity, AbstractTemplateSwitch):
     """Representation of a Template switch."""
@@ -181,16 +182,6 @@ class StateSwitchEntity(TemplateEntity, AbstractTemplateSwitch):
             assert name is not None
         AbstractTemplateSwitch.__init__(self, name, config)
 
-    @override
-    async def async_added_to_hass(self) -> None:
-        """Register callbacks."""
-        if CONF_STATE not in self._templates:
-            # restore state after startup
-            await super().async_added_to_hass()
-            if state := await self.async_get_last_state():
-                self._attr_is_on = state.state == STATE_ON
-        await super().async_added_to_hass()
-
 
 class TriggerSwitchEntity(TriggerEntity, AbstractTemplateSwitch):
     """Switch entity based on trigger data."""
@@ -207,17 +198,3 @@ class TriggerSwitchEntity(TriggerEntity, AbstractTemplateSwitch):
         TriggerEntity.__init__(self, hass, coordinator, config)
         name = self._rendered.get(CONF_NAME, DEFAULT_NAME)
         AbstractTemplateSwitch.__init__(self, name, config)
-
-    @override
-    async def async_added_to_hass(self) -> None:
-        """Restore last state."""
-        await super().async_added_to_hass()
-        if (
-            (last_state := await self.async_get_last_state()) is not None
-            and last_state.state not in (STATE_UNKNOWN, STATE_UNAVAILABLE)
-            # The trigger might have fired already while we waited for stored data,
-            # then we should not restore state
-            and self.is_on is None
-        ):
-            self._attr_is_on = last_state.state == STATE_ON
-            self.restore_attributes(last_state)

homeassistant/components/template/template_entity.py

@@ -43,7 +43,7 @@ from homeassistant.helpers.template import (
 )
 from homeassistant.helpers.typing import ConfigType
 
-from .const import CONF_ATTRIBUTES, CONF_AVAILABILITY, CONF_PICTURE
+from .const import CONF_AVAILABILITY, CONF_PICTURE
 from .entity import AbstractTemplateEntity
 
 _LOGGER = logging.getLogger(__name__)
@@ -161,7 +161,6 @@ class TemplateEntity(AbstractTemplateEntity):
         AbstractTemplateEntity.__init__(self, hass, config)
         self._template_attrs: dict[Template, list[_TemplateAttribute]] = {}
         self._template_result_info: TrackTemplateResultInfo | None = None
-        self._attr_extra_state_attributes = {}
         self._self_ref_update_count = 0
         self._attr_unique_id = unique_id
         self._preview_callback: (
@@ -177,7 +176,6 @@ class TemplateEntity(AbstractTemplateEntity):
             | None
         ) = None
         self._run_variables: ScriptVariables | dict
-        self._attribute_templates = config.get(CONF_ATTRIBUTES)
         self._availability_template = config.get(CONF_AVAILABILITY)
         self._run_variables = config.get(CONF_VARIABLES, {})
         self._blueprint_inputs = config.get("raw_blueprint_inputs")
@@ -569,12 +567,20 @@ class TemplateEntity(AbstractTemplateEntity):
             preview_callback(None, None, None, str(err))
         return self._call_on_remove_callbacks
 
+    @override
+    def restore_attribute(self, conf_attr: str, attr: str, restored_value: Any) -> None:
+        """Restore an attribute from the last value."""
+        setattr(self, attr, restored_value)
+
     @override
     async def async_added_to_hass(self) -> None:
         """Run when entity about to be added to hass."""
+        await super().async_added_to_hass()
+
         self._async_setup_templates()
 
         async_at_start(self.hass, self._async_template_startup)
+        await self.async_restore_last_state()
 
     async def async_update(self) -> None:
         """Call for forced update."""

homeassistant/components/template/trigger_entity.py

@@ -54,7 +54,12 @@ class TriggerEntity(  # pylint: disable=home-assistant-enforce-class-module
         """Handle being added to Home Assistant."""
         await super().async_added_to_hass()
         if self.coordinator.data is not None:
+            # The trigger already produced data; rendering it must win over
+            # restored state, so skip restore entirely to avoid clobbering the
+            # freshly rendered attributes.
             self._process_data()
+        else:
+            await self.async_restore_last_state()
 
     @override
     def _set_unique_id(self, unique_id: str | None) -> None:
@@ -151,6 +156,18 @@ class TriggerEntity(  # pylint: disable=home-assistant-enforce-class-module
 
         return super().available
 
+    @property
+    @override
+    def extra_state_attributes(self) -> dict[str, Any] | None:
+        """Return the state attributes."""
+        # Override TriggerBaseEntity's extra_state_attributes property to restore Entity's extra state attributes behavior.
+        return self._attr_extra_state_attributes
+
+    @override
+    def restore_attribute(self, conf_attr: str, attr: str, restored_value: Any) -> None:
+        """Restore an attribute from the last value."""
+        self._rendered[conf_attr] = restored_value
+
     @callback
     @override
     def _render_script_variables(self) -> dict:
@@ -209,7 +226,20 @@ class TriggerEntity(  # pylint: disable=home-assistant-enforce-class-module
         self._render_single_templates(
             rendered, variables, [state_option] if state_option else []
         )
-        self._render_attributes(rendered, variables)
+
+        if self._attribute_templates:
+            attributes = {}
+            for attribute, template in self._attribute_templates.items():
+                try:
+                    value = template_render_complex(template, variables)
+                    attributes[attribute] = value
+                    variables.update({attribute: value})
+                except TemplateError as err:
+                    log_triggered_template_error(
+                        self.entity_id, err, attribute=attribute
+                    )
+            self._attr_extra_state_attributes = attributes
+
         self._rendered = rendered
 
     def _handle_rendered_results(self) -> bool:

homeassistant/components/template/update.py

@@ -15,13 +15,8 @@ from homeassistant.components.update import (
     UpdateEntityFeature,
 )
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import (
-    CONF_DEVICE_CLASS,
-    CONF_NAME,
-    STATE_UNAVAILABLE,
-    STATE_UNKNOWN,
-)
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.const import CONF_DEVICE_CLASS, CONF_NAME
+from homeassistant.core import HomeAssistant, State, callback
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.entity_platform import (
     AddConfigEntryEntitiesCallback,
@@ -143,6 +138,7 @@ class AbstractTemplateUpdate(AbstractTemplateEntity, UpdateEntity):
     """Representation of a template update features."""
 
     _entity_id_format = ENTITY_ID_FORMAT
+    _restore_state_properties = ("_attr_installed_version", "_attr_latest_version")
 
     # The super init is not called because TemplateEntity
     # and TriggerEntity will call
@@ -245,6 +241,13 @@ class AbstractTemplateUpdate(AbstractTemplateEntity, UpdateEntity):
             context=self._context,
         )
 
+    @override
+    def restore_last_state_state(self, last_state: State) -> bool:
+        """Restore the state from the last state."""
+        self._attr_installed_version = last_state.attributes[ATTR_INSTALLED_VERSION]
+        self._attr_latest_version = last_state.attributes[ATTR_LATEST_VERSION]
+        return True
+
 
 class StateUpdateEntity(TemplateEntity, AbstractTemplateUpdate):
     """Representation of a Template update."""
@@ -300,20 +303,6 @@ class TriggerUpdateEntity(TriggerEntity, AbstractTemplateUpdate):
         if CONF_PICTURE in config:
             self._parse_result.add(CONF_PICTURE)
 
-    @override
-    async def async_added_to_hass(self) -> None:
-        """Restore last state."""
-        await super().async_added_to_hass()
-        if (
-            (last_state := await self.async_get_last_state()) is not None
-            and last_state.state not in (STATE_UNKNOWN, STATE_UNAVAILABLE)
-            and self._attr_installed_version is None
-            and self._attr_latest_version is None
-        ):
-            self._attr_installed_version = last_state.attributes[ATTR_INSTALLED_VERSION]
-            self._attr_latest_version = last_state.attributes[ATTR_LATEST_VERSION]
-            self.restore_attributes(last_state)
-
     @property
     @override
     def entity_picture(self) -> str | None:

homeassistant/components/template/weather.py

@@ -38,10 +38,8 @@ from homeassistant.const import (
     CONF_ICON_TEMPLATE,
     CONF_NAME,
     CONF_TEMPERATURE_UNIT,
-    STATE_UNAVAILABLE,
-    STATE_UNKNOWN,
 )
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import HomeAssistant, State, callback
 from homeassistant.helpers import config_validation as cv, template
 from homeassistant.helpers.entity_platform import (
     AddConfigEntryEntitiesCallback,
@@ -404,12 +402,76 @@ def validate_forecast(
     return validate
 
 
-class AbstractTemplateWeather(AbstractTemplateEntity, WeatherEntity):
+@dataclass(kw_only=True)
+class WeatherExtraStoredData(ExtraStoredData):
+    """Object to hold extra stored data."""
+
+    last_apparent_temperature: float | None
+    last_cloud_coverage: int | None
+    last_dew_point: float | None
+    last_humidity: float | None
+    last_ozone: float | None
+    last_pressure: float | None
+    last_temperature: float | None
+    last_uv_index: float | None
+    last_visibility: float | None
+    last_wind_bearing: float | str | None
+    last_wind_gust_speed: float | None
+    last_wind_speed: float | None
+
+    @override
+    def as_dict(self) -> dict[str, Any]:
+        """Return a dict representation of the event data."""
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, restored: dict[str, Any]) -> Self | None:
+        """Initialize a stored event state from a dict."""
+        for key, vtypes in (
+            ("last_apparent_temperature", (float, int)),
+            ("last_cloud_coverage", (float, int)),
+            ("last_dew_point", (float, int)),
+            ("last_humidity", (float, int)),
+            ("last_ozone", (float, int)),
+            ("last_pressure", (float, int)),
+            ("last_temperature", (float, int)),
+            ("last_uv_index", (float, int)),
+            ("last_visibility", (float, int)),
+            ("last_wind_bearing", (float, int, str)),
+            ("last_wind_gust_speed", (float, int)),
+            ("last_wind_speed", (float, int)),
+        ):
+            # This is needed to safeguard against previous restore data that has strings
+            # instead of floats or ints.
+            if key not in restored or (
+                (value := restored[key]) is not None and not isinstance(value, vtypes)
+            ):
+                return None
+
+        return cls(
+            last_apparent_temperature=restored["last_apparent_temperature"],
+            last_cloud_coverage=restored["last_cloud_coverage"],
+            last_dew_point=restored["last_dew_point"],
+            last_humidity=restored["last_humidity"],
+            last_ozone=restored["last_ozone"],
+            last_pressure=restored["last_pressure"],
+            last_temperature=restored["last_temperature"],
+            last_uv_index=restored["last_uv_index"],
+            last_visibility=restored["last_visibility"],
+            last_wind_bearing=restored["last_wind_bearing"],
+            last_wind_gust_speed=restored["last_wind_gust_speed"],
+            last_wind_speed=restored["last_wind_speed"],
+        )
+
+
+class AbstractTemplateWeather(AbstractTemplateEntity, WeatherEntity, RestoreEntity):
     """Representation of a template weathers features."""
 
     _entity_id_format = ENTITY_ID_FORMAT
     _state_option = CONF_CONDITION
     _optimistic_entity = True
+    _restore_state_extra_data = WeatherExtraStoredData
+    _restore_state_properties = ("_attr_condition",)
 
     # The super init is not called because TemplateEntity
     # and TriggerEntity will call
@@ -554,126 +616,6 @@ class AbstractTemplateWeather(AbstractTemplateEntity, WeatherEntity):
         """Return the daily forecast in native units."""
         return self._forecast_twice_daily or []
 
-
-class StateWeatherEntity(TemplateEntity, AbstractTemplateWeather):
-    """Representation of a Template weather."""
-
-    _attr_should_poll = False
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        config: ConfigType,
-        unique_id: str | None,
-    ) -> None:
-        """Initialize the Template weather."""
-        TemplateEntity.__init__(self, hass, config, unique_id)
-        AbstractTemplateWeather.__init__(self, config)
-
-
-@dataclass(kw_only=True)
-class WeatherExtraStoredData(ExtraStoredData):
-    """Object to hold extra stored data."""
-
-    last_apparent_temperature: float | None
-    last_cloud_coverage: int | None
-    last_dew_point: float | None
-    last_humidity: float | None
-    last_ozone: float | None
-    last_pressure: float | None
-    last_temperature: float | None
-    last_uv_index: float | None
-    last_visibility: float | None
-    last_wind_bearing: float | str | None
-    last_wind_gust_speed: float | None
-    last_wind_speed: float | None
-
-    @override
-    def as_dict(self) -> dict[str, Any]:
-        """Return a dict representation of the event data."""
-        return asdict(self)
-
-    @classmethod
-    def from_dict(cls, restored: dict[str, Any]) -> Self | None:
-        """Initialize a stored event state from a dict."""
-        for key, vtypes in (
-            ("last_apparent_temperature", (float, int)),
-            ("last_cloud_coverage", (float, int)),
-            ("last_dew_point", (float, int)),
-            ("last_humidity", (float, int)),
-            ("last_ozone", (float, int)),
-            ("last_pressure", (float, int)),
-            ("last_temperature", (float, int)),
-            ("last_uv_index", (float, int)),
-            ("last_visibility", (float, int)),
-            ("last_wind_bearing", (float, int, str)),
-            ("last_wind_gust_speed", (float, int)),
-            ("last_wind_speed", (float, int)),
-        ):
-            # This is needed to safeguard against previous restore data that has strings
-            # instead of floats or ints.
-            if key not in restored or (
-                (value := restored[key]) is not None and not isinstance(value, vtypes)
-            ):
-                return None
-
-        return cls(
-            last_apparent_temperature=restored["last_apparent_temperature"],
-            last_cloud_coverage=restored["last_cloud_coverage"],
-            last_dew_point=restored["last_dew_point"],
-            last_humidity=restored["last_humidity"],
-            last_ozone=restored["last_ozone"],
-            last_pressure=restored["last_pressure"],
-            last_temperature=restored["last_temperature"],
-            last_uv_index=restored["last_uv_index"],
-            last_visibility=restored["last_visibility"],
-            last_wind_bearing=restored["last_wind_bearing"],
-            last_wind_gust_speed=restored["last_wind_gust_speed"],
-            last_wind_speed=restored["last_wind_speed"],
-        )
-
-
-class TriggerWeatherEntity(TriggerEntity, AbstractTemplateWeather, RestoreEntity):
-    """Weather entity based on trigger data."""
-
-    domain = WEATHER_DOMAIN
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        coordinator: TriggerUpdateCoordinator,
-        config: ConfigType,
-    ) -> None:
-        """Initialize."""
-        TriggerEntity.__init__(self, hass, coordinator, config)
-        AbstractTemplateWeather.__init__(self, config)
-
-    @override
-    async def async_added_to_hass(self) -> None:
-        """Restore last state."""
-        await super().async_added_to_hass()
-        if (
-            (state := await self.async_get_last_state())
-            and state.state is not None
-            and state.state not in (STATE_UNKNOWN, STATE_UNAVAILABLE)
-            and (weather_data := await self.async_get_last_weather_data())
-        ):
-            self._attr_native_apparent_temperature = (
-                weather_data.last_apparent_temperature
-            )
-            self._attr_cloud_coverage = weather_data.last_cloud_coverage
-            self._attr_condition = state.state
-            self._attr_native_dew_point = weather_data.last_dew_point
-            self._attr_humidity = weather_data.last_humidity
-            self._attr_ozone = weather_data.last_ozone
-            self._attr_native_pressure = weather_data.last_pressure
-            self._attr_native_temperature = weather_data.last_temperature
-            self._attr_uv_index = weather_data.last_uv_index
-            self._attr_native_visibility = weather_data.last_visibility
-            self._attr_wind_bearing = weather_data.last_wind_bearing
-            self._attr_native_wind_gust_speed = weather_data.last_wind_gust_speed
-            self._attr_native_wind_speed = weather_data.last_wind_speed
-
     @property
     @override
     def extra_restore_state_data(self) -> WeatherExtraStoredData:
@@ -693,8 +635,56 @@ class TriggerWeatherEntity(TriggerEntity, AbstractTemplateWeather, RestoreEntity
             last_wind_speed=self.native_wind_speed,
         )
 
-    async def async_get_last_weather_data(self) -> WeatherExtraStoredData | None:
-        """Restore weather specific state data."""
-        if (restored_last_extra_data := await self.async_get_last_extra_data()) is None:
-            return None
-        return WeatherExtraStoredData.from_dict(restored_last_extra_data.as_dict())
+    @override
+    def restore_last_state_state(self, last_state: State) -> bool:
+        """Restore the state from the last state."""
+        self._attr_condition = last_state.state
+        return True
+
+    @override
+    def restore_extra_data(self, extra_data: WeatherExtraStoredData) -> None:
+        """Restore the extra data."""
+        self._attr_native_apparent_temperature = extra_data.last_apparent_temperature
+        self._attr_cloud_coverage = extra_data.last_cloud_coverage
+        self._attr_native_dew_point = extra_data.last_dew_point
+        self._attr_humidity = extra_data.last_humidity
+        self._attr_ozone = extra_data.last_ozone
+        self._attr_native_pressure = extra_data.last_pressure
+        self._attr_native_temperature = extra_data.last_temperature
+        self._attr_uv_index = extra_data.last_uv_index
+        self._attr_native_visibility = extra_data.last_visibility
+        self._attr_wind_bearing = extra_data.last_wind_bearing
+        self._attr_native_wind_gust_speed = extra_data.last_wind_gust_speed
+        self._attr_native_wind_speed = extra_data.last_wind_speed
+
+
+class StateWeatherEntity(TemplateEntity, AbstractTemplateWeather):
+    """Representation of a Template weather."""
+
+    _attr_should_poll = False
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        config: ConfigType,
+        unique_id: str | None,
+    ) -> None:
+        """Initialize the Template weather."""
+        TemplateEntity.__init__(self, hass, config, unique_id)
+        AbstractTemplateWeather.__init__(self, config)
+
+
+class TriggerWeatherEntity(TriggerEntity, AbstractTemplateWeather):
+    """Weather entity based on trigger data."""
+
+    domain = WEATHER_DOMAIN
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        coordinator: TriggerUpdateCoordinator,
+        config: ConfigType,
+    ) -> None:
+        """Initialize."""
+        TriggerEntity.__init__(self, hass, coordinator, config)
+        AbstractTemplateWeather.__init__(self, config)

homeassistant/components/thermoworks_smoke/__init__.py

@@ -1 +0,0 @@
-"""The thermoworks_smoke component."""

homeassistant/components/thermoworks_smoke/manifest.json

@@ -1,11 +0,0 @@
-{
-  "domain": "thermoworks_smoke",
-  "name": "ThermoWorks Smoke",
-  "codeowners": [],
-  "disabled": "This integration is disabled because it creates an unresolvable dependency conflict.",
-  "documentation": "https://www.home-assistant.io/integrations/thermoworks_smoke",
-  "iot_class": "cloud_polling",
-  "loggers": ["thermoworks_smoke"],
-  "quality_scale": "legacy",
-  "requirements": ["stringcase==1.2.0", "thermoworks-smoke==0.1.8"]
-}

homeassistant/components/thermoworks_smoke/sensor.py

@@ -1,166 +0,0 @@
-"""Support for getting the state of a Thermoworks Smoke Thermometer.
-
-Requires Smoke Gateway Wifi with an internet connection.
-"""
-
-import logging
-
-from requests import RequestException
-from requests.exceptions import HTTPError
-from stringcase import camelcase
-import thermoworks_smoke
-import voluptuous as vol
-
-from homeassistant.components.sensor import (
-    PLATFORM_SCHEMA as SENSOR_PLATFORM_SCHEMA,
-    SensorDeviceClass,
-    SensorEntity,
-)
-from homeassistant.const import (
-    ATTR_BATTERY_LEVEL,
-    CONF_EMAIL,
-    CONF_EXCLUDE,
-    CONF_MONITORED_CONDITIONS,
-    CONF_PASSWORD,
-    UnitOfTemperature,
-)
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
-from homeassistant.util import snakecase
-
-_LOGGER = logging.getLogger(__name__)
-
-PROBE_1 = "probe1"
-PROBE_2 = "probe2"
-PROBE_1_MIN = "probe1_min"
-PROBE_1_MAX = "probe1_max"
-PROBE_2_MIN = "probe2_min"
-PROBE_2_MAX = "probe2_max"
-BATTERY_LEVEL = "battery"
-FIRMWARE = "firmware"
-
-SERIAL_REGEX = "^(?:[0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2}$"
-
-# map types to labels
-SENSOR_TYPES = {
-    PROBE_1: "Probe 1",
-    PROBE_2: "Probe 2",
-    PROBE_1_MIN: "Probe 1 Min",
-    PROBE_1_MAX: "Probe 1 Max",
-    PROBE_2_MIN: "Probe 2 Min",
-    PROBE_2_MAX: "Probe 2 Max",
-}
-
-# exclude these keys from thermoworks data
-EXCLUDE_KEYS = [FIRMWARE]
-
-PLATFORM_SCHEMA = SENSOR_PLATFORM_SCHEMA.extend(
-    {
-        vol.Required(CONF_EMAIL): cv.string,
-        vol.Required(CONF_PASSWORD): cv.string,
-        vol.Optional(CONF_MONITORED_CONDITIONS, default=[PROBE_1, PROBE_2]): vol.All(
-            cv.ensure_list, [vol.In(SENSOR_TYPES)]
-        ),
-        vol.Optional(CONF_EXCLUDE, default=[]): vol.All(
-            cv.ensure_list, [cv.matches_regex(SERIAL_REGEX)]
-        ),
-    }
-)
-
-
-def setup_platform(
-    hass: HomeAssistant,
-    config: ConfigType,
-    add_entities: AddEntitiesCallback,
-    discovery_info: DiscoveryInfoType | None = None,
-) -> None:
-    """Set up the thermoworks sensor."""
-
-    email = config[CONF_EMAIL]
-    password = config[CONF_PASSWORD]
-    monitored_variables = config[CONF_MONITORED_CONDITIONS]
-    excluded = config[CONF_EXCLUDE]
-
-    try:
-        mgr = thermoworks_smoke.initialize_app(email, password, True, excluded)
-    except HTTPError as error:
-        msg = f"{error.strerror}"
-        if "EMAIL_NOT_FOUND" in msg or "INVALID_PASSWORD" in msg:
-            _LOGGER.error("Invalid email and password combination")
-        else:
-            _LOGGER.error(msg)
-    else:
-        add_entities(
-            (
-                ThermoworksSmokeSensor(variable, serial, mgr)
-                for serial in mgr.serials()
-                for variable in monitored_variables
-            ),
-            True,
-        )
-
-
-class ThermoworksSmokeSensor(SensorEntity):
-    """Implementation of a thermoworks smoke sensor."""
-
-    def __init__(self, sensor_type, serial, mgr):
-        """Initialize the sensor."""
-        self.type = sensor_type
-        self.serial = serial
-        self.mgr = mgr
-        self._attr_name = f"{mgr.name(serial)} {SENSOR_TYPES[sensor_type]}"
-        self._attr_native_unit_of_measurement = UnitOfTemperature.FAHRENHEIT
-        self._attr_unique_id = f"{serial}-{sensor_type}"
-        self._attr_device_class = SensorDeviceClass.TEMPERATURE
-        self.update_unit()
-
-    def update_unit(self):
-        """Set the units from the data."""
-        if PROBE_2 in self.type:
-            self._attr_native_unit_of_measurement = self.mgr.units(self.serial, PROBE_2)
-        else:
-            self._attr_native_unit_of_measurement = self.mgr.units(self.serial, PROBE_1)
-
-    def update(self) -> None:
-        """Get the monitored data from firebase."""
-
-        try:
-            values = self.mgr.data(self.serial)
-
-            # set state from data based on type of sensor
-            self._attr_native_value = values.get(camelcase(self.type))
-
-            # set units
-            self.update_unit()
-
-            # set basic attributes for all sensors
-            self._attr_extra_state_attributes = {
-                "time": values["time"],
-                "localtime": values["localtime"],
-            }
-
-            # set extended attributes for main probe sensors
-            if self.type in (PROBE_1, PROBE_2):
-                for key, val in values.items():
-                    # add all attributes that don't contain any probe name
-                    # or contain a matching probe name
-                    if (self.type == PROBE_1 and key.find(PROBE_2) == -1) or (
-                        self.type == PROBE_2 and key.find(PROBE_1) == -1
-                    ):
-                        if key == BATTERY_LEVEL:
-                            key = ATTR_BATTERY_LEVEL
-                        else:
-                            # strip probe label and convert to snake_case
-                            key = snakecase(key.replace(self.type, ""))
-                        # add to attrs
-                        if key and key not in EXCLUDE_KEYS:
-                            self._attr_extra_state_attributes[key] = val
-                # store actual unit because attributes are not converted
-                self._attr_extra_state_attributes["unit_of_min_max"] = (
-                    self._attr_native_unit_of_measurement
-                )
-
-        except RequestException, ValueError, KeyError:
-            _LOGGER.warning("Could not update status for %s", self.name)

homeassistant/components/tuya/manifest.json

@@ -44,7 +44,7 @@
   "iot_class": "cloud_push",
   "loggers": ["tuya_sharing"],
   "requirements": [
-    "tuya-device-handlers==0.0.22",
-    "tuya-device-sharing-sdk==0.2.8"
+    "tuya-device-handlers==0.0.24",
+    "tuya-device-sharing-sdk==0.2.10"
   ]
 }

homeassistant/components/unifiprotect/manifest.json

@@ -9,5 +9,5 @@
   "iot_class": "local_push",
   "loggers": ["uiprotect"],
   "quality_scale": "platinum",
-  "requirements": ["uiprotect==14.0.0"]
+  "requirements": ["uiprotect==15.3.0"]
 }

homeassistant/components/vera/__init__.py

@@ -62,10 +62,14 @@ async def async_setup_entry(hass: HomeAssistant, entry: VeraConfigEntry) -> bool
     controller = veraApi.VeraController(base_url, subscription_registry)
 
     try:
-        all_devices = await hass.async_add_executor_job(controller.get_devices)
 
-        # pylint: disable-next=home-assistant-sequential-executor-jobs
-        all_scenes = await hass.async_add_executor_job(controller.get_scenes)
+        def _get_devices_and_scenes():
+            """Get devices and scenes from the Vera controller."""
+            return controller.get_devices(), controller.get_scenes()
+
+        all_devices, all_scenes = await hass.async_add_executor_job(
+            _get_devices_and_scenes
+        )
     except RequestException as exception:
         # There was a network related error connecting to the Vera controller.
         _LOGGER.exception("Error communicating with Vera API")

homeassistant/components/vodafone_station/coordinator.py

@@ -145,9 +145,7 @@ class VodafoneStationRouter(DataUpdateCoordinator[UpdateCoordinatorDataType]):
                 translation_placeholders={"error": repr(err)},
             ) from err
         except (
-            exceptions.CannotConnect,
-            exceptions.AlreadyLogged,
-            exceptions.GenericLoginError,
+            exceptions.VodafoneError,
             JSONDecodeError,
         ) as err:
             if isinstance(err, JSONDecodeError):

homeassistant/components/xiaomi_miio/select.py

@@ -149,7 +149,6 @@ SELECTOR_TYPES = (
     XiaomiMiioSelectDescription(
         key=ATTR_DISPLAY_ORIENTATION,
         attr_name=ATTR_DISPLAY_ORIENTATION,
-        name="Display Orientation",
         options_map={
             "Portrait": "Forward",
             "LandscapeLeft": "Left",
@@ -165,7 +164,6 @@ SELECTOR_TYPES = (
     XiaomiMiioSelectDescription(
         key=ATTR_MODE,
         attr_name=ATTR_MODE,
-        name="Mode",
         set_method="set_mode",
         set_method_error_message="Setting the mode of the fan failed.",
         icon="mdi:fan",
@@ -176,7 +174,6 @@ SELECTOR_TYPES = (
     XiaomiMiioSelectDescription(
         key=ATTR_LED_BRIGHTNESS,
         attr_name=ATTR_LED_BRIGHTNESS,
-        name="Led Brightness",
         set_method="set_led_brightness",
         set_method_error_message="Setting the led brightness failed.",
         icon="mdi:brightness-6",
@@ -187,7 +184,6 @@ SELECTOR_TYPES = (
     XiaomiMiioSelectDescription(
         key=ATTR_PTC_LEVEL,
         attr_name=ATTR_PTC_LEVEL,
-        name="Auxiliary Heat Level",
         set_method="set_ptc_level",
         set_method_error_message="Setting the ptc level failed.",
         icon="mdi:fire-circle",