Apply suggestions from code review

Co-authored-by: Norbert Rittel <norbert@rittel.de>

.github/copilot-instructions.md

@@ -1,12 +1,6 @@
 <!-- Automatically generated by gen_copilot_instructions.py, do not edit -->
 
 
-
-# Copilot code review instructions
-
-- Start review comments with a short, one-sentence summary of the suggested fix.
-- Do not add comments about code style, formatting or linting issues.
-
 # GitHub Copilot & Claude Code Instructions
 
 This repository contains the core of Home Assistant, a Python 3 based home automation application.

.github/workflows/ci.yaml

@@ -120,7 +120,7 @@ jobs:
         run: |
           echo "key=$(lsb_release -rs)-apt-${CACHE_VERSION}-${HA_SHORT_VERSION}" >> $GITHUB_OUTPUT
       - name: Filter for core changes
-        uses: dorny/paths-filter@fbd0ab8f3e69293af611ebaee6363fc25e6d187d # v4.0.1
+        uses: dorny/paths-filter@de90cc6fb38fc0963ad72b210f1f284cd68cea36 # v3.0.2
         id: core
         with:
           filters: .core_files.yaml
@@ -135,7 +135,7 @@ jobs:
           echo "Result:"
           cat .integration_paths.yaml
       - name: Filter for integration changes
-        uses: dorny/paths-filter@fbd0ab8f3e69293af611ebaee6363fc25e6d187d # v4.0.1
+        uses: dorny/paths-filter@de90cc6fb38fc0963ad72b210f1f284cd68cea36 # v3.0.2
         id: integrations
         with:
           filters: .integration_paths.yaml

homeassistant/components/assist_pipeline/pipeline.py

@@ -662,8 +662,7 @@ class PipelineRun:
         """Emit run start event."""
         self._device_id = device_id
         self._satellite_id = satellite_id
-        if self.start_stage in (PipelineStage.WAKE_WORD, PipelineStage.STT):
-            self._start_debug_recording_thread()
+        self._start_debug_recording_thread()
 
         data: dict[str, Any] = {
             "pipeline": self.pipeline.id,
@@ -1505,7 +1504,9 @@ class PipelineRun:
 
     def _start_debug_recording_thread(self) -> None:
         """Start thread to record wake/stt audio if debug_recording_dir is set."""
-        assert self.debug_recording_thread is None
+        if self.debug_recording_thread is not None:
+            # Already started
+            return
 
         # Directory to save audio for each pipeline run.
         # Configured in YAML for assist_pipeline.

homeassistant/components/automation/__init__.py

@@ -155,6 +155,7 @@ _EXPERIMENTAL_TRIGGER_PLATFORMS = {
     "gate",
     "humidifier",
     "humidity",
+    "input_boolean",
     "lawn_mower",
     "light",
     "lock",

homeassistant/components/camera/__init__.py

@@ -432,7 +432,6 @@ class Camera(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
     )
 
     # Entity Properties
-    entity_description: CameraEntityDescription
     _attr_brand: str | None = None
     _attr_frame_interval: float = MIN_STREAM_INTERVAL
     _attr_is_on: bool = True

homeassistant/components/climate/strings.json

@@ -462,10 +462,6 @@
         "below": {
           "description": "Trigger when the target temperature is below this value.",
           "name": "Below"
-        },
-        "unit": {
-          "description": "All values will be converted to this unit when evaluating the trigger.",
-          "name": "Unit of measurement"
         }
       },
       "name": "Climate-control device target temperature changed"
@@ -485,10 +481,6 @@
           "description": "Type of threshold crossing to trigger on.",
           "name": "Threshold type"
         },
-        "unit": {
-          "description": "[%key:component::climate::triggers::target_temperature_changed::fields::unit::description%]",
-          "name": "[%key:component::climate::triggers::target_temperature_changed::fields::unit::name%]"
-        },
         "upper_limit": {
           "description": "Upper threshold limit.",
           "name": "Upper threshold"

homeassistant/components/climate/trigger.py

@@ -2,15 +2,12 @@
 
 import voluptuous as vol
 
-from homeassistant.const import ATTR_TEMPERATURE, CONF_OPTIONS, UnitOfTemperature
-from homeassistant.core import HomeAssistant, State
+from homeassistant.const import ATTR_TEMPERATURE, CONF_OPTIONS
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.automation import DomainSpec, NumericalDomainSpec
 from homeassistant.helpers.trigger import (
     ENTITY_STATE_TRIGGER_SCHEMA_FIRST_LAST,
-    EntityNumericalStateChangedTriggerWithUnitBase,
-    EntityNumericalStateCrossedThresholdTriggerWithUnitBase,
-    EntityNumericalStateTriggerWithUnitBase,
     EntityTargetStateTriggerBase,
     Trigger,
     TriggerConfig,
@@ -19,7 +16,6 @@ from homeassistant.helpers.trigger import (
     make_entity_target_state_trigger,
     make_entity_transition_trigger,
 )
-from homeassistant.util.unit_conversion import TemperatureConverter
 
 from .const import ATTR_HUMIDITY, ATTR_HVAC_ACTION, DOMAIN, HVACAction, HVACMode
 
@@ -48,33 +44,6 @@ class HVACModeChangedTrigger(EntityTargetStateTriggerBase):
         self._to_states = set(self._options[CONF_HVAC_MODE])
 
 
-class _ClimateTargetTemperatureTriggerMixin(EntityNumericalStateTriggerWithUnitBase):
-    """Mixin for climate target temperature triggers with unit conversion."""
-
-    _base_unit = UnitOfTemperature.CELSIUS
-    _domain_specs = {DOMAIN: NumericalDomainSpec(value_source=ATTR_TEMPERATURE)}
-    _unit_converter = TemperatureConverter
-
-    def _get_entity_unit(self, state: State) -> str | None:
-        """Get the temperature unit of a climate entity from its state."""
-        # Climate entities convert temperatures to the system unit via show_temp
-        return self._hass.config.units.temperature_unit
-
-
-class ClimateTargetTemperatureChangedTrigger(
-    _ClimateTargetTemperatureTriggerMixin,
-    EntityNumericalStateChangedTriggerWithUnitBase,
-):
-    """Trigger for climate target temperature value changes."""
-
-
-class ClimateTargetTemperatureCrossedThresholdTrigger(
-    _ClimateTargetTemperatureTriggerMixin,
-    EntityNumericalStateCrossedThresholdTriggerWithUnitBase,
-):
-    """Trigger for climate target temperature value crossing a threshold."""
-
-
 TRIGGERS: dict[str, type[Trigger]] = {
     "hvac_mode_changed": HVACModeChangedTrigger,
     "started_cooling": make_entity_target_state_trigger(
@@ -84,15 +53,17 @@ TRIGGERS: dict[str, type[Trigger]] = {
         {DOMAIN: DomainSpec(value_source=ATTR_HVAC_ACTION)}, HVACAction.DRYING
     ),
     "target_humidity_changed": make_entity_numerical_state_changed_trigger(
-        {DOMAIN: NumericalDomainSpec(value_source=ATTR_HUMIDITY)},
-        valid_unit="%",
+        {DOMAIN: NumericalDomainSpec(value_source=ATTR_HUMIDITY)}
     ),
     "target_humidity_crossed_threshold": make_entity_numerical_state_crossed_threshold_trigger(
-        {DOMAIN: NumericalDomainSpec(value_source=ATTR_HUMIDITY)},
-        valid_unit="%",
+        {DOMAIN: NumericalDomainSpec(value_source=ATTR_HUMIDITY)}
+    ),
+    "target_temperature_changed": make_entity_numerical_state_changed_trigger(
+        {DOMAIN: NumericalDomainSpec(value_source=ATTR_TEMPERATURE)}
+    ),
+    "target_temperature_crossed_threshold": make_entity_numerical_state_crossed_threshold_trigger(
+        {DOMAIN: NumericalDomainSpec(value_source=ATTR_TEMPERATURE)}
     ),
-    "target_temperature_changed": ClimateTargetTemperatureChangedTrigger,
-    "target_temperature_crossed_threshold": ClimateTargetTemperatureCrossedThresholdTrigger,
     "turned_off": make_entity_target_state_trigger(DOMAIN, HVACMode.OFF),
     "turned_on": make_entity_transition_trigger(
         DOMAIN,

homeassistant/components/climate/triggers.yaml

@@ -14,29 +14,7 @@
             - last
             - any
 
-.number_or_entity_humidity: &number_or_entity_humidity
-  required: false
-  selector:
-    choose:
-      choices:
-        number:
-          selector:
-            number:
-              mode: box
-              unit_of_measurement: "%"
-        entity:
-          selector:
-            entity:
-              filter:
-                - domain: input_number
-                  unit_of_measurement: "%"
-                - domain: sensor
-                  device_class: humidity
-                - domain: number
-                  device_class: humidity
-      translation_key: number_or_entity
-
-.number_or_entity_temperature: &number_or_entity_temperature
+.number_or_entity: &number_or_entity
   required: false
   selector:
     choose:
@@ -49,24 +27,12 @@
           selector:
             entity:
               filter:
-                - domain: input_number
-                  unit_of_measurement:
-                    - "°C"
-                    - "°F"
-                - domain: sensor
-                  device_class: temperature
-                - domain: number
-                  device_class: temperature
+                domain:
+                  - input_number
+                  - number
+                  - sensor
       translation_key: number_or_entity
 
-.trigger_unit_temperature: &trigger_unit_temperature
-  required: false
-  selector:
-    select:
-      options:
-        - "°C"
-        - "°F"
-
 .trigger_threshold_type: &trigger_threshold_type
   required: true
   default: above
@@ -103,29 +69,27 @@ hvac_mode_changed:
 target_humidity_changed:
   target: *trigger_climate_target
   fields:
-    above: *number_or_entity_humidity
-    below: *number_or_entity_humidity
+    above: *number_or_entity
+    below: *number_or_entity
 
 target_humidity_crossed_threshold:
   target: *trigger_climate_target
   fields:
     behavior: *trigger_behavior
     threshold_type: *trigger_threshold_type
-    lower_limit: *number_or_entity_humidity
-    upper_limit: *number_or_entity_humidity
+    lower_limit: *number_or_entity
+    upper_limit: *number_or_entity
 
 target_temperature_changed:
   target: *trigger_climate_target
   fields:
-    above: *number_or_entity_temperature
-    below: *number_or_entity_temperature
-    unit: *trigger_unit_temperature
+    above: *number_or_entity
+    below: *number_or_entity
 
 target_temperature_crossed_threshold:
   target: *trigger_climate_target
   fields:
     behavior: *trigger_behavior
     threshold_type: *trigger_threshold_type
-    lower_limit: *number_or_entity_temperature
-    upper_limit: *number_or_entity_temperature
-    unit: *trigger_unit_temperature
+    lower_limit: *number_or_entity
+    upper_limit: *number_or_entity

homeassistant/components/cloud/manifest.json

@@ -13,6 +13,6 @@
   "integration_type": "system",
   "iot_class": "cloud_push",
   "loggers": ["acme", "hass_nabucasa", "snitun"],
-  "requirements": ["hass-nabucasa==2.2.0", "openai==2.21.0"],
+  "requirements": ["hass-nabucasa==2.0.0", "openai==2.21.0"],
   "single_config_entry": true
 }

homeassistant/components/evohome/manifest.json

@@ -6,5 +6,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["evohomeasync", "evohomeasync2"],
   "quality_scale": "legacy",
-  "requirements": ["evohome-async==1.2.0"]
+  "requirements": ["evohome-async==1.1.3"]
 }

homeassistant/components/evohome/water_heater.py

@@ -124,17 +124,15 @@ class EvoDHW(EvoChild, WaterHeaterEntity):
             until = dt_util.as_utc(until) if until else None
 
             if operation_mode == STATE_ON:
-                await self.coordinator.call_client_api(
-                    self._evo_device.set_on(until=until)
-                )
+                await self.coordinator.call_client_api(self._evo_device.on(until=until))
             else:  # STATE_OFF
                 await self.coordinator.call_client_api(
-                    self._evo_device.set_off(until=until)
+                    self._evo_device.off(until=until)
                 )
 
     async def async_turn_away_mode_on(self) -> None:
         """Turn away mode on."""
-        await self.coordinator.call_client_api(self._evo_device.set_off())
+        await self.coordinator.call_client_api(self._evo_device.off())
 
     async def async_turn_away_mode_off(self) -> None:
         """Turn away mode off."""
@@ -142,8 +140,8 @@ class EvoDHW(EvoChild, WaterHeaterEntity):
 
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn on."""
-        await self.coordinator.call_client_api(self._evo_device.set_on())
+        await self.coordinator.call_client_api(self._evo_device.on())
 
     async def async_turn_off(self, **kwargs: Any) -> None:
         """Turn off."""
-        await self.coordinator.call_client_api(self._evo_device.set_off())
+        await self.coordinator.call_client_api(self._evo_device.off())

homeassistant/components/frontend/manifest.json

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

homeassistant/components/generic_thermostat/config_flow.py

@@ -116,11 +116,7 @@ async def _validate_config(
 
 
 CONFIG_FLOW = {
-    "user": SchemaFlowFormStep(
-        vol.Schema(CONFIG_SCHEMA),
-        validate_user_input=_validate_config,
-        next_step="presets",
-    ),
+    "user": SchemaFlowFormStep(vol.Schema(CONFIG_SCHEMA), next_step="presets"),
     "presets": SchemaFlowFormStep(vol.Schema(PRESETS_SCHEMA)),
 }
 

homeassistant/components/generic_thermostat/strings.json

@@ -1,8 +1,5 @@
 {
   "config": {
-    "error": {
-      "min_max_runtime": "Minimum run time must be less than the maximum run time."
-    },
     "step": {
       "presets": {
         "data": {
@@ -48,7 +45,7 @@
   },
   "options": {
     "error": {
-      "min_max_runtime": "[%key:component::generic_thermostat::config::error::min_max_runtime%]"
+      "min_max_runtime": "Minimum run time must be less than the maximum run time."
     },
     "step": {
       "init": {

homeassistant/components/green_planet_energy/manifest.json

@@ -7,6 +7,6 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "quality_scale": "bronze",
-  "requirements": ["greenplanet-energy-api==0.1.10"],
+  "requirements": ["greenplanet-energy-api==0.1.4"],
   "single_config_entry": true
 }

homeassistant/components/hassio/__init__.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import asyncio
 from contextlib import suppress
-from dataclasses import replace
 from datetime import datetime
 import logging
 import os
@@ -16,7 +15,6 @@ from aiohasupervisor import SupervisorError
 from aiohasupervisor.models import (
     GreenOptions,
     HomeAssistantInfo,
-    HomeAssistantOptions,
     HostInfo,
     InstalledAddon,
     NetworkInfo,
@@ -24,28 +22,20 @@ from aiohasupervisor.models import (
     RootInfo,
     StoreInfo,
     SupervisorInfo,
-    SupervisorOptions,
     YellowOptions,
 )
 import voluptuous as vol
 
 from homeassistant.auth.const import GROUP_ID_ADMIN
-from homeassistant.auth.models import RefreshToken
 from homeassistant.components import frontend, panel_custom
 from homeassistant.components.homeassistant import async_set_stop_handler
-from homeassistant.components.http import (
-    CONF_SERVER_HOST,
-    CONF_SERVER_PORT,
-    CONF_SSL_CERTIFICATE,
-    StaticPathConfig,
-)
+from homeassistant.components.http import StaticPathConfig
 from homeassistant.config_entries import SOURCE_SYSTEM, ConfigEntry
 from homeassistant.const import (
     ATTR_DEVICE_ID,
     ATTR_NAME,
     EVENT_CORE_CONFIG_UPDATE,
     HASSIO_USER_NAME,
-    SERVER_PORT,
     Platform,
 )
 from homeassistant.core import (
@@ -455,30 +445,8 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
         require_admin=True,
     )
 
-    async def update_hass_api(http_config: dict[str, Any], refresh_token: RefreshToken):
-        """Update Home Assistant API data on Hass.io."""
-        options = HomeAssistantOptions(
-            ssl=CONF_SSL_CERTIFICATE in http_config,
-            port=http_config.get(CONF_SERVER_PORT) or SERVER_PORT,
-            refresh_token=refresh_token.token,
-        )
-
-        if http_config.get(CONF_SERVER_HOST) is not None:
-            options = replace(options, watchdog=False)
-            _LOGGER.warning(
-                "Found incompatible HTTP option 'server_host'. Watchdog feature"
-                " disabled"
-            )
-
-        try:
-            await supervisor_client.homeassistant.set_options(options)
-        except SupervisorError as err:
-            _LOGGER.warning(
-                "Failed to update Home Assistant options in Supervisor: %s", err
-            )
-
     update_hass_api_task = hass.async_create_task(
-        update_hass_api(config.get("http", {}), refresh_token), eager_start=True
+        hassio.update_hass_api(config.get("http", {}), refresh_token), eager_start=True
     )
 
     last_timezone = None
@@ -489,25 +457,19 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
         nonlocal last_timezone
         nonlocal last_country
 
-        new_timezone = hass.config.time_zone
-        new_country = hass.config.country
+        new_timezone = str(hass.config.time_zone)
+        new_country = str(hass.config.country)
 
         if new_timezone != last_timezone or new_country != last_country:
             last_timezone = new_timezone
             last_country = new_country
-
-            try:
-                await supervisor_client.supervisor.set_options(
-                    SupervisorOptions(timezone=new_timezone, country=new_country)
-                )
-            except SupervisorError as err:
-                _LOGGER.warning("Failed to update Supervisor options: %s", err)
+            await hassio.update_hass_config(new_timezone, new_country)
 
     hass.bus.async_listen(EVENT_CORE_CONFIG_UPDATE, push_config)
 
     push_config_task = hass.async_create_task(push_config(None), eager_start=True)
     # Start listening for problems with supervisor and making issues
-    hass.data[DATA_KEY_SUPERVISOR_ISSUES] = issues = SupervisorIssues(hass)
+    hass.data[DATA_KEY_SUPERVISOR_ISSUES] = issues = SupervisorIssues(hass, hassio)
     issues_task = hass.async_create_task(issues.setup(), eager_start=True)
 
     async def async_service_handler(service: ServiceCall) -> None:
@@ -655,7 +617,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
     async_set_stop_handler(hass, _async_stop)
 
     # Init discovery Hass.io feature
-    async_setup_discovery_view(hass)
+    async_setup_discovery_view(hass, hassio)
 
     # Init auth Hass.io feature
     assert user is not None

homeassistant/components/hassio/discovery.py

@@ -21,15 +21,15 @@ from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.service_info.hassio import HassioServiceInfo
 
 from .const import ATTR_ADDON, ATTR_UUID, DOMAIN
-from .handler import get_supervisor_client
+from .handler import HassIO, get_supervisor_client
 
 _LOGGER = logging.getLogger(__name__)
 
 
 @callback
-def async_setup_discovery_view(hass: HomeAssistant) -> None:
+def async_setup_discovery_view(hass: HomeAssistant, hassio: HassIO) -> None:
     """Discovery setup."""
-    hassio_discovery = HassIODiscovery(hass)
+    hassio_discovery = HassIODiscovery(hass, hassio)
     supervisor_client = get_supervisor_client(hass)
     hass.http.register_view(hassio_discovery)
 
@@ -77,9 +77,10 @@ class HassIODiscovery(HomeAssistantView):
     name = "api:hassio_push:discovery"
     url = "/api/hassio_push/discovery/{uuid}"
 
-    def __init__(self, hass: HomeAssistant) -> None:
+    def __init__(self, hass: HomeAssistant, hassio: HassIO) -> None:
         """Initialize WebView."""
         self.hass = hass
+        self.hassio = hassio
         self._supervisor_client = get_supervisor_client(hass)
 
     async def post(self, request: web.Request, uuid: str) -> web.Response:

homeassistant/components/hassio/handler.py

@@ -14,6 +14,13 @@ from aiohasupervisor.models import SupervisorOptions
 import aiohttp
 from yarl import URL
 
+from homeassistant.auth.models import RefreshToken
+from homeassistant.components.http import (
+    CONF_SERVER_HOST,
+    CONF_SERVER_PORT,
+    CONF_SSL_CERTIFICATE,
+)
+from homeassistant.const import SERVER_PORT
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.singleton import singleton
 
@@ -28,6 +35,22 @@ class HassioAPIError(RuntimeError):
     """Return if a API trow a error."""
 
 
+def _api_bool[**_P](
+    funct: Callable[_P, Coroutine[Any, Any, dict[str, Any]]],
+) -> Callable[_P, Coroutine[Any, Any, bool]]:
+    """Return a boolean."""
+
+    async def _wrapper(*argv: _P.args, **kwargs: _P.kwargs) -> bool:
+        """Wrap function."""
+        try:
+            data = await funct(*argv, **kwargs)
+            return data["result"] == "ok"
+        except HassioAPIError:
+            return False
+
+    return _wrapper
+
+
 def api_data[**_P](
     funct: Callable[_P, Coroutine[Any, Any, dict[str, Any]]],
 ) -> Callable[_P, Coroutine[Any, Any, Any]]:
@@ -72,6 +95,37 @@ class HassIO:
         """
         return self.send_command("/ingress/panels", method="get")
 
+    @_api_bool
+    async def update_hass_api(
+        self, http_config: dict[str, Any], refresh_token: RefreshToken
+    ):
+        """Update Home Assistant API data on Hass.io."""
+        port = http_config.get(CONF_SERVER_PORT) or SERVER_PORT
+        options = {
+            "ssl": CONF_SSL_CERTIFICATE in http_config,
+            "port": port,
+            "refresh_token": refresh_token.token,
+        }
+
+        if http_config.get(CONF_SERVER_HOST) is not None:
+            options["watchdog"] = False
+            _LOGGER.warning(
+                "Found incompatible HTTP option 'server_host'. Watchdog feature"
+                " disabled"
+            )
+
+        return await self.send_command("/homeassistant/options", payload=options)
+
+    @_api_bool
+    def update_hass_config(self, timezone: str, country: str | None) -> Coroutine:
+        """Update Home-Assistant timezone data on Hass.io.
+
+        This method returns a coroutine.
+        """
+        return self.send_command(
+            "/supervisor/options", payload={"timezone": timezone, "country": country}
+        )
+
     async def send_command(
         self,
         command: str,

homeassistant/components/hassio/issues.py

@@ -63,7 +63,7 @@ from .const import (
     UPDATE_KEY_SUPERVISOR,
 )
 from .coordinator import HassioDataUpdateCoordinator, get_addons_list, get_host_info
-from .handler import get_supervisor_client
+from .handler import HassIO, get_supervisor_client
 
 ISSUE_KEY_UNHEALTHY = "unhealthy"
 ISSUE_KEY_UNSUPPORTED = "unsupported"
@@ -175,9 +175,10 @@ class Issue:
 class SupervisorIssues:
     """Create issues from supervisor events."""
 
-    def __init__(self, hass: HomeAssistant) -> None:
+    def __init__(self, hass: HomeAssistant, client: HassIO) -> None:
         """Initialize supervisor issues."""
         self._hass = hass
+        self._client = client
         self._unsupported_reasons: set[str] = set()
         self._unhealthy_reasons: set[str] = set()
         self._issues: dict[UUID, Issue] = {}

homeassistant/components/homeassistant_connect_zbt2/config_flow.py

@@ -5,8 +5,6 @@ from __future__ import annotations
 import logging
 from typing import TYPE_CHECKING, Any, Protocol
 
-from universal_silabs_flasher.flasher import Zbt2Flasher
-
 from homeassistant.components import usb
 from homeassistant.components.homeassistant_hardware import firmware_config_flow
 from homeassistant.components.homeassistant_hardware.helpers import (
@@ -15,6 +13,7 @@ from homeassistant.components.homeassistant_hardware.helpers import (
 from homeassistant.components.homeassistant_hardware.util import (
     ApplicationType,
     FirmwareInfo,
+    ResetTarget,
 )
 from homeassistant.components.usb import (
     usb_service_info_from_device,
@@ -77,7 +76,15 @@ class ZBT2FirmwareMixin(ConfigEntryBaseFlow, FirmwareInstallFlowProtocol):
     context: ConfigFlowContext
 
     ZIGBEE_BAUDRATE = 460800
-    _flasher_cls = Zbt2Flasher
+
+    # Early ZBT-2 samples used RTS/DTR to trigger the bootloader, later ones use the
+    # baudrate method. Since the two are mutually exclusive we just use both.
+    BOOTLOADER_RESET_METHODS = [ResetTarget.RTS_DTR, ResetTarget.BAUDRATE]
+    APPLICATION_PROBE_METHODS = [
+        (ApplicationType.GECKO_BOOTLOADER, 115200),
+        (ApplicationType.EZSP, ZIGBEE_BAUDRATE),
+        (ApplicationType.SPINEL, 460800),
+    ]
 
     async def async_step_install_zigbee_firmware(
         self, user_input: dict[str, Any] | None = None

homeassistant/components/homeassistant_connect_zbt2/update.py

@@ -4,8 +4,6 @@ from __future__ import annotations
 
 import logging
 
-from universal_silabs_flasher.flasher import Zbt2Flasher
-
 from homeassistant.components.homeassistant_hardware.coordinator import (
     FirmwareUpdateCoordinator,
 )
@@ -25,6 +23,7 @@ from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import HomeAssistantConnectZBT2ConfigEntry
+from .config_flow import ZBT2FirmwareMixin
 from .const import DOMAIN, FIRMWARE, FIRMWARE_VERSION, HARDWARE_NAME, SERIAL_NUMBER
 
 _LOGGER = logging.getLogger(__name__)
@@ -135,7 +134,8 @@ async def async_setup_entry(
 class FirmwareUpdateEntity(BaseFirmwareUpdateEntity):
     """Connect ZBT-2 firmware update entity."""
 
-    _flasher_cls = Zbt2Flasher
+    BOOTLOADER_RESET_METHODS = ZBT2FirmwareMixin.BOOTLOADER_RESET_METHODS
+    APPLICATION_PROBE_METHODS = ZBT2FirmwareMixin.APPLICATION_PROBE_METHODS
 
     def __init__(
         self,

homeassistant/components/homeassistant_hardware/firmware_config_flow.py

@@ -12,7 +12,6 @@ from aiohttp import ClientError
 from ha_silabs_firmware_client import FirmwareUpdateClient, ManifestMissing
 from universal_silabs_flasher.common import Version
 from universal_silabs_flasher.firmware import NabuCasaMetadata
-from universal_silabs_flasher.flasher import DeviceSpecificFlasher
 
 from homeassistant.components.hassio import (
     AddonError,
@@ -40,6 +39,7 @@ from .util import (
     FirmwareInfo,
     OwningAddon,
     OwningIntegration,
+    ResetTarget,
     async_firmware_flashing_context,
     async_flash_silabs_firmware,
     get_otbr_addon_manager,
@@ -81,7 +81,8 @@ class BaseFirmwareInstallFlow(ConfigEntryBaseFlow, ABC):
     """Base flow to install firmware."""
 
     ZIGBEE_BAUDRATE = 115200  # Default, subclasses may override
-    _flasher_cls: type[DeviceSpecificFlasher]
+    BOOTLOADER_RESET_METHODS: list[ResetTarget] = []  # Default, subclasses may override
+    APPLICATION_PROBE_METHODS: list[tuple[ApplicationType, int]] = []
 
     _picked_firmware_type: PickedFirmwareType
     _zigbee_flow_strategy: ZigbeeFlowStrategy = ZigbeeFlowStrategy.RECOMMENDED
@@ -238,7 +239,8 @@ class BaseFirmwareInstallFlow(ConfigEntryBaseFlow, ABC):
             # isn't strictly necessary for functionality.
             self._probed_firmware_info = await probe_silabs_firmware_info(
                 self._device,
-                flasher_cls=self._flasher_cls,
+                bootloader_reset_methods=self.BOOTLOADER_RESET_METHODS,
+                application_probe_methods=self.APPLICATION_PROBE_METHODS,
             )
 
             firmware_install_required = self._probed_firmware_info is None or (
@@ -309,8 +311,9 @@ class BaseFirmwareInstallFlow(ConfigEntryBaseFlow, ABC):
                 hass=self.hass,
                 device=self._device,
                 fw_data=fw_data,
-                flasher_cls=self._flasher_cls,
                 expected_installed_firmware_type=expected_installed_firmware_type,
+                bootloader_reset_methods=self.BOOTLOADER_RESET_METHODS,
+                application_probe_methods=self.APPLICATION_PROBE_METHODS,
                 progress_callback=lambda offset, total: self.async_update_progress(
                     offset / total
                 ),

homeassistant/components/homeassistant_hardware/manifest.json

@@ -8,7 +8,7 @@
   "integration_type": "system",
   "requirements": [
     "serialx==0.6.2",
-    "universal-silabs-flasher==1.0.2",
+    "universal-silabs-flasher==0.1.2",
     "ha-silabs-firmware-client==0.3.0"
   ]
 }

homeassistant/components/homeassistant_hardware/update.py

@@ -8,7 +8,6 @@ import logging
 from typing import Any, cast
 
 from ha_silabs_firmware_client import FirmwareManifest, FirmwareMetadata
-from universal_silabs_flasher.flasher import DeviceSpecificFlasher
 from yarl import URL
 
 from homeassistant.components.update import (
@@ -26,6 +25,7 @@ from .helpers import async_register_firmware_info_callback
 from .util import (
     ApplicationType,
     FirmwareInfo,
+    ResetTarget,
     async_firmware_flashing_context,
     async_flash_silabs_firmware,
 )
@@ -87,11 +87,13 @@ class BaseFirmwareUpdateEntity(
 
     # Subclasses provide the mapping between firmware types and entity descriptions
     entity_description: FirmwareUpdateEntityDescription
+    BOOTLOADER_RESET_METHODS: list[ResetTarget]
+    APPLICATION_PROBE_METHODS: list[tuple[ApplicationType, int]]
+
     _attr_supported_features = (
         UpdateEntityFeature.INSTALL | UpdateEntityFeature.PROGRESS
     )
     _attr_has_entity_name = True
-    _flasher_cls: type[DeviceSpecificFlasher]
 
     def __init__(
         self,
@@ -280,8 +282,9 @@ class BaseFirmwareUpdateEntity(
                     hass=self.hass,
                     device=self._current_device,
                     fw_data=fw_data,
-                    flasher_cls=self._flasher_cls,
                     expected_installed_firmware_type=self.entity_description.expected_firmware_type,
+                    bootloader_reset_methods=self.BOOTLOADER_RESET_METHODS,
+                    application_probe_methods=self.APPLICATION_PROBE_METHODS,
                     progress_callback=self._update_progress,
                 )
         finally:

homeassistant/components/homeassistant_hardware/util.py

@@ -10,9 +10,12 @@ from dataclasses import dataclass
 from enum import StrEnum
 import logging
 
-from universal_silabs_flasher.const import ApplicationType as FlasherApplicationType
+from universal_silabs_flasher.const import (
+    ApplicationType as FlasherApplicationType,
+    ResetTarget as FlasherResetTarget,
+)
 from universal_silabs_flasher.firmware import parse_firmware_image
-from universal_silabs_flasher.flasher import BaseFlasher, DeviceSpecificFlasher, Flasher
+from universal_silabs_flasher.flasher import Flasher
 
 from homeassistant.components.hassio import AddonError, AddonManager, AddonState
 from homeassistant.config_entries import ConfigEntryState
@@ -60,6 +63,18 @@ class ApplicationType(StrEnum):
         return FlasherApplicationType(self.value)
 
 
+class ResetTarget(StrEnum):
+    """Methods to reset a device into bootloader mode."""
+
+    RTS_DTR = "rts_dtr"
+    BAUDRATE = "baudrate"
+    YELLOW = "yellow"
+
+    def as_flasher_reset_target(self) -> FlasherResetTarget:
+        """Convert the reset target enum into one compatible with USF."""
+        return FlasherResetTarget(self.value)
+
+
 @singleton(OTBR_ADDON_MANAGER_DATA)
 @callback
 def get_otbr_addon_manager(hass: HomeAssistant) -> WaitingAddonManager:
@@ -295,20 +310,23 @@ async def guess_firmware_info(hass: HomeAssistant, device_path: str) -> Firmware
 async def probe_silabs_firmware_info(
     device: str,
     *,
-    flasher_cls: type[BaseFlasher],
-    application_probe_methods: Sequence[ApplicationType] | None = None,
+    bootloader_reset_methods: Sequence[ResetTarget],
+    application_probe_methods: Sequence[tuple[ApplicationType, int]],
 ) -> FirmwareInfo | None:
     """Probe the running firmware on a SiLabs device."""
-    flasher = flasher_cls(device=device)
+    flasher = Flasher(
+        device=device,
+        probe_methods=tuple(
+            (m.as_flasher_application_type(), baudrate)
+            for m, baudrate in application_probe_methods
+        ),
+        bootloader_reset=tuple(
+            m.as_flasher_reset_target() for m in bootloader_reset_methods
+        ),
+    )
 
     try:
-        await flasher.probe_app_type(
-            only=(
-                [m.as_flasher_application_type() for m in application_probe_methods]
-                if application_probe_methods is not None
-                else None
-            )
-        )
+        await flasher.probe_app_type()
     except Exception:  # noqa: BLE001
         _LOGGER.debug("Failed to probe application type", exc_info=True)
 
@@ -331,25 +349,20 @@ async def probe_silabs_firmware_info(
 async def probe_silabs_firmware_type(
     device: str,
     *,
+    bootloader_reset_methods: Sequence[ResetTarget],
     application_probe_methods: Sequence[tuple[ApplicationType, int]],
 ) -> ApplicationType | None:
     """Probe the running firmware type on a SiLabs device."""
-    flasher = Flasher(
-        device=device,
-        probe_methods=[
-            (m.as_flasher_application_type(), b) for m, b in application_probe_methods
-        ],
+
+    fw_info = await probe_silabs_firmware_info(
+        device,
+        bootloader_reset_methods=bootloader_reset_methods,
+        application_probe_methods=application_probe_methods,
     )
-
-    try:
-        await flasher.probe_app_type()
-    except Exception:  # noqa: BLE001
-        _LOGGER.debug("Failed to probe application type", exc_info=True)
-
-    if flasher.app_type is None:
+    if fw_info is None:
         return None
 
-    return ApplicationType.from_flasher_application_type(flasher.app_type)
+    return fw_info.firmware_type
 
 
 @asynccontextmanager
@@ -372,18 +385,36 @@ async def async_flash_silabs_firmware(
     hass: HomeAssistant,
     device: str,
     fw_data: bytes,
-    flasher_cls: type[DeviceSpecificFlasher],
     expected_installed_firmware_type: ApplicationType,
+    bootloader_reset_methods: Sequence[ResetTarget],
+    application_probe_methods: Sequence[tuple[ApplicationType, int]],
     progress_callback: Callable[[int, int], None] | None = None,
 ) -> FirmwareInfo:
     """Flash firmware to the SiLabs device.
 
     This function is meant to be used within a firmware update context.
     """
+    if not any(
+        method == expected_installed_firmware_type
+        for method, _ in application_probe_methods
+    ):
+        raise ValueError(
+            f"Expected installed firmware type {expected_installed_firmware_type!r}"
+            f" not in application probe methods {application_probe_methods!r}"
+        )
 
     fw_image = await hass.async_add_executor_job(parse_firmware_image, fw_data)
 
-    flasher = flasher_cls(device=device)
+    flasher = Flasher(
+        device=device,
+        probe_methods=tuple(
+            (m.as_flasher_application_type(), baudrate)
+            for m, baudrate in application_probe_methods
+        ),
+        bootloader_reset=tuple(
+            m.as_flasher_reset_target() for m in bootloader_reset_methods
+        ),
+    )
 
     try:
         # Enter the bootloader with indeterminate progress
@@ -400,9 +431,13 @@ async def async_flash_silabs_firmware(
 
     probed_firmware_info = await probe_silabs_firmware_info(
         device,
-        flasher_cls=flasher_cls,
+        bootloader_reset_methods=bootloader_reset_methods,
         # Only probe for the expected installed firmware type
-        application_probe_methods=[expected_installed_firmware_type],
+        application_probe_methods=[
+            (method, baudrate)
+            for method, baudrate in application_probe_methods
+            if method == expected_installed_firmware_type
+        ],
     )
 
     if probed_firmware_info is None:

homeassistant/components/homeassistant_sky_connect/config_flow.py

@@ -5,8 +5,6 @@ from __future__ import annotations
 import logging
 from typing import TYPE_CHECKING, Any, Protocol
 
-from universal_silabs_flasher.flasher import Zbt1Flasher
-
 from homeassistant.components import usb
 from homeassistant.components.homeassistant_hardware import (
     firmware_config_flow,
@@ -18,6 +16,7 @@ from homeassistant.components.homeassistant_hardware.helpers import (
 from homeassistant.components.homeassistant_hardware.util import (
     ApplicationType,
     FirmwareInfo,
+    ResetTarget,
 )
 from homeassistant.components.usb import (
     usb_service_info_from_device,
@@ -82,7 +81,18 @@ class SkyConnectFirmwareMixin(ConfigEntryBaseFlow, FirmwareInstallFlowProtocol):
     context: ConfigFlowContext
 
     ZIGBEE_BAUDRATE = 115200
-    _flasher_cls = Zbt1Flasher
+    # There is no hardware bootloader trigger
+    BOOTLOADER_RESET_METHODS: list[ResetTarget] = []
+    APPLICATION_PROBE_METHODS = [
+        (ApplicationType.GECKO_BOOTLOADER, 115200),
+        (ApplicationType.EZSP, ZIGBEE_BAUDRATE),
+        (ApplicationType.SPINEL, 460800),
+        # CPC baudrates can be removed once multiprotocol is removed
+        (ApplicationType.CPC, 115200),
+        (ApplicationType.CPC, 230400),
+        (ApplicationType.CPC, 460800),
+        (ApplicationType.ROUTER, 115200),
+    ]
 
     def _get_translation_placeholders(self) -> dict[str, str]:
         """Shared translation placeholders."""

homeassistant/components/homeassistant_sky_connect/update.py

@@ -4,8 +4,6 @@ from __future__ import annotations
 
 import logging
 
-from universal_silabs_flasher.flasher import Zbt1Flasher
-
 from homeassistant.components.homeassistant_hardware.coordinator import (
     FirmwareUpdateCoordinator,
 )
@@ -25,6 +23,7 @@ from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import HomeAssistantSkyConnectConfigEntry
+from .config_flow import SkyConnectFirmwareMixin
 from .const import (
     DOMAIN,
     FIRMWARE,
@@ -153,7 +152,8 @@ async def async_setup_entry(
 class FirmwareUpdateEntity(BaseFirmwareUpdateEntity):
     """SkyConnect firmware update entity."""
 
-    _flasher_cls = Zbt1Flasher
+    BOOTLOADER_RESET_METHODS = SkyConnectFirmwareMixin.BOOTLOADER_RESET_METHODS
+    APPLICATION_PROBE_METHODS = SkyConnectFirmwareMixin.APPLICATION_PROBE_METHODS
 
     def __init__(
         self,

homeassistant/components/homeassistant_yellow/config_flow.py

@@ -7,7 +7,6 @@ import asyncio
 import logging
 from typing import TYPE_CHECKING, Any, Protocol, final
 
-from universal_silabs_flasher.flasher import YellowFlasher
 import voluptuous as vol
 
 from homeassistant.components.hassio import (
@@ -26,6 +25,7 @@ from homeassistant.components.homeassistant_hardware.silabs_multiprotocol_addon
 from homeassistant.components.homeassistant_hardware.util import (
     ApplicationType,
     FirmwareInfo,
+    ResetTarget,
     probe_silabs_firmware_info,
 )
 from homeassistant.config_entries import (
@@ -83,7 +83,17 @@ class YellowFirmwareMixin(ConfigEntryBaseFlow, FirmwareInstallFlowProtocol):
     """Mixin for Home Assistant Yellow firmware methods."""
 
     ZIGBEE_BAUDRATE = 115200
-    _flasher_cls = YellowFlasher
+    BOOTLOADER_RESET_METHODS = [ResetTarget.YELLOW]
+    APPLICATION_PROBE_METHODS = [
+        (ApplicationType.GECKO_BOOTLOADER, 115200),
+        (ApplicationType.EZSP, ZIGBEE_BAUDRATE),
+        (ApplicationType.SPINEL, 460800),
+        # CPC baudrates can be removed once multiprotocol is removed
+        (ApplicationType.CPC, 115200),
+        (ApplicationType.CPC, 230400),
+        (ApplicationType.CPC, 460800),
+        (ApplicationType.ROUTER, 115200),
+    ]
 
     async def async_step_install_zigbee_firmware(
         self, user_input: dict[str, Any] | None = None
@@ -149,7 +159,8 @@ class HomeAssistantYellowConfigFlow(
         # We do not actually use any portion of `BaseFirmwareConfigFlow` beyond this
         self._probed_firmware_info = await probe_silabs_firmware_info(
             self._device,
-            flasher_cls=self._flasher_cls,
+            bootloader_reset_methods=self.BOOTLOADER_RESET_METHODS,
+            application_probe_methods=self.APPLICATION_PROBE_METHODS,
         )
 
         # Kick off ZHA hardware discovery automatically if Zigbee firmware is running

homeassistant/components/homeassistant_yellow/update.py

@@ -4,8 +4,6 @@ from __future__ import annotations
 
 import logging
 
-from universal_silabs_flasher.flasher import YellowFlasher
-
 from homeassistant.components.homeassistant_hardware.coordinator import (
     FirmwareUpdateCoordinator,
 )
@@ -25,6 +23,7 @@ from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import HomeAssistantYellowConfigEntry
+from .config_flow import YellowFirmwareMixin
 from .const import DOMAIN, FIRMWARE, FIRMWARE_VERSION, MANUFACTURER, MODEL, RADIO_DEVICE
 
 _LOGGER = logging.getLogger(__name__)
@@ -151,7 +150,8 @@ async def async_setup_entry(
 class FirmwareUpdateEntity(BaseFirmwareUpdateEntity):
     """Yellow firmware update entity."""
 
-    _flasher_cls = YellowFlasher
+    BOOTLOADER_RESET_METHODS = YellowFirmwareMixin.BOOTLOADER_RESET_METHODS
+    APPLICATION_PROBE_METHODS = YellowFirmwareMixin.APPLICATION_PROBE_METHODS
 
     def __init__(
         self,

homeassistant/components/humidifier/icons.json

@@ -64,6 +64,9 @@
     }
   },
   "triggers": {
+    "mode_changed": {
+      "trigger": "mdi:air-humidifier"
+    },
     "started_drying": {
       "trigger": "mdi:arrow-down-bold"
     },

homeassistant/components/humidifier/strings.json

@@ -199,6 +199,20 @@
   },
   "title": "Humidifier",
   "triggers": {
+    "mode_changed": {
+      "description": "Triggers after the operation mode of one or more humidifiers changes.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::humidifier::common::trigger_behavior_description%]",
+          "name": "[%key:component::humidifier::common::trigger_behavior_name%]"
+        },
+        "mode": {
+          "description": "The operation modes to trigger on.",
+          "name": "Mode"
+        }
+      },
+      "name": "Humidifier mode changed"
+    },
     "started_drying": {
       "description": "Triggers after one or more humidifiers start drying.",
       "fields": {

homeassistant/components/humidifier/trigger.py

@@ -1,13 +1,46 @@
 """Provides triggers for humidifiers."""
 
-from homeassistant.const import STATE_OFF, STATE_ON
+import voluptuous as vol
+
+from homeassistant.const import ATTR_MODE, CONF_OPTIONS, STATE_OFF, STATE_ON
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.automation import DomainSpec
-from homeassistant.helpers.trigger import Trigger, make_entity_target_state_trigger
+from homeassistant.helpers.trigger import (
+    ENTITY_STATE_TRIGGER_SCHEMA_FIRST_LAST,
+    EntityTargetStateTriggerBase,
+    Trigger,
+    TriggerConfig,
+    make_entity_target_state_trigger,
+)
 
 from .const import ATTR_ACTION, DOMAIN, HumidifierAction
 
+CONF_MODE = "mode"
+
+MODE_CHANGED_TRIGGER_SCHEMA = ENTITY_STATE_TRIGGER_SCHEMA_FIRST_LAST.extend(
+    {
+        vol.Required(CONF_OPTIONS): {
+            vol.Required(CONF_MODE): vol.All(cv.ensure_list, vol.Length(min=1), [str]),
+        },
+    }
+)
+
+
+class ModeChangedTrigger(EntityTargetStateTriggerBase):
+    """Trigger for humidifier mode changes."""
+
+    _domain_specs = {DOMAIN: DomainSpec(value_source=ATTR_MODE)}
+    _schema = MODE_CHANGED_TRIGGER_SCHEMA
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the mode trigger."""
+        super().__init__(hass, config)
+        self._to_states = set(self._options[CONF_MODE])
+
+
 TRIGGERS: dict[str, type[Trigger]] = {
+    "mode_changed": ModeChangedTrigger,
     "started_drying": make_entity_target_state_trigger(
         {DOMAIN: DomainSpec(value_source=ATTR_ACTION)}, HumidifierAction.DRYING
     ),

homeassistant/components/humidifier/triggers.yaml

@@ -1,9 +1,9 @@
 .trigger_common: &trigger_common
-  target:
+  target: &trigger_humidifier_target
     entity:
       domain: humidifier
   fields:
-    behavior:
+    behavior: &trigger_behavior
       required: true
       default: any
       selector:
@@ -18,3 +18,16 @@ started_drying: *trigger_common
 started_humidifying: *trigger_common
 turned_on: *trigger_common
 turned_off: *trigger_common
+
+mode_changed:
+  target: *trigger_humidifier_target
+  fields:
+    behavior: *trigger_behavior
+    mode:
+      context:
+        filter_target: target
+      required: true
+      selector:
+        state:
+          attribute: available_modes
+          multiple: true

homeassistant/components/immich/__init__.py

@@ -2,9 +2,22 @@
 
 from __future__ import annotations
 
-from homeassistant.const import Platform
+from aioimmich import Immich
+from aioimmich.const import CONNECT_ERRORS
+from aioimmich.exceptions import ImmichUnauthorizedError
+
+from homeassistant.const import (
+    CONF_API_KEY,
+    CONF_HOST,
+    CONF_PORT,
+    CONF_SSL,
+    CONF_VERIFY_SSL,
+    Platform,
+)
 from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.typing import ConfigType
 
 from .const import DOMAIN
@@ -25,7 +38,30 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 async def async_setup_entry(hass: HomeAssistant, entry: ImmichConfigEntry) -> bool:
     """Set up Immich from a config entry."""
 
-    coordinator = ImmichDataUpdateCoordinator(hass, entry)
+    session = async_get_clientsession(hass, entry.data[CONF_VERIFY_SSL])
+    immich = Immich(
+        session,
+        entry.data[CONF_API_KEY],
+        entry.data[CONF_HOST],
+        entry.data[CONF_PORT],
+        entry.data[CONF_SSL],
+        "home-assistant",
+    )
+
+    try:
+        user_info = await immich.users.async_get_my_user()
+    except ImmichUnauthorizedError as err:
+        raise ConfigEntryAuthFailed(
+            translation_domain=DOMAIN,
+            translation_key="auth_error",
+        ) from err
+    except CONNECT_ERRORS as err:
+        raise ConfigEntryNotReady(
+            translation_domain=DOMAIN,
+            translation_key="cannot_connect",
+        ) from err
+
+    coordinator = ImmichDataUpdateCoordinator(hass, entry, immich, user_info.is_admin)
     await coordinator.async_config_entry_first_refresh()
     entry.runtime_data = coordinator
 

homeassistant/components/immich/coordinator.py

@@ -16,19 +16,11 @@ from aioimmich.server.models import (
     ImmichServerVersionCheck,
 )
 from awesomeversion import AwesomeVersion
-from yarl import URL
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import (
-    CONF_API_KEY,
-    CONF_HOST,
-    CONF_PORT,
-    CONF_SSL,
-    CONF_VERIFY_SSL,
-)
+from homeassistant.const import CONF_HOST, CONF_PORT, CONF_SSL
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
 from .const import DOMAIN
@@ -54,49 +46,24 @@ class ImmichDataUpdateCoordinator(DataUpdateCoordinator[ImmichData]):
 
     config_entry: ImmichConfigEntry
 
-    def __init__(self, hass: HomeAssistant, config_entry: ImmichConfigEntry) -> None:
+    def __init__(
+        self, hass: HomeAssistant, entry: ConfigEntry, api: Immich, is_admin: bool
+    ) -> None:
         """Initialize the data update coordinator."""
-        self.api = Immich(
-            async_get_clientsession(hass, config_entry.data[CONF_VERIFY_SSL]),
-            config_entry.data[CONF_API_KEY],
-            config_entry.data[CONF_HOST],
-            config_entry.data[CONF_PORT],
-            config_entry.data[CONF_SSL],
-            "home-assistant",
-        )
-        self.is_admin = False
-        self.configuration_url = str(
-            URL.build(
-                scheme="https" if config_entry.data[CONF_SSL] else "http",
-                host=config_entry.data[CONF_HOST],
-                port=config_entry.data[CONF_PORT],
-            )
+        self.api = api
+        self.is_admin = is_admin
+        self.configuration_url = (
+            f"{'https' if entry.data[CONF_SSL] else 'http'}://"
+            f"{entry.data[CONF_HOST]}:{entry.data[CONF_PORT]}"
         )
         super().__init__(
             hass,
             _LOGGER,
-            config_entry=config_entry,
+            config_entry=entry,
             name=DOMAIN,
             update_interval=timedelta(seconds=60),
         )
 
-    async def _async_setup(self) -> None:
-        """Handle setup of the coordinator."""
-        try:
-            user_info = await self.api.users.async_get_my_user()
-        except ImmichUnauthorizedError as err:
-            raise ConfigEntryAuthFailed(
-                translation_domain=DOMAIN,
-                translation_key="auth_error",
-            ) from err
-        except CONNECT_ERRORS as err:
-            raise UpdateFailed(
-                translation_domain=DOMAIN,
-                translation_key="cannot_connect",
-            ) from err
-
-        self.is_admin = user_info.is_admin
-
     async def _async_update_data(self) -> ImmichData:
         """Update data via internal method."""
         try:

homeassistant/components/input_boolean/icons.json

@@ -20,5 +20,13 @@
     "turn_on": {
       "service": "mdi:toggle-switch"
     }
+  },
+  "triggers": {
+    "turned_off": {
+      "trigger": "mdi:toggle-switch-off"
+    },
+    "turned_on": {
+      "trigger": "mdi:toggle-switch"
+    }
   }
 }

homeassistant/components/input_boolean/strings.json

@@ -1,4 +1,8 @@
 {
+  "common": {
+    "trigger_behavior_description": "The behavior of the targeted toggles to trigger on.",
+    "trigger_behavior_name": "Behavior"
+  },
   "entity_component": {
     "_": {
       "name": "[%key:component::input_boolean::title%]",
@@ -17,6 +21,15 @@
       }
     }
   },
+  "selector": {
+    "trigger_behavior": {
+      "options": {
+        "any": "Any",
+        "first": "First",
+        "last": "Last"
+      }
+    }
+  },
   "services": {
     "reload": {
       "description": "Reloads helpers from the YAML-configuration.",
@@ -35,5 +48,27 @@
       "name": "[%key:common::action::turn_on%]"
     }
   },
-  "title": "Input boolean"
+  "title": "Input boolean",
+  "triggers": {
+    "turned_off": {
+      "description": "Triggers after one or more toggles turn off.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::input_boolean::common::trigger_behavior_description%]",
+          "name": "[%key:component::input_boolean::common::trigger_behavior_name%]"
+        }
+      },
+      "name": "Toggle turned off"
+    },
+    "turned_on": {
+      "description": "Triggers after one or more toggles turn on.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::input_boolean::common::trigger_behavior_description%]",
+          "name": "[%key:component::input_boolean::common::trigger_behavior_name%]"
+        }
+      },
+      "name": "Toggle turned on"
+    }
+  }
 }

homeassistant/components/input_boolean/trigger.py

@@ -0,0 +1,17 @@
+"""Provides triggers for input booleans."""
+
+from homeassistant.const import STATE_OFF, STATE_ON
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.trigger import Trigger, make_entity_target_state_trigger
+
+from . import DOMAIN
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "turned_on": make_entity_target_state_trigger(DOMAIN, STATE_ON),
+    "turned_off": make_entity_target_state_trigger(DOMAIN, STATE_OFF),
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for input booleans."""
+    return TRIGGERS

homeassistant/components/input_boolean/triggers.yaml

@@ -0,0 +1,18 @@
+.trigger_common: &trigger_common
+  target:
+    entity:
+      domain: input_boolean
+  fields:
+    behavior:
+      required: true
+      default: any
+      selector:
+        select:
+          options:
+            - first
+            - last
+            - any
+          translation_key: trigger_behavior
+
+turned_off: *trigger_common
+turned_on: *trigger_common

homeassistant/components/liebherr/manifest.json

@@ -8,7 +8,7 @@
   "iot_class": "cloud_polling",
   "loggers": ["pyliebherrhomeapi"],
   "quality_scale": "gold",
-  "requirements": ["pyliebherrhomeapi==0.4.1"],
+  "requirements": ["pyliebherrhomeapi==0.4.0"],
   "zeroconf": [
     {
       "name": "liebherr*",

homeassistant/components/light/trigger.py

@@ -30,10 +30,10 @@ BRIGHTNESS_DOMAIN_SPECS = {
 
 TRIGGERS: dict[str, type[Trigger]] = {
     "brightness_changed": make_entity_numerical_state_changed_trigger(
-        BRIGHTNESS_DOMAIN_SPECS, valid_unit="%"
+        BRIGHTNESS_DOMAIN_SPECS
     ),
     "brightness_crossed_threshold": make_entity_numerical_state_crossed_threshold_trigger(
-        BRIGHTNESS_DOMAIN_SPECS, valid_unit="%"
+        BRIGHTNESS_DOMAIN_SPECS
     ),
     "turned_off": make_entity_target_state_trigger(DOMAIN, STATE_OFF),
     "turned_on": make_entity_target_state_trigger(DOMAIN, STATE_ON),

homeassistant/components/light/triggers.yaml

@@ -30,12 +30,10 @@
           selector:
             entity:
               filter:
-                - domain: input_number
-                  unit_of_measurement: "%"
-                - domain: number
-                  unit_of_measurement: "%"
-                - domain: sensor
-                  unit_of_measurement: "%"
+                domain:
+                  - input_number
+                  - number
+                  - sensor
       translation_key: number_or_entity
 
 turned_on: *trigger_common

homeassistant/components/matter/number.py

@@ -399,47 +399,6 @@ DISCOVERY_SCHEMAS = [
         ),
         entity_class=MatterNumber,
         required_attributes=(clusters.OccupancySensing.Attributes.HoldTime,),
-        # HoldTime is shared by PIR-specific numbers as a required attribute.
-        # Keep discovery open so this generic schema does not block them.
-        allow_multi=True,
-    ),
-    MatterDiscoverySchema(
-        platform=Platform.NUMBER,
-        entity_description=MatterNumberEntityDescription(
-            key="OccupancySensingPIRUnoccupiedToOccupiedDelay",
-            entity_category=EntityCategory.CONFIG,
-            translation_key="detection_delay",
-            native_max_value=65534,
-            native_min_value=0,
-            native_unit_of_measurement=UnitOfTime.SECONDS,
-            mode=NumberMode.BOX,
-        ),
-        entity_class=MatterNumber,
-        required_attributes=(
-            clusters.OccupancySensing.Attributes.PIRUnoccupiedToOccupiedDelay,
-            # This attribute is mandatory when the PIRUnoccupiedToOccupiedDelay is present
-            clusters.OccupancySensing.Attributes.HoldTime,
-        ),
-        featuremap_contains=clusters.OccupancySensing.Bitmaps.Feature.kPassiveInfrared,
-        allow_multi=True,
-    ),
-    MatterDiscoverySchema(
-        platform=Platform.NUMBER,
-        entity_description=MatterNumberEntityDescription(
-            key="OccupancySensingPIRUnoccupiedToOccupiedThreshold",
-            entity_category=EntityCategory.CONFIG,
-            translation_key="detection_threshold",
-            native_max_value=254,
-            native_min_value=1,
-            mode=NumberMode.BOX,
-        ),
-        entity_class=MatterNumber,
-        required_attributes=(
-            clusters.OccupancySensing.Attributes.PIRUnoccupiedToOccupiedThreshold,
-            clusters.OccupancySensing.Attributes.HoldTime,
-        ),
-        featuremap_contains=clusters.OccupancySensing.Bitmaps.Feature.kPassiveInfrared,
-        allow_multi=True,
     ),
     MatterDiscoverySchema(
         platform=Platform.NUMBER,

homeassistant/components/matter/strings.json

@@ -214,12 +214,6 @@
       "cook_time": {
         "name": "Cooking time"
       },
-      "detection_delay": {
-        "name": "Detection delay"
-      },
-      "detection_threshold": {
-        "name": "Detection threshold"
-      },
       "hold_time": {
         "name": "Hold time"
       },

homeassistant/components/motion_blinds/strings.json

@@ -72,7 +72,7 @@
   },
   "services": {
     "set_absolute_position": {
-      "description": "Sets the absolute position of a cover.",
+      "description": "Sets the absolute position of the cover.",
       "fields": {
         "absolute_position": {
           "description": "Absolute position to move to.",

homeassistant/components/playstation_network/manifest.json

@@ -90,5 +90,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_polling",
   "quality_scale": "bronze",
-  "requirements": ["PSNAWP==3.0.3", "pyrate-limiter==4.1.0"]
+  "requirements": ["PSNAWP==3.0.3", "pyrate-limiter==4.0.2"]
 }

homeassistant/components/proxmoxve/button.py

@@ -125,14 +125,6 @@ VM_BUTTONS: tuple[ProxmoxVMButtonEntityDescription, ...] = (
         ),
         entity_category=EntityCategory.CONFIG,
     ),
-    ProxmoxVMButtonEntityDescription(
-        key="shutdown",
-        translation_key="shutdown",
-        press_action=lambda coordinator, node, vmid: (
-            coordinator.proxmox.nodes(node).qemu(vmid).status.shutdown.post()
-        ),
-        entity_category=EntityCategory.CONFIG,
-    ),
 )
 
 CONTAINER_BUTTONS: tuple[ProxmoxContainerButtonEntityDescription, ...] = (

homeassistant/components/proxmoxve/icons.json

@@ -7,9 +7,6 @@
       "reset": {
         "default": "mdi:restart"
       },
-      "shutdown": {
-        "default": "mdi:power"
-      },
       "start": {
         "default": "mdi:play"
       },

homeassistant/components/roborock/button.py

@@ -159,6 +159,7 @@ async def async_setup_entry(
                     description,
                 )
                 for coordinator in config_entry.runtime_data.b01_q10
+                if isinstance(coordinator, RoborockB01Q10UpdateCoordinator)
                 for description in Q10_BUTTON_DESCRIPTIONS
             ),
         )

homeassistant/components/roborock/manifest.json

@@ -20,7 +20,7 @@
   "loggers": ["roborock"],
   "quality_scale": "silver",
   "requirements": [
-    "python-roborock==5.0.0",
+    "python-roborock==4.26.3",
     "vacuum-map-parser-roborock==0.1.4"
   ]
 }

homeassistant/components/roborock/vacuum.py

@@ -80,23 +80,23 @@ Q7_STATE_CODE_TO_STATE = {
 }
 
 Q10_STATE_CODE_TO_STATE = {
-    YXDeviceState.SLEEPING: VacuumActivity.IDLE,
-    YXDeviceState.IDLE: VacuumActivity.IDLE,
-    YXDeviceState.CLEANING: VacuumActivity.CLEANING,
-    YXDeviceState.RETURNING_HOME: VacuumActivity.RETURNING,
-    YXDeviceState.REMOTE_CONTROL_ACTIVE: VacuumActivity.CLEANING,
-    YXDeviceState.CHARGING: VacuumActivity.DOCKED,
-    YXDeviceState.PAUSED: VacuumActivity.PAUSED,
-    YXDeviceState.ERROR: VacuumActivity.ERROR,
-    YXDeviceState.UPDATING: VacuumActivity.DOCKED,
-    YXDeviceState.EMPTYING_THE_BIN: VacuumActivity.DOCKED,
-    YXDeviceState.MAPPING: VacuumActivity.CLEANING,
-    YXDeviceState.RELOCATING: VacuumActivity.CLEANING,
-    YXDeviceState.SWEEPING: VacuumActivity.CLEANING,
-    YXDeviceState.MOPPING: VacuumActivity.CLEANING,
-    YXDeviceState.SWEEP_AND_MOP: VacuumActivity.CLEANING,
-    YXDeviceState.TRANSITIONING: VacuumActivity.CLEANING,
-    YXDeviceState.WAITING_TO_CHARGE: VacuumActivity.DOCKED,
+    YXDeviceState.SLEEP_STATE: VacuumActivity.IDLE,
+    YXDeviceState.STANDBY_STATE: VacuumActivity.IDLE,
+    YXDeviceState.CLEANING_STATE: VacuumActivity.CLEANING,
+    YXDeviceState.TO_CHARGE_STATE: VacuumActivity.RETURNING,
+    YXDeviceState.REMOTEING_STATE: VacuumActivity.CLEANING,
+    YXDeviceState.CHARGING_STATE: VacuumActivity.DOCKED,
+    YXDeviceState.PAUSE_STATE: VacuumActivity.PAUSED,
+    YXDeviceState.FAULT_STATE: VacuumActivity.ERROR,
+    YXDeviceState.UPGRADE_STATE: VacuumActivity.DOCKED,
+    YXDeviceState.DUSTING: VacuumActivity.DOCKED,
+    YXDeviceState.CREATING_MAP_STATE: VacuumActivity.CLEANING,
+    YXDeviceState.RE_LOCATION_STATE: VacuumActivity.CLEANING,
+    YXDeviceState.ROBOT_SWEEPING: VacuumActivity.CLEANING,
+    YXDeviceState.ROBOT_MOPING: VacuumActivity.CLEANING,
+    YXDeviceState.ROBOT_SWEEP_AND_MOPING: VacuumActivity.CLEANING,
+    YXDeviceState.ROBOT_TRANSITIONING: VacuumActivity.CLEANING,
+    YXDeviceState.ROBOT_WAIT_CHARGE: VacuumActivity.DOCKED,
 }
 
 PARALLEL_UPDATES = 0

homeassistant/components/switch/trigger.py

@@ -1,18 +1,14 @@
 """Provides triggers for switch platform."""
 
-from homeassistant.components.input_boolean import DOMAIN as INPUT_BOOLEAN_DOMAIN
 from homeassistant.const import STATE_OFF, STATE_ON
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.automation import DomainSpec
 from homeassistant.helpers.trigger import Trigger, make_entity_target_state_trigger
 
 from .const import DOMAIN
 
-SWITCH_DOMAIN_SPECS = {DOMAIN: DomainSpec(), INPUT_BOOLEAN_DOMAIN: DomainSpec()}
-
 TRIGGERS: dict[str, type[Trigger]] = {
-    "turned_on": make_entity_target_state_trigger(SWITCH_DOMAIN_SPECS, STATE_ON),
-    "turned_off": make_entity_target_state_trigger(SWITCH_DOMAIN_SPECS, STATE_OFF),
+    "turned_on": make_entity_target_state_trigger(DOMAIN, STATE_ON),
+    "turned_off": make_entity_target_state_trigger(DOMAIN, STATE_OFF),
 }
 
 

homeassistant/components/switch/triggers.yaml

@@ -1,8 +1,7 @@
 .trigger_common: &trigger_common
   target:
     entity:
-      - domain: switch
-      - domain: input_boolean
+      domain: switch
   fields:
     behavior:
       required: true

homeassistant/components/telegram_bot/config_flow.py

@@ -153,7 +153,6 @@ STEP_WEBHOOKS_DATA_SCHEMA: vol.Schema = vol.Schema(
         vol.Required(CONF_TRUSTED_NETWORKS): vol.Coerce(str),
     }
 )
-SUBENTRY_SCHEMA: vol.Schema = vol.Schema({vol.Required(CONF_CHAT_ID): vol.Coerce(int)})
 OPTIONS_SCHEMA: vol.Schema = vol.Schema(
     {
         vol.Required(
@@ -599,30 +598,24 @@ class AllowedChatIdsSubEntryFlowHandler(ConfigSubentryFlow):
             )
 
         errors: dict[str, str] = {}
-        description_placeholders = DESCRIPTION_PLACEHOLDERS.copy()
 
         if user_input is not None:
             config_entry: TelegramBotConfigEntry = self._get_entry()
             bot = config_entry.runtime_data.bot
 
-            # validate chat id
             chat_id: int = user_input[CONF_CHAT_ID]
-            try:
-                chat_info: ChatFullInfo = await bot.get_chat(chat_id)
-            except BadRequest:
-                errors["base"] = "chat_not_found"
-            except TelegramError as err:
-                errors["base"] = "telegram_error"
-                description_placeholders[ERROR_MESSAGE] = str(err)
-
-            if not errors:
+            chat_name = await _async_get_chat_name(bot, chat_id)
+            if chat_name:
                 return self.async_create_entry(
-                    title=chat_info.effective_name or str(chat_id),
+                    title=f"{chat_name} ({chat_id})",
                     data={CONF_CHAT_ID: chat_id},
                     unique_id=str(chat_id),
                 )
 
+            errors["base"] = "chat_not_found"
+
         service: TelegramNotificationService = self._get_entry().runtime_data
+        description_placeholders = DESCRIPTION_PLACEHOLDERS.copy()
         description_placeholders["bot_username"] = f"@{service.bot.username}"
         description_placeholders["bot_url"] = f"https://t.me/{service.bot.username}"
 
@@ -646,7 +639,7 @@ class AllowedChatIdsSubEntryFlowHandler(ConfigSubentryFlow):
         return self.async_show_form(
             step_id="user",
             data_schema=self.add_suggested_values_to_schema(
-                SUBENTRY_SCHEMA,
+                vol.Schema({vol.Required(CONF_CHAT_ID): vol.Coerce(int)}),
                 suggested_values,
             ),
             description_placeholders=description_placeholders,
@@ -684,3 +677,11 @@ async def _get_most_recent_chat(
             )
 
     return None
+
+
+async def _async_get_chat_name(bot: Bot, chat_id: int) -> str:
+    try:
+        chat_info: ChatFullInfo = await bot.get_chat(chat_id)
+        return chat_info.effective_name or str(chat_id)
+    except BadRequest:
+        return ""

homeassistant/components/telegram_bot/strings.json

@@ -92,8 +92,7 @@
       },
       "entry_type": "Allowed chat ID",
       "error": {
-        "chat_not_found": "Chat not found",
-        "telegram_error": "[%key:component::telegram_bot::config::error::telegram_error%]"
+        "chat_not_found": "Chat not found"
       },
       "initiate_flow": {
         "user": "Add allowed chat ID"

homeassistant/components/temperature/strings.json

@@ -29,7 +29,7 @@
   "title": "Temperature",
   "triggers": {
     "changed": {
-      "description": "Triggers after one or more temperatures change.",
+      "description": "Triggers when the temperature changes.",
       "fields": {
         "above": {
           "description": "Only trigger when temperature is above this value.",
@@ -47,7 +47,7 @@
       "name": "Temperature changed"
     },
     "crossed_threshold": {
-      "description": "Triggers after one or more temperatures cross a threshold.",
+      "description": "Triggers when the temperature crosses a threshold.",
       "fields": {
         "behavior": {
           "description": "[%key:component::temperature::common::trigger_behavior_description%]",

homeassistant/components/template/alarm_control_panel.py

@@ -80,16 +80,6 @@ LEGACY_FIELDS = {
     CONF_VALUE_TEMPLATE: CONF_STATE,
 }
 
-SCRIPT_FIELDS = (
-    CONF_ARM_AWAY_ACTION,
-    CONF_ARM_CUSTOM_BYPASS_ACTION,
-    CONF_ARM_HOME_ACTION,
-    CONF_ARM_NIGHT_ACTION,
-    CONF_ARM_VACATION_ACTION,
-    CONF_DISARM_ACTION,
-    CONF_TRIGGER_ACTION,
-)
-
 DEFAULT_NAME = "Template Alarm Control Panel"
 
 ALARM_CONTROL_PANEL_COMMON_SCHEMA = vol.Schema(
@@ -162,7 +152,6 @@ async def async_setup_entry(
         StateAlarmControlPanelEntity,
         ALARM_CONTROL_PANEL_CONFIG_ENTRY_SCHEMA,
         True,
-        script_options=SCRIPT_FIELDS,
     )
 
 
@@ -183,7 +172,6 @@ async def async_setup_platform(
         discovery_info,
         LEGACY_FIELDS,
         legacy_key=CONF_ALARM_CONTROL_PANELS,
-        script_options=SCRIPT_FIELDS,
     )
 
 
@@ -209,7 +197,6 @@ class AbstractTemplateAlarmControlPanel(
 
     _entity_id_format = ENTITY_ID_FORMAT
     _optimistic_entity = True
-    _state_option = CONF_STATE
 
     # The super init is not called because TemplateEntity calls AbstractTemplateEntity.__init__.
     def __init__(self, name: str) -> None:  # pylint: disable=super-init-not-called
@@ -219,6 +206,7 @@ class AbstractTemplateAlarmControlPanel(
         self._attr_code_format = self._config[CONF_CODE_FORMAT].value
 
         self.setup_state_template(
+            CONF_STATE,
             "_attr_alarm_state",
             validator=tcv.strenum(self, CONF_STATE, AlarmControlPanelState),
         )

homeassistant/components/template/binary_sensor.py

@@ -176,7 +176,6 @@ class AbstractTemplateBinarySensor(
     """Representation of a template binary sensor features."""
 
     _entity_id_format = ENTITY_ID_FORMAT
-    _state_option = CONF_STATE
 
     # The super init is not called because TemplateEntity and TriggerEntity will call AbstractTemplateEntity.__init__.
     # This ensures that the __init__ on AbstractTemplateEntity is not called twice.
@@ -190,6 +189,7 @@ class AbstractTemplateBinarySensor(
         self._delay_cancel: CALLBACK_TYPE | None = None
 
         self.setup_state_template(
+            CONF_STATE,
             "_attr_is_on",
             on_update=self._update_state,
         )

homeassistant/components/template/button.py

@@ -36,8 +36,6 @@ _LOGGER = logging.getLogger(__name__)
 DEFAULT_NAME = "Template Button"
 DEFAULT_OPTIMISTIC = False
 
-SCRIPT_FIELDS = (CONF_PRESS,)
-
 BUTTON_YAML_SCHEMA = vol.Schema(
     {
         vol.Required(CONF_PRESS): cv.SCRIPT_SCHEMA,
@@ -68,7 +66,6 @@ async def async_setup_platform(
         None,
         async_add_entities,
         discovery_info,
-        script_options=SCRIPT_FIELDS,
     )
 
 
@@ -84,7 +81,6 @@ async def async_setup_entry(
         async_add_entities,
         StateButtonEntity,
         BUTTON_CONFIG_ENTRY_SCHEMA,
-        script_options=SCRIPT_FIELDS,
     )
 
 

homeassistant/components/template/cover.py

@@ -71,14 +71,6 @@ CONF_TILT_OPTIMISTIC = "tilt_optimistic"
 
 CONF_OPEN_AND_CLOSE = "open_or_close"
 
-SCRIPT_FIELDS = (
-    CLOSE_ACTION,
-    OPEN_ACTION,
-    POSITION_ACTION,
-    STOP_ACTION,
-    TILT_ACTION,
-)
-
 TILT_FEATURES = (
     CoverEntityFeature.OPEN_TILT
     | CoverEntityFeature.CLOSE_TILT
@@ -173,7 +165,6 @@ async def async_setup_platform(
         discovery_info,
         LEGACY_FIELDS,
         legacy_key=CONF_COVERS,
-        script_options=SCRIPT_FIELDS,
     )
 
 
@@ -190,7 +181,6 @@ async def async_setup_entry(
         StateCoverEntity,
         COVER_CONFIG_ENTRY_SCHEMA,
         True,
-        script_options=SCRIPT_FIELDS,
     )
 
 
@@ -215,7 +205,6 @@ class AbstractTemplateCover(AbstractTemplateEntity, CoverEntity):
     _entity_id_format = ENTITY_ID_FORMAT
     _optimistic_entity = True
     _extra_optimistic_options = (CONF_POSITION,)
-    _state_option = CONF_STATE
 
     # The super init is not called because TemplateEntity and TriggerEntity will call AbstractTemplateEntity.__init__.
     # This ensures that the __init__ on AbstractTemplateEntity is not called twice.
@@ -223,6 +212,7 @@ class AbstractTemplateCover(AbstractTemplateEntity, CoverEntity):
         """Initialize the features."""
 
         self.setup_state_template(
+            CONF_STATE,
             "_attr_current_cover_position",
             template_validators.strenum(
                 self, CONF_STATE, CoverState, CoverState.OPEN, CoverState.CLOSED

homeassistant/components/template/entity.py

@@ -3,9 +3,10 @@
 from abc import abstractmethod
 from collections.abc import Callable, Sequence
 from dataclasses import dataclass
+import logging
 from typing import Any
 
-from homeassistant.const import CONF_DEVICE_ID, CONF_OPTIMISTIC
+from homeassistant.const import CONF_DEVICE_ID, CONF_OPTIMISTIC, CONF_STATE
 from homeassistant.core import Context, HomeAssistant, callback
 from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.entity import Entity, async_generate_entity_id
@@ -15,6 +16,8 @@ from homeassistant.helpers.typing import ConfigType
 
 from .const import CONF_DEFAULT_ENTITY_ID
 
+_LOGGER = logging.getLogger(__name__)
+
 
 @dataclass
 class EntityTemplate:
@@ -33,7 +36,7 @@ class AbstractTemplateEntity(Entity):
     _entity_id_format: str
     _optimistic_entity: bool = False
     _extra_optimistic_options: tuple[str, ...] | None = None
-    _state_option: str | None = None
+    _template: Template | None = None
 
     def __init__(
         self,
@@ -50,18 +53,19 @@ class AbstractTemplateEntity(Entity):
         if self._optimistic_entity:
             optimistic = config.get(CONF_OPTIMISTIC)
 
-            if self._state_option is not None:
-                assumed_optimistic = config.get(self._state_option) is None
-                if self._extra_optimistic_options:
-                    assumed_optimistic = assumed_optimistic and all(
-                        config.get(option) is None
-                        for option in self._extra_optimistic_options
-                    )
+            self._template = config.get(CONF_STATE)
 
-                self._attr_assumed_state = optimistic or (
-                    optimistic is None and assumed_optimistic
+            assumed_optimistic = self._template is None
+            if self._extra_optimistic_options:
+                assumed_optimistic = assumed_optimistic and all(
+                    config.get(option) is None
+                    for option in self._extra_optimistic_options
                 )
 
+            self._attr_assumed_state = optimistic or (
+                optimistic is None and assumed_optimistic
+            )
+
         if (default_entity_id := config.get(CONF_DEFAULT_ENTITY_ID)) is not None:
             _, _, object_id = default_entity_id.partition(".")
             self.entity_id = async_generate_entity_id(
@@ -85,16 +89,12 @@ class AbstractTemplateEntity(Entity):
     @abstractmethod
     def setup_state_template(
         self,
+        option: str,
         attribute: str,
         validator: Callable[[Any], Any] | None = None,
         on_update: Callable[[Any], None] | None = None,
     ) -> None:
-        """Set up a template that manages the main state of the entity.
-
-        Requires _state_option to be set on the inheriting class. _state_option represents
-        the configuration option that derives the state. E.g. Template weather entities main state option
-        is 'condition', where switch is 'state'.
-        """
+        """Set up a template that manages the main state of the entity."""
 
     @abstractmethod
     def setup_template(

homeassistant/components/template/fan.py

@@ -87,15 +87,6 @@ LEGACY_FIELDS = {
 
 DEFAULT_NAME = "Template Fan"
 
-SCRIPT_FIELDS = (
-    CONF_OFF_ACTION,
-    CONF_ON_ACTION,
-    CONF_SET_DIRECTION_ACTION,
-    CONF_SET_OSCILLATING_ACTION,
-    CONF_SET_PERCENTAGE_ACTION,
-    CONF_SET_PRESET_MODE_ACTION,
-)
-
 FAN_COMMON_SCHEMA = vol.Schema(
     {
         vol.Optional(CONF_DIRECTION): cv.template,
@@ -168,7 +159,6 @@ async def async_setup_platform(
         discovery_info,
         LEGACY_FIELDS,
         legacy_key=CONF_FANS,
-        script_options=SCRIPT_FIELDS,
     )
 
 
@@ -184,7 +174,6 @@ async def async_setup_entry(
         async_add_entities,
         StateFanEntity,
         FAN_CONFIG_ENTRY_SCHEMA,
-        script_options=SCRIPT_FIELDS,
     )
 
 
@@ -207,13 +196,13 @@ class AbstractTemplateFan(AbstractTemplateEntity, FanEntity):
 
     _entity_id_format = ENTITY_ID_FORMAT
     _optimistic_entity = True
-    _state_option = CONF_STATE
 
     # The super init is not called because TemplateEntity and TriggerEntity will call AbstractTemplateEntity.__init__.
     # This ensures that the __init__ on AbstractTemplateEntity is not called twice.
     def __init__(self, name: str, config: dict[str, Any]) -> None:  # pylint: disable=super-init-not-called
         """Initialize the features."""
         self.setup_state_template(
+            CONF_STATE,
             "_attr_is_on",
             template_validators.boolean(self, CONF_STATE),
         )

homeassistant/components/template/helpers.py

@@ -8,7 +8,6 @@ import logging
 from typing import Any
 
 import voluptuous as vol
-from voluptuous.humanize import humanize_error
 
 from homeassistant.components import blueprint
 from homeassistant.config_entries import ConfigEntry
@@ -26,7 +25,7 @@ from homeassistant.const import (
     SERVICE_RELOAD,
 )
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.exceptions import HomeAssistantError, PlatformNotReady
+from homeassistant.exceptions import PlatformNotReady
 from homeassistant.helpers import issue_registry as ir, template
 from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.entity_platform import (
@@ -35,7 +34,6 @@ from homeassistant.helpers.entity_platform import (
     async_get_platforms,
 )
 from homeassistant.helpers.issue_registry import IssueSeverity
-from homeassistant.helpers.script import async_validate_actions_config
 from homeassistant.helpers.script_variables import ScriptVariables
 from homeassistant.helpers.singleton import singleton
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
@@ -210,21 +208,6 @@ def _format_template(value: Any, field: str | None = None) -> Any:
     return str(value)
 
 
-def _get_config_breadcrumbs(config: ConfigType) -> str:
-    """Try to coerce entity information from the config."""
-    breadcrumb = "Template Entity"
-    # Default entity id should be in most legacy configuration because
-    # it's created from the legacy slug. Vacuum and Lock do not have a
-    # slug, therefore we need to use the name or unique_id.
-    if (default_entity_id := config.get(CONF_DEFAULT_ENTITY_ID)) is not None:
-        breadcrumb = default_entity_id.split(".")[-1]
-    elif (unique_id := config.get(CONF_UNIQUE_ID)) is not None:
-        breadcrumb = f"unique_id: {unique_id}"
-    elif (name := config.get(CONF_NAME)) and isinstance(name, template.Template):
-        breadcrumb = name.template
-    return breadcrumb
-
-
 def format_migration_config(
     config: ConfigType | list[ConfigType], depth: int = 0
 ) -> ConfigType | list[ConfigType]:
@@ -269,7 +252,16 @@ def create_legacy_template_issue(
     if domain not in PLATFORMS:
         return
 
-    breadcrumb = _get_config_breadcrumbs(config)
+    breadcrumb = "Template Entity"
+    # Default entity id should be in most legacy configuration because
+    # it's created from the legacy slug. Vacuum and Lock do not have a
+    # slug, therefore we need to use the name or unique_id.
+    if (default_entity_id := config.get(CONF_DEFAULT_ENTITY_ID)) is not None:
+        breadcrumb = default_entity_id.split(".")[-1]
+    elif (unique_id := config.get(CONF_UNIQUE_ID)) is not None:
+        breadcrumb = f"unique_id: {unique_id}"
+    elif (name := config.get(CONF_NAME)) and isinstance(name, template.Template):
+        breadcrumb = name.template
 
     issue_id = f"{LEGACY_TEMPLATE_DEPRECATION_KEY}_{domain}_{breadcrumb}_{hashlib.md5(','.join(config.keys()).encode()).hexdigest()}"
 
@@ -304,39 +296,6 @@ def create_legacy_template_issue(
     )
 
 
-async def validate_template_scripts(
-    hass: HomeAssistant,
-    config: ConfigType,
-    script_options: tuple[str, ...] | None = None,
-) -> None:
-    """Validate template scripts."""
-    if not script_options:
-        return
-
-    def _humanize(err: Exception, data: Any) -> str:
-        """Humanize vol.Invalid, stringify other exceptions."""
-        if isinstance(err, vol.Invalid):
-            return humanize_error(data, err)
-        return str(err)
-
-    breadcrumb: str | None = None
-    for script_option in script_options:
-        if (script_config := config.pop(script_option, None)) is not None:
-            try:
-                config[script_option] = await async_validate_actions_config(
-                    hass, script_config
-                )
-            except (vol.Invalid, HomeAssistantError) as err:
-                if not breadcrumb:
-                    breadcrumb = _get_config_breadcrumbs(config)
-                _LOGGER.error(
-                    "The '%s' actions for %s failed to setup: %s",
-                    script_option,
-                    breadcrumb,
-                    _humanize(err, script_config),
-                )
-
-
 async def async_setup_template_platform(
     hass: HomeAssistant,
     domain: str,
@@ -347,7 +306,6 @@ async def async_setup_template_platform(
     discovery_info: DiscoveryInfoType | None,
     legacy_fields: dict[str, str] | None = None,
     legacy_key: str | None = None,
-    script_options: tuple[str, ...] | None = None,
 ) -> None:
     """Set up the Template platform."""
     if discovery_info is None:
@@ -379,14 +337,10 @@ async def async_setup_template_platform(
     # Trigger Configuration
     if "coordinator" in discovery_info:
         if trigger_entity_cls:
-            entities = []
-            for entity_config in discovery_info["entities"]:
-                await validate_template_scripts(hass, entity_config, script_options)
-                entities.append(
-                    trigger_entity_cls(
-                        hass, discovery_info["coordinator"], entity_config
-                    )
-                )
+            entities = [
+                trigger_entity_cls(hass, discovery_info["coordinator"], config)
+                for config in discovery_info["entities"]
+            ]
             async_add_entities(entities)
         else:
             raise PlatformNotReady(
@@ -395,9 +349,6 @@ async def async_setup_template_platform(
         return
 
     # Modern Configuration
-    for entity_config in discovery_info["entities"]:
-        await validate_template_scripts(hass, entity_config, script_options)
-
     async_create_template_tracking_entities(
         state_entity_cls,
         async_add_entities,
@@ -414,7 +365,6 @@ async def async_setup_template_entry(
     state_entity_cls: type[TemplateEntity],
     config_schema: vol.Schema | vol.All,
     replace_value_template: bool = False,
-    script_options: tuple[str, ...] | None = None,
 ) -> None:
     """Setup the Template from a config entry."""
     options = dict(config_entry.options)
@@ -427,7 +377,6 @@ async def async_setup_template_entry(
         options[CONF_STATE] = options.pop(CONF_VALUE_TEMPLATE)
 
     validated_config = config_schema(options)
-    await validate_template_scripts(hass, validated_config, script_options)
 
     async_add_entities(
         [state_entity_cls(hass, validated_config, config_entry.entry_id)]

homeassistant/components/template/light.py

@@ -129,18 +129,6 @@ LEGACY_FIELDS = {
 
 DEFAULT_NAME = "Template Light"
 
-SCRIPT_FIELDS = (
-    CONF_EFFECT_ACTION,
-    CONF_HS_ACTION,
-    CONF_LEVEL_ACTION,
-    CONF_OFF_ACTION,
-    CONF_ON_ACTION,
-    CONF_RGB_ACTION,
-    CONF_RGBW_ACTION,
-    CONF_RGBWW_ACTION,
-    CONF_TEMPERATURE_ACTION,
-)
-
 LIGHT_COMMON_SCHEMA = vol.Schema(
     {
         vol.Inclusive(CONF_EFFECT_ACTION, "effect"): cv.SCRIPT_SCHEMA,
@@ -154,6 +142,8 @@ LIGHT_COMMON_SCHEMA = vol.Schema(
         vol.Optional(CONF_MIN_MIREDS): cv.template,
         vol.Required(CONF_OFF_ACTION): cv.SCRIPT_SCHEMA,
         vol.Required(CONF_ON_ACTION): cv.SCRIPT_SCHEMA,
+        vol.Required(CONF_OFF_ACTION): cv.SCRIPT_SCHEMA,
+        vol.Required(CONF_ON_ACTION): cv.SCRIPT_SCHEMA,
         vol.Optional(CONF_RGB_ACTION): cv.SCRIPT_SCHEMA,
         vol.Optional(CONF_RGB): cv.template,
         vol.Optional(CONF_RGBW_ACTION): cv.SCRIPT_SCHEMA,
@@ -236,7 +226,6 @@ async def async_setup_platform(
         discovery_info,
         LEGACY_FIELDS,
         legacy_key=CONF_LIGHTS,
-        script_options=SCRIPT_FIELDS,
     )
 
 
@@ -253,7 +242,6 @@ async def async_setup_entry(
         StateLightEntity,
         LIGHT_CONFIG_ENTRY_SCHEMA,
         True,
-        script_options=SCRIPT_FIELDS,
     )
 
 
@@ -359,7 +347,6 @@ class AbstractTemplateLight(AbstractTemplateEntity, LightEntity):
     _optimistic_entity = True
     _attr_max_color_temp_kelvin = DEFAULT_MAX_KELVIN
     _attr_min_color_temp_kelvin = DEFAULT_MIN_KELVIN
-    _state_option = CONF_STATE
 
     # The super init is not called because TemplateEntity and TriggerEntity will call AbstractTemplateEntity.__init__.
     # This ensures that the __init__ on AbstractTemplateEntity is not called twice.
@@ -370,7 +357,7 @@ class AbstractTemplateLight(AbstractTemplateEntity, LightEntity):
 
         # Setup state and brightness
         self.setup_state_template(
-            "_attr_is_on", template_validators.boolean(self, CONF_STATE)
+            CONF_STATE, "_attr_is_on", template_validators.boolean(self, CONF_STATE)
         )
         self.setup_template(
             CONF_LEVEL,

homeassistant/components/template/lock.py

@@ -64,13 +64,6 @@ LEGACY_FIELDS = {
     CONF_VALUE_TEMPLATE: CONF_STATE,
 }
 
-SCRIPT_FIELDS = (
-    CONF_LOCK,
-    CONF_OPEN,
-    CONF_UNLOCK,
-)
-
-
 LOCK_COMMON_SCHEMA = vol.Schema(
     {
         vol.Optional(CONF_CODE_FORMAT): cv.template,
@@ -119,7 +112,6 @@ async def async_setup_platform(
         async_add_entities,
         discovery_info,
         LEGACY_FIELDS,
-        script_options=SCRIPT_FIELDS,
     )
 
 
@@ -135,7 +127,6 @@ async def async_setup_entry(
         async_add_entities,
         StateLockEntity,
         LOCK_CONFIG_ENTRY_SCHEMA,
-        script_options=SCRIPT_FIELDS,
     )
 
 
@@ -158,7 +149,6 @@ class AbstractTemplateLock(AbstractTemplateEntity, LockEntity):
 
     _entity_id_format = ENTITY_ID_FORMAT
     _optimistic_entity = True
-    _state_option = CONF_STATE
 
     # The super init is not called because TemplateEntity and TriggerEntity will call AbstractTemplateEntity.__init__.
     # This ensures that the __init__ on AbstractTemplateEntity is not called twice.
@@ -167,6 +157,7 @@ class AbstractTemplateLock(AbstractTemplateEntity, LockEntity):
         self._code_format_template_error: TemplateError | None = None
 
         self.setup_state_template(
+            CONF_STATE,
             "_lock_state",
             template_validators.strenum(
                 self, CONF_STATE, LockState, LockState.LOCKED, LockState.UNLOCKED
@@ -192,18 +183,16 @@ class AbstractTemplateLock(AbstractTemplateEntity, LockEntity):
                 self._attr_supported_features |= supported_feature
 
     def _set_state(self, state: LockState | None) -> None:
+        if state is None:
+            self._attr_is_locked = None
+            return
+
         self._attr_is_jammed = state == LockState.JAMMED
         self._attr_is_opening = state == LockState.OPENING
         self._attr_is_locking = state == LockState.LOCKING
         self._attr_is_open = state == LockState.OPEN
         self._attr_is_unlocking = state == LockState.UNLOCKING
-
-        # All other parameters need to be set False in order
-        # for the lock to be unknown.
-        if state is None:
-            self._attr_is_locked = state
-        else:
-            self._attr_is_locked = state == LockState.LOCKED
+        self._attr_is_locked = state == LockState.LOCKED
 
     @callback
     def _update_code_format(self, render: str | TemplateError | None):

homeassistant/components/template/number.py

@@ -46,8 +46,6 @@ CONF_SET_VALUE = "set_value"
 DEFAULT_NAME = "Template Number"
 DEFAULT_OPTIMISTIC = False
 
-SCRIPT_FIELDS = (CONF_SET_VALUE,)
-
 NUMBER_COMMON_SCHEMA = vol.Schema(
     {
         vol.Optional(CONF_MAX, default=DEFAULT_MAX_VALUE): cv.template,
@@ -83,7 +81,6 @@ async def async_setup_platform(
         TriggerNumberEntity,
         async_add_entities,
         discovery_info,
-        script_options=SCRIPT_FIELDS,
     )
 
 
@@ -99,7 +96,6 @@ async def async_setup_entry(
         async_add_entities,
         StateNumberEntity,
         NUMBER_CONFIG_ENTRY_SCHEMA,
-        script_options=SCRIPT_FIELDS,
     )
 
 
@@ -118,7 +114,6 @@ class AbstractTemplateNumber(AbstractTemplateEntity, NumberEntity):
 
     _entity_id_format = ENTITY_ID_FORMAT
     _optimistic_entity = True
-    _state_option = CONF_STATE
 
     # The super init is not called because TemplateEntity and TriggerEntity will call AbstractTemplateEntity.__init__.
     # This ensures that the __init__ on AbstractTemplateEntity is not called twice.
@@ -130,6 +125,7 @@ class AbstractTemplateNumber(AbstractTemplateEntity, NumberEntity):
         self._attr_native_max_value = DEFAULT_MAX_VALUE
 
         self.setup_state_template(
+            CONF_STATE,
             "_attr_native_value",
             template_validators.number(self, CONF_STATE),
         )

homeassistant/components/template/select.py

@@ -47,8 +47,6 @@ CONF_SELECT_OPTION = "select_option"
 
 DEFAULT_NAME = "Template Select"
 
-SCRIPT_FIELDS = (CONF_SELECT_OPTION,)
-
 SELECT_COMMON_SCHEMA = vol.Schema(
     {
         vol.Required(ATTR_OPTIONS): cv.template,
@@ -81,7 +79,6 @@ async def async_setup_platform(
         TriggerSelectEntity,
         async_add_entities,
         discovery_info,
-        script_options=SCRIPT_FIELDS,
     )
 
 
@@ -97,7 +94,6 @@ async def async_setup_entry(
         async_add_entities,
         TemplateSelect,
         SELECT_CONFIG_ENTRY_SCHEMA,
-        script_options=SCRIPT_FIELDS,
     )
 
 
@@ -116,7 +112,6 @@ class AbstractTemplateSelect(AbstractTemplateEntity, SelectEntity):
 
     _entity_id_format = ENTITY_ID_FORMAT
     _optimistic_entity = True
-    _state_option = CONF_STATE
 
     # The super init is not called because TemplateEntity and TriggerEntity will call AbstractTemplateEntity.__init__.
     # This ensures that the __init__ on AbstractTemplateEntity is not called twice.
@@ -125,6 +120,7 @@ class AbstractTemplateSelect(AbstractTemplateEntity, SelectEntity):
         self._attr_options = []
 
         self.setup_state_template(
+            CONF_STATE,
             "_attr_current_option",
             cv.string,
         )

homeassistant/components/template/sensor.py

@@ -229,7 +229,6 @@ class AbstractTemplateSensor(AbstractTemplateEntity, RestoreSensor):
     """Representation of a template sensor features."""
 
     _entity_id_format = ENTITY_ID_FORMAT
-    _state_option = CONF_STATE
 
     # The super init is not called because TemplateEntity and TriggerEntity will call AbstractTemplateEntity.__init__.
     # This ensures that the __init__ on AbstractTemplateEntity is not called twice.
@@ -241,6 +240,7 @@ class AbstractTemplateSensor(AbstractTemplateEntity, RestoreSensor):
         self._attr_last_reset = None
 
         self.setup_state_template(
+            CONF_STATE,
             "_attr_native_value",
             self._validate_state,
         )

homeassistant/components/template/switch.py

@@ -57,16 +57,11 @@ LEGACY_FIELDS = {
 
 DEFAULT_NAME = "Template Switch"
 
-SCRIPT_FIELDS = (
-    CONF_TURN_OFF,
-    CONF_TURN_ON,
-)
-
 SWITCH_COMMON_SCHEMA = vol.Schema(
     {
         vol.Optional(CONF_STATE): cv.template,
-        vol.Optional(CONF_TURN_OFF): cv.SCRIPT_SCHEMA,
         vol.Optional(CONF_TURN_ON): cv.SCRIPT_SCHEMA,
+        vol.Optional(CONF_TURN_OFF): cv.SCRIPT_SCHEMA,
     }
 )
 
@@ -114,7 +109,6 @@ async def async_setup_platform(
         discovery_info,
         LEGACY_FIELDS,
         legacy_key=CONF_SWITCHES,
-        script_options=SCRIPT_FIELDS,
     )
 
 
@@ -131,7 +125,6 @@ async def async_setup_entry(
         StateSwitchEntity,
         SWITCH_CONFIG_ENTRY_SCHEMA,
         True,
-        script_options=SCRIPT_FIELDS,
     )
 
 
@@ -155,7 +148,6 @@ class AbstractTemplateSwitch(AbstractTemplateEntity, SwitchEntity, RestoreEntity
 
     _entity_id_format = ENTITY_ID_FORMAT
     _optimistic_entity = True
-    _state_option = CONF_STATE
 
     # The super init is not called because TemplateEntity and TriggerEntity will call AbstractTemplateEntity.__init__.
     # This ensures that the __init__ on AbstractTemplateEntity is not called twice.
@@ -163,6 +155,7 @@ class AbstractTemplateSwitch(AbstractTemplateEntity, SwitchEntity, RestoreEntity
         """Initialize the features."""
 
         self.setup_state_template(
+            CONF_STATE,
             "_attr_is_on",
             template_validators.boolean(self, CONF_STATE),
         )

homeassistant/components/template/template_entity.py

@@ -292,16 +292,12 @@ class TemplateEntity(AbstractTemplateEntity):
 
     def setup_state_template(
         self,
+        option: str,
         attribute: str,
         validator: Callable[[Any], Any] | None = None,
         on_update: Callable[[Any], None] | None = None,
     ) -> None:
-        """Set up a template that manages the main state of the entity.
-
-        Requires _state_option to be set on the inheriting class. _state_option represents
-        the configuration option that derives the state. E.g. Template weather entities main state option
-        is 'condition', where switch is 'state'.
-        """
+        """Set up a template that manages the main state of the entity."""
 
         @callback
         def _update_state(result: Any) -> None:
@@ -318,22 +314,13 @@ class TemplateEntity(AbstractTemplateEntity):
                 self._attr_available = True
 
             state = validator(result) if validator else result
-
             if on_update:
                 on_update(state)
             else:
                 setattr(self, attribute, state)
 
-        if self._state_option is None:
-            raise NotImplementedError(
-                f"{self.__class__.__name__} does not implement '_state_option' for 'setup_state_template'."
-            )
-
         self.add_template(
-            self._state_option,
-            attribute,
-            on_update=_update_state,
-            none_on_template_error=False,
+            option, attribute, on_update=_update_state, none_on_template_error=False
         )
 
     def setup_template(

homeassistant/components/template/trigger_entity.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from collections.abc import Callable
 from typing import Any
 
-from homeassistant.const import CONF_VARIABLES
+from homeassistant.const import CONF_STATE, CONF_VARIABLES
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import TemplateError
 from homeassistant.helpers.script_variables import ScriptVariables
@@ -60,30 +60,17 @@ class TriggerEntity(  # pylint: disable=hass-enforce-class-module
 
     def setup_state_template(
         self,
+        option: str,
         attribute: str,
         validator: Callable[[Any], Any] | None = None,
         on_update: Callable[[Any], None] | None = None,
     ) -> None:
-        """Set up a template that manages the main state of the entity.
-
-        Requires _state_option to be set on the inheriting class. _state_option represents
-        the configuration option that derives the state. E.g. Template weather entities main state option
-        is 'condition', where switch is 'state'.
-        """
-        if self._state_option is None:
-            raise NotImplementedError(
-                f"{self.__class__.__name__} does not implement '_state_option' for 'setup_state_template'."
-            )
-
+        """Set up a template that manages the main state of the entity."""
         if self.add_template(
-            self._state_option,
-            attribute,
-            validator,
-            on_update,
-            none_on_template_error=False,
+            option, attribute, validator, on_update, none_on_template_error=False
         ):
-            self._to_render_simple.append(self._state_option)
-            self._parse_result.add(self._state_option)
+            self._to_render_simple.append(option)
+            self._parse_result.add(option)
 
     def setup_template(
         self,
@@ -162,7 +149,7 @@ class TriggerEntity(  # pylint: disable=hass-enforce-class-module
             # Filter out state templates because they have unique behavior
             # with none_on_template_error.
             if (
-                key != self._state_option
+                key != CONF_STATE
                 and key in self._templates
                 and not self._templates[key].none_on_template_error
             ):
@@ -177,21 +164,17 @@ class TriggerEntity(  # pylint: disable=hass-enforce-class-module
 
         # If state fails to render, the entity should go unavailable. Render the
         # state as a simple template because the result should always be a string or None.
-        if (
-            state_option := self._state_option
-        ) is not None and state_option in self._to_render_simple:
+        if CONF_STATE in self._to_render_simple:
             if (
-                result := self._render_single_template(state_option, variables)
+                result := self._render_single_template(CONF_STATE, variables)
             ) is _SENTINEL:
                 self._rendered = self._static_rendered
                 self._state_render_error = True
                 return
 
-            rendered[state_option] = result
+            rendered[CONF_STATE] = result
 
-        self._render_single_templates(
-            rendered, variables, [state_option] if state_option else []
-        )
+        self._render_single_templates(rendered, variables, [CONF_STATE])
         self._render_attributes(rendered, variables)
         self._rendered = rendered
 
@@ -199,10 +182,6 @@ class TriggerEntity(  # pylint: disable=hass-enforce-class-module
         """Get a rendered result and return the value."""
         # Handle any templates.
         write_state = False
-        if self._state_render_error:
-            # The state errored and the entity is unavailable, do not process any values.
-            return True
-
         for option, entity_template in self._templates.items():
             # Capture templates that did not render a result due to an exception and
             # ensure the state object updates. _SENTINEL is used to differentiate
@@ -246,7 +225,18 @@ class TriggerEntity(  # pylint: disable=hass-enforce-class-module
         if self._render_availability_template(variables):
             self._render_templates(variables)
 
-            write_state = self._handle_rendered_results()
+            write_state = False
+            # While transitioning platforms to the new framework, this
+            # if-statement is necessary for backward compatibility with existing
+            # trigger based platforms.
+            if self._templates:
+                # Handle any results that were rendered.
+                write_state = self._handle_rendered_results()
+
+            # Check availability after rendering the results because the state
+            # template could render the entity unavailable
+            if not self.available:
+                write_state = True
 
             if len(self._rendered) > 0:
                 # In some cases, the entity may be state optimistic or

homeassistant/components/template/update.py

@@ -65,8 +65,6 @@ CONF_SPECIFIC_VERSION = "specific_version"
 CONF_TITLE = "title"
 CONF_UPDATE_PERCENTAGE = "update_percentage"
 
-SCRIPT_FIELDS = (CONF_INSTALL,)
-
 UPDATE_COMMON_SCHEMA = vol.Schema(
     {
         vol.Optional(CONF_BACKUP, default=False): cv.boolean,
@@ -107,7 +105,6 @@ async def async_setup_platform(
         TriggerUpdateEntity,
         async_add_entities,
         discovery_info,
-        script_options=SCRIPT_FIELDS,
     )
 
 
@@ -123,7 +120,6 @@ async def async_setup_entry(
         async_add_entities,
         StateUpdateEntity,
         UPDATE_CONFIG_ENTRY_SCHEMA,
-        script_options=SCRIPT_FIELDS,
     )
 
 

homeassistant/components/template/vacuum.py

@@ -76,16 +76,6 @@ LEGACY_FIELDS = {
     CONF_VALUE_TEMPLATE: CONF_STATE,
 }
 
-SCRIPT_FIELDS = (
-    SERVICE_CLEAN_SPOT,
-    SERVICE_LOCATE,
-    SERVICE_PAUSE,
-    SERVICE_RETURN_TO_BASE,
-    SERVICE_SET_FAN_SPEED,
-    SERVICE_START,
-    SERVICE_STOP,
-)
-
 VACUUM_COMMON_SCHEMA = vol.Schema(
     {
         vol.Optional(CONF_BATTERY_LEVEL): cv.template,
@@ -160,7 +150,6 @@ async def async_setup_platform(
         discovery_info,
         LEGACY_FIELDS,
         legacy_key=CONF_VACUUMS,
-        script_options=SCRIPT_FIELDS,
     )
 
 
@@ -176,7 +165,6 @@ async def async_setup_entry(
         async_add_entities,
         TemplateStateVacuumEntity,
         VACUUM_CONFIG_ENTRY_SCHEMA,
-        script_options=SCRIPT_FIELDS,
     )
 
 
@@ -219,7 +207,6 @@ class AbstractTemplateVacuum(AbstractTemplateEntity, StateVacuumEntity):
 
     _entity_id_format = ENTITY_ID_FORMAT
     _optimistic_entity = True
-    _state_option = CONF_STATE
 
     # The super init is not called because TemplateEntity and TriggerEntity will call AbstractTemplateEntity.__init__.
     # This ensures that the __init__ on AbstractTemplateEntity is not called twice.
@@ -229,6 +216,7 @@ class AbstractTemplateVacuum(AbstractTemplateEntity, StateVacuumEntity):
         # List of valid fan speeds
         self._attr_fan_speed_list = config[CONF_FAN_SPEED_LIST]
         self.setup_state_template(
+            CONF_STATE,
             "_attr_activity",
             template_validators.strenum(self, CONF_STATE, VacuumActivity),
         )

homeassistant/components/template/weather.py

@@ -389,7 +389,6 @@ class AbstractTemplateWeather(AbstractTemplateEntity, WeatherEntity):
     """Representation of a template weathers features."""
 
     _entity_id_format = ENTITY_ID_FORMAT
-    _state_option = CONF_CONDITION
     _optimistic_entity = True
 
     # The super init is not called because TemplateEntity and TriggerEntity will call AbstractTemplateEntity.__init__.
@@ -400,7 +399,8 @@ class AbstractTemplateWeather(AbstractTemplateEntity, WeatherEntity):
         """Initialize the features."""
 
         # Required options
-        self.setup_state_template(
+        self.setup_template(
+            CONF_CONDITION,
             "_attr_condition",
             template_validators.item_in_list(self, CONF_CONDITION, CONDITION_CLASSES),
         )

homeassistant/components/tplink_omada/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "local_polling",
   "quality_scale": "bronze",
-  "requirements": ["tplink-omada-client==1.5.6"]
+  "requirements": ["tplink-omada-client==1.5.3"]
 }

homeassistant/components/trane/__init__.py

@@ -10,7 +10,7 @@ from steamloop import (
 
 from homeassistant.const import CONF_HOST, Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryError, ConfigEntryNotReady
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import device_registry as dr
 
 from .const import CONF_SECRET_KEY, DOMAIN, MANUFACTURER
@@ -37,7 +37,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: TraneConfigEntry) -> boo
         ) from err
     except AuthenticationError as err:
         await conn.disconnect()
-        raise ConfigEntryError(
+        raise ConfigEntryAuthFailed(
             translation_domain=DOMAIN,
             translation_key="authentication_failed",
         ) from err

homeassistant/components/tuya/alarm_control_panel.py

@@ -121,7 +121,9 @@ class TuyaAlarmEntity(TuyaEntity, AlarmControlPanelEntity):
         state_wrapper: DeviceWrapper[TuyaAlarmControlPanelState],
     ) -> None:
         """Init Tuya Alarm."""
-        super().__init__(device, device_manager, description)
+        super().__init__(device, device_manager)
+        self.entity_description = description
+        self._attr_unique_id = f"{super().unique_id}{description.key}"
         self._action_wrapper = action_wrapper
         self._changed_by_wrapper = changed_by_wrapper
         self._state_wrapper = state_wrapper

homeassistant/components/tuya/binary_sensor.py

@@ -449,7 +449,9 @@ class TuyaBinarySensorEntity(TuyaEntity, BinarySensorEntity):
         dpcode_wrapper: DeviceWrapper[bool],
     ) -> None:
         """Init Tuya binary sensor."""
-        super().__init__(device, device_manager, description)
+        super().__init__(device, device_manager)
+        self.entity_description = description
+        self._attr_unique_id = f"{super().unique_id}{description.key}"
         self._dpcode_wrapper = dpcode_wrapper
 
     @property

homeassistant/components/tuya/button.py

@@ -111,7 +111,9 @@ class TuyaButtonEntity(TuyaEntity, ButtonEntity):
         dpcode_wrapper: DeviceWrapper[bool],
     ) -> None:
         """Init Tuya button."""
-        super().__init__(device, device_manager, description)
+        super().__init__(device, device_manager)
+        self.entity_description = description
+        self._attr_unique_id = f"{super().unique_id}{description.key}"
         self._dpcode_wrapper = dpcode_wrapper
 
     async def async_press(self) -> None:

homeassistant/components/tuya/climate.py

@@ -79,27 +79,27 @@ class TuyaClimateEntityDescription(ClimateEntityDescription):
 
 CLIMATE_DESCRIPTIONS: dict[DeviceCategory, TuyaClimateEntityDescription] = {
     DeviceCategory.DBL: TuyaClimateEntityDescription(
-        key="",
+        key="dbl",
         switch_only_hvac_mode=HVACMode.HEAT,
     ),
     DeviceCategory.KT: TuyaClimateEntityDescription(
-        key="",
+        key="kt",
         switch_only_hvac_mode=HVACMode.COOL,
     ),
     DeviceCategory.QN: TuyaClimateEntityDescription(
-        key="",
+        key="qn",
         switch_only_hvac_mode=HVACMode.HEAT,
     ),
     DeviceCategory.RS: TuyaClimateEntityDescription(
-        key="",
+        key="rs",
         switch_only_hvac_mode=HVACMode.HEAT,
     ),
     DeviceCategory.WK: TuyaClimateEntityDescription(
-        key="",
+        key="wk",
         switch_only_hvac_mode=HVACMode.HEAT_COOL,
     ),
     DeviceCategory.WKF: TuyaClimateEntityDescription(
-        key="",
+        key="wkf",
         switch_only_hvac_mode=HVACMode.HEAT,
     ),
 }
@@ -258,7 +258,6 @@ class TuyaClimateEntity(TuyaEntity, ClimateEntity):
 
     entity_description: TuyaClimateEntityDescription
     _attr_name = None
-    _attr_target_temperature_step = 1.0
 
     def __init__(
         self,
@@ -278,7 +277,10 @@ class TuyaClimateEntity(TuyaEntity, ClimateEntity):
         temperature_unit: UnitOfTemperature,
     ) -> None:
         """Determine which values to use."""
-        super().__init__(device, device_manager, description)
+        self._attr_target_temperature_step = 1.0
+        self.entity_description = description
+
+        super().__init__(device, device_manager)
         self._current_humidity_wrapper = current_humidity_wrapper
         self._current_temperature = current_temperature_wrapper
         self._fan_mode_wrapper = fan_mode_wrapper

homeassistant/components/tuya/cover.py

@@ -240,7 +240,9 @@ class TuyaCoverEntity(TuyaEntity, CoverEntity):
         tilt_position: DeviceWrapper[int] | None,
     ) -> None:
         """Init Tuya Cover."""
-        super().__init__(device, device_manager, description)
+        super().__init__(device, device_manager)
+        self.entity_description = description
+        self._attr_unique_id = f"{super().unique_id}{description.key}"
         self._attr_supported_features = CoverEntityFeature(0)
 
         self._current_position = current_position or set_position

homeassistant/components/tuya/entity.py

@@ -9,7 +9,7 @@ from tuya_sharing import CustomerDevice, Manager
 
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
-from homeassistant.helpers.entity import Entity, EntityDescription
+from homeassistant.helpers.entity import Entity
 
 from .const import DOMAIN, LOGGER, TUYA_HA_SIGNAL_UPDATE_ENTITY
 
@@ -20,21 +20,13 @@ class TuyaEntity(Entity):
     _attr_has_entity_name = True
     _attr_should_poll = False
 
-    def __init__(
-        self,
-        device: CustomerDevice,
-        device_manager: Manager,
-        description: EntityDescription | None = None,
-    ) -> None:
+    def __init__(self, device: CustomerDevice, device_manager: Manager) -> None:
         """Init TuyaHaEntity."""
         self._attr_unique_id = f"tuya.{device.id}"
         # TuyaEntity initialize mq can subscribe
         device.set_up = True
         self.device = device
         self.device_manager = device_manager
-        if description:
-            self._attr_unique_id = f"tuya.{device.id}{description.key}"
-            self.entity_description = description
 
     @property
     def device_info(self) -> DeviceInfo:

homeassistant/components/tuya/event.py

@@ -161,7 +161,9 @@ class TuyaEventEntity(TuyaEntity, EventEntity):
         dpcode_wrapper: DeviceWrapper[tuple[str, dict[str, Any] | None]],
     ) -> None:
         """Init Tuya event entity."""
-        super().__init__(device, device_manager, description)
+        super().__init__(device, device_manager)
+        self.entity_description = description
+        self._attr_unique_id = f"{super().unique_id}{description.key}"
         self._dpcode_wrapper = dpcode_wrapper
         self._attr_event_types = dpcode_wrapper.options
 

homeassistant/components/tuya/humidifier.py

@@ -137,7 +137,9 @@ class TuyaHumidifierEntity(TuyaEntity, HumidifierEntity):
         target_humidity_wrapper: DeviceWrapper[int] | None = None,
     ) -> None:
         """Init Tuya (de)humidifier."""
-        super().__init__(device, device_manager, description)
+        super().__init__(device, device_manager)
+        self.entity_description = description
+        self._attr_unique_id = f"{super().unique_id}{description.key}"
 
         self._current_humidity_wrapper = current_humidity_wrapper
         self._mode_wrapper = mode_wrapper

homeassistant/components/tuya/light.py

@@ -529,7 +529,9 @@ class TuyaLightEntity(TuyaEntity, LightEntity):
         switch_wrapper: DeviceWrapper[bool],
     ) -> None:
         """Init TuyaHaLight."""
-        super().__init__(device, device_manager, description)
+        super().__init__(device, device_manager)
+        self.entity_description = description
+        self._attr_unique_id = f"{super().unique_id}{description.key}"
         self._brightness_wrapper = brightness_wrapper
         self._color_data_wrapper = color_data_wrapper
         self._color_mode_wrapper = color_mode_wrapper

homeassistant/components/tuya/number.py

@@ -492,7 +492,9 @@ class TuyaNumberEntity(TuyaEntity, NumberEntity):
         dpcode_wrapper: DeviceWrapper[float],
     ) -> None:
         """Init Tuya sensor."""
-        super().__init__(device, device_manager, description)
+        super().__init__(device, device_manager)
+        self.entity_description = description
+        self._attr_unique_id = f"{super().unique_id}{description.key}"
         self._dpcode_wrapper = dpcode_wrapper
 
         self._attr_native_max_value = dpcode_wrapper.max_value

homeassistant/components/tuya/select.py

@@ -397,7 +397,9 @@ class TuyaSelectEntity(TuyaEntity, SelectEntity):
         dpcode_wrapper: DeviceWrapper[str],
     ) -> None:
         """Init Tuya sensor."""
-        super().__init__(device, device_manager, description)
+        super().__init__(device, device_manager)
+        self.entity_description = description
+        self._attr_unique_id = f"{super().unique_id}{description.key}"
         self._dpcode_wrapper = dpcode_wrapper
         self._attr_options = dpcode_wrapper.options
 

homeassistant/components/tuya/sensor.py

@@ -1684,7 +1684,9 @@ class TuyaSensorEntity(TuyaEntity, SensorEntity):
         dpcode_wrapper: DeviceWrapper[StateType],
     ) -> None:
         """Init Tuya sensor."""
-        super().__init__(device, device_manager, description)
+        super().__init__(device, device_manager)
+        self.entity_description = description
+        self._attr_unique_id = f"{super().unique_id}{description.key}"
         self._dpcode_wrapper = dpcode_wrapper
 
         if description.native_unit_of_measurement is None:

homeassistant/components/tuya/siren.py

@@ -98,7 +98,9 @@ class TuyaSirenEntity(TuyaEntity, SirenEntity):
         dpcode_wrapper: DeviceWrapper[bool],
     ) -> None:
         """Init Tuya Siren."""
-        super().__init__(device, device_manager, description)
+        super().__init__(device, device_manager)
+        self.entity_description = description
+        self._attr_unique_id = f"{super().unique_id}{description.key}"
         self._dpcode_wrapper = dpcode_wrapper
 
     @property

homeassistant/components/tuya/switch.py

@@ -950,7 +950,9 @@ class TuyaSwitchEntity(TuyaEntity, SwitchEntity):
         dpcode_wrapper: DeviceWrapper[bool],
     ) -> None:
         """Init TuyaHaSwitch."""
-        super().__init__(device, device_manager, description)
+        super().__init__(device, device_manager)
+        self.entity_description = description
+        self._attr_unique_id = f"{super().unique_id}{description.key}"
         self._dpcode_wrapper = dpcode_wrapper
 
     @property

homeassistant/components/tuya/valve.py

@@ -126,7 +126,9 @@ class TuyaValveEntity(TuyaEntity, ValveEntity):
         dpcode_wrapper: DeviceWrapper[bool],
     ) -> None:
         """Init TuyaValveEntity."""
-        super().__init__(device, device_manager, description)
+        super().__init__(device, device_manager)
+        self.entity_description = description
+        self._attr_unique_id = f"{super().unique_id}{description.key}"
         self._dpcode_wrapper = dpcode_wrapper
 
     @property

homeassistant/components/unifi_access/__init__.py

@@ -6,7 +6,7 @@ from unifi_access_api import ApiAuthError, ApiConnectionError, UnifiAccessApiCli
 
 from homeassistant.const import CONF_API_TOKEN, CONF_HOST, CONF_VERIFY_SSL, Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
+from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
 from .coordinator import UnifiAccessConfigEntry, UnifiAccessCoordinator
@@ -33,7 +33,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: UnifiAccessConfigEntry)
     try:
         await client.authenticate()
     except ApiAuthError as err:
-        raise ConfigEntryAuthFailed(
+        raise ConfigEntryNotReady(
             f"Authentication failed for UniFi Access at {entry.data[CONF_HOST]}"
         ) from err
     except ApiConnectionError as err:

homeassistant/components/unifi_access/config_flow.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-from collections.abc import Mapping
 import logging
 from typing import Any
 
@@ -67,48 +66,3 @@ class UnifiAccessConfigFlow(ConfigFlow, domain=DOMAIN):
             ),
             errors=errors,
         )
-
-    async def async_step_reauth(
-        self, entry_data: Mapping[str, Any]
-    ) -> ConfigFlowResult:
-        """Handle reauth flow."""
-        return await self.async_step_reauth_confirm()
-
-    async def async_step_reauth_confirm(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle reauth confirm."""
-        errors: dict[str, str] = {}
-        reauth_entry = self._get_reauth_entry()
-
-        if user_input is not None:
-            session = async_get_clientsession(
-                self.hass, verify_ssl=reauth_entry.data[CONF_VERIFY_SSL]
-            )
-            client = UnifiAccessApiClient(
-                host=reauth_entry.data[CONF_HOST],
-                api_token=user_input[CONF_API_TOKEN],
-                session=session,
-                verify_ssl=reauth_entry.data[CONF_VERIFY_SSL],
-            )
-            try:
-                await client.authenticate()
-            except ApiAuthError:
-                errors["base"] = "invalid_auth"
-            except ApiConnectionError:
-                errors["base"] = "cannot_connect"
-            except Exception:
-                _LOGGER.exception("Unexpected exception")
-                errors["base"] = "unknown"
-            else:
-                return self.async_update_reload_and_abort(
-                    reauth_entry,
-                    data_updates={CONF_API_TOKEN: user_input[CONF_API_TOKEN]},
-                )
-
-        return self.async_show_form(
-            step_id="reauth_confirm",
-            data_schema=vol.Schema({vol.Required(CONF_API_TOKEN): str}),
-            description_placeholders={CONF_HOST: reauth_entry.data[CONF_HOST]},
-            errors=errors,
-        )

homeassistant/components/unifi_access/coordinator.py

@@ -30,7 +30,6 @@ from unifi_access_api.models.websocket import (
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback
-from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
 from .const import DOMAIN
@@ -117,7 +116,7 @@ class UnifiAccessCoordinator(DataUpdateCoordinator[UnifiAccessData]):
                     self.client.get_emergency_status(),
                 )
         except ApiAuthError as err:
-            raise ConfigEntryAuthFailed(f"Authentication failed: {err}") from err
+            raise UpdateFailed(f"Authentication failed: {err}") from err
         except ApiConnectionError as err:
             raise UpdateFailed(f"Error connecting to API: {err}") from err
         except ApiError as err:
@@ -212,6 +211,9 @@ class UnifiAccessCoordinator(DataUpdateCoordinator[UnifiAccessData]):
     async def _handle_insights_add(self, msg: WebsocketMessage) -> None:
         """Handle access insights events (entry/exit)."""
         insights = cast(InsightsAdd, msg)
+        door = insights.data.metadata.door
+        if not door.id:
+            return
         event_type = (
             "access_granted" if insights.data.result == "ACCESS" else "access_denied"
         )
@@ -222,9 +224,7 @@ class UnifiAccessCoordinator(DataUpdateCoordinator[UnifiAccessData]):
             attrs["authentication"] = insights.data.metadata.authentication.display_name
         if insights.data.result:
             attrs["result"] = insights.data.result
-        for door in insights.data.metadata.door:
-            if door.id:
-                self._dispatch_door_event(door.id, "access", event_type, attrs)
+        self._dispatch_door_event(door.id, "access", event_type, attrs)
 
     @callback
     def _dispatch_door_event(

homeassistant/components/unifi_access/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "local_push",
   "loggers": ["unifi_access_api"],
   "quality_scale": "bronze",
-  "requirements": ["py-unifi-access==1.1.3"]
+  "requirements": ["py-unifi-access==1.1.0"]
 }

homeassistant/components/unifi_access/quality_scale.yaml

@@ -34,7 +34,7 @@ rules:
   integration-owner: done
   log-when-unavailable: done
   parallel-updates: done
-  reauthentication-flow: done
+  reauthentication-flow: todo
   test-coverage: done
 
   # Gold

homeassistant/components/unifi_access/strings.json

@@ -1,8 +1,7 @@
 {
   "config": {
     "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
     },
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
@@ -10,15 +9,6 @@
       "unknown": "[%key:common::config_flow::error::unknown%]"
     },
     "step": {
-      "reauth_confirm": {
-        "data": {
-          "api_token": "[%key:common::config_flow::data::api_token%]"
-        },
-        "data_description": {
-          "api_token": "[%key:component::unifi_access::config::step::user::data_description::api_token%]"
-        },
-        "description": "The API token for UniFi Access at {host} is invalid. Please provide a new token."
-      },
       "user": {
         "data": {
           "api_token": "[%key:common::config_flow::data::api_token%]",

homeassistant/components/vera/__init__.py

@@ -8,7 +8,9 @@ import logging
 
 import pyvera as veraApi
 from requests.exceptions import RequestException
+import voluptuous as vol
 
+from homeassistant import config_entries
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
     CONF_EXCLUDE,
@@ -19,6 +21,7 @@ from homeassistant.const import (
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.typing import ConfigType
 
 from .common import (
     ControllerData,
@@ -32,7 +35,41 @@ from .const import CONF_CONTROLLER, DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
-CONFIG_SCHEMA = cv.removed(DOMAIN, raise_if_present=False)
+VERA_ID_LIST_SCHEMA = vol.Schema([int])
+
+CONFIG_SCHEMA = vol.Schema(
+    vol.All(
+        cv.deprecated(DOMAIN),
+        {
+            DOMAIN: vol.Schema(
+                {
+                    vol.Required(CONF_CONTROLLER): cv.url,
+                    vol.Optional(CONF_EXCLUDE, default=[]): VERA_ID_LIST_SCHEMA,
+                    vol.Optional(CONF_LIGHTS, default=[]): VERA_ID_LIST_SCHEMA,
+                }
+            )
+        },
+    ),
+    extra=vol.ALLOW_EXTRA,
+)
+
+
+async def async_setup(hass: HomeAssistant, base_config: ConfigType) -> bool:
+    """Set up for Vera controllers."""
+    hass.data[DOMAIN] = {}
+
+    if not (config := base_config.get(DOMAIN)):
+        return True
+
+    hass.async_create_task(
+        hass.config_entries.flow.async_init(
+            DOMAIN,
+            context={"source": config_entries.SOURCE_IMPORT},
+            data=config,
+        )
+    )
+
+    return True
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:

homeassistant/components/vera/common.py

@@ -46,7 +46,7 @@ def set_controller_data(
     hass: HomeAssistant, config_entry: ConfigEntry, data: ControllerData
 ) -> None:
     """Set controller data in hass data."""
-    hass.data.setdefault(DOMAIN, {})[config_entry.entry_id] = data
+    hass.data[DOMAIN][config_entry.entry_id] = data
 
 
 class SubscriptionRegistry(pv.AbstractSubscriptionRegistry):

homeassistant/components/vera/config_flow.py

@@ -12,6 +12,7 @@ from requests.exceptions import RequestException
 import voluptuous as vol
 
 from homeassistant.config_entries import (
+    SOURCE_IMPORT,
     SOURCE_USER,
     ConfigEntry,
     ConfigFlow,
@@ -20,6 +21,7 @@ from homeassistant.config_entries import (
 )
 from homeassistant.const import CONF_EXCLUDE, CONF_LIGHTS, CONF_SOURCE
 from homeassistant.core import callback
+from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.typing import VolDictType
 
 from .const import CONF_CONTROLLER, CONF_LEGACY_UNIQUE_ID, DOMAIN
@@ -129,6 +131,31 @@ class VeraFlowHandler(ConfigFlow, domain=DOMAIN):
             },
         )
 
+    async def async_step_import(self, import_data: dict[str, Any]) -> ConfigFlowResult:
+        """Handle a flow initialized by import."""
+
+        # If there are entities with the legacy unique_id, then this imported config
+        # should also use the legacy unique_id for entity creation.
+        entity_registry = er.async_get(self.hass)
+        use_legacy_unique_id = (
+            len(
+                [
+                    entry
+                    for entry in entity_registry.entities.values()
+                    if entry.platform == DOMAIN and entry.unique_id.isdigit()
+                ]
+            )
+            > 0
+        )
+
+        return await self.async_step_finish(
+            {
+                **import_data,
+                CONF_SOURCE: SOURCE_IMPORT,
+                CONF_LEGACY_UNIQUE_ID: use_legacy_unique_id,
+            }
+        )
+
     async def async_step_finish(self, config: dict[str, Any]) -> ConfigFlowResult:
         """Validate and create config entry."""
         base_url = config[CONF_CONTROLLER] = config[CONF_CONTROLLER].rstrip("/")