Add media_player.muted trigger

Implements a trigger that fires when a cover's position changes. Supports:
- Monitoring current_position attribute (0-100 range)
- Optional threshold filters: lower, upper, above, below
- Device class filtering (curtain, shutter, blind)
- Provides from_position and to_position in trigger data

.github/workflows/ci.yaml

@@ -37,7 +37,7 @@ on:
         type: boolean
 
 env:
-  CACHE_VERSION: 2
+  CACHE_VERSION: 1
   UV_CACHE_VERSION: 1
   MYPY_CACHE_VERSION: 1
   HA_SHORT_VERSION: "2025.12"

homeassistant/components/alarm_control_panel/strings.json

@@ -143,5 +143,28 @@
       "name": "Trigger"
     }
   },
-  "title": "Alarm control panel"
+  "title": "Alarm control panel",
+  "triggers": {
+    "armed": {
+      "description": "Triggers when an alarm is armed.",
+      "description_configured": "Triggers when an alarm is armed",
+      "fields": {
+        "mode": {
+          "description": "The arm modes to trigger on. If empty, triggers on all arm modes.",
+          "name": "Arm modes"
+        }
+      },
+      "name": "When an alarm is armed"
+    },
+    "disarmed": {
+      "description": "Triggers when an alarm is disarmed.",
+      "description_configured": "Triggers when an alarm is disarmed",
+      "name": "When an alarm is disarmed"
+    },
+    "triggered": {
+      "description": "Triggers when an alarm is triggered.",
+      "description_configured": "Triggers when an alarm is triggered",
+      "name": "When an alarm is triggered"
+    }
+  }
 }

homeassistant/components/alarm_control_panel/trigger.py

@@ -0,0 +1,283 @@
+"""Provides triggers for alarm control panels."""
+
+from typing import TYPE_CHECKING, cast, override
+
+import voluptuous as vol
+
+from homeassistant.const import (
+    ATTR_ENTITY_ID,
+    CONF_OPTIONS,
+    CONF_TARGET,
+    STATE_UNAVAILABLE,
+)
+from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback, split_entity_id
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.target import (
+    TargetStateChangedData,
+    async_track_target_selector_state_change_event,
+)
+from homeassistant.helpers.trigger import Trigger, TriggerActionRunner, TriggerConfig
+from homeassistant.helpers.typing import ConfigType
+
+from .const import DOMAIN, AlarmControlPanelState
+
+CONF_MODE = "mode"
+
+ARMED_TRIGGER_SCHEMA = vol.Schema(
+    {
+        vol.Optional(CONF_OPTIONS, default={}): {
+            vol.Optional(CONF_MODE, default=[]): vol.All(
+                cv.ensure_list,
+                [
+                    vol.In(
+                        [
+                            AlarmControlPanelState.ARMED_HOME,
+                            AlarmControlPanelState.ARMED_AWAY,
+                            AlarmControlPanelState.ARMED_NIGHT,
+                            AlarmControlPanelState.ARMED_VACATION,
+                            AlarmControlPanelState.ARMED_CUSTOM_BYPASS,
+                        ]
+                    )
+                ],
+            ),
+        },
+        vol.Required(CONF_TARGET): cv.TARGET_FIELDS,
+    }
+)
+
+DISARMED_TRIGGER_SCHEMA = vol.Schema(
+    {
+        vol.Optional(CONF_OPTIONS, default={}): {},
+        vol.Required(CONF_TARGET): cv.TARGET_FIELDS,
+    }
+)
+
+TRIGGERED_TRIGGER_SCHEMA = vol.Schema(
+    {
+        vol.Optional(CONF_OPTIONS, default={}): {},
+        vol.Required(CONF_TARGET): cv.TARGET_FIELDS,
+    }
+)
+
+
+class AlarmArmedTrigger(Trigger):
+    """Trigger for when an alarm control panel is armed."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, ARMED_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the alarm armed trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.options is not None
+            assert config.target is not None
+        self._options = config.options
+        self._target = config.target
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+        mode_filter = self._options[CONF_MODE]
+
+        # All armed states
+        armed_states = {
+            AlarmControlPanelState.ARMED_HOME,
+            AlarmControlPanelState.ARMED_AWAY,
+            AlarmControlPanelState.ARMED_NIGHT,
+            AlarmControlPanelState.ARMED_VACATION,
+            AlarmControlPanelState.ARMED_CUSTOM_BYPASS,
+        }
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Check if the new state is an armed state
+            if to_state.state not in armed_states:
+                return
+
+            # If mode filter is specified, check if the mode matches
+            if mode_filter and to_state.state not in mode_filter:
+                return
+
+            run_action(
+                {
+                    ATTR_ENTITY_ID: entity_id,
+                    "from_state": from_state,
+                    "to_state": to_state,
+                },
+                f"alarm armed on {entity_id}",
+                event.context,
+            )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+class AlarmDisarmedTrigger(Trigger):
+    """Trigger for when an alarm control panel is disarmed."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, DISARMED_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the alarm disarmed trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.target is not None
+        self._target = config.target
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Check if the new state is disarmed
+            if to_state.state != AlarmControlPanelState.DISARMED:
+                return
+
+            run_action(
+                {
+                    ATTR_ENTITY_ID: entity_id,
+                    "from_state": from_state,
+                    "to_state": to_state,
+                },
+                f"alarm disarmed on {entity_id}",
+                event.context,
+            )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+class AlarmTriggeredTrigger(Trigger):
+    """Trigger for when an alarm control panel is triggered."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, TRIGGERED_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the alarm triggered trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.target is not None
+        self._target = config.target
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Check if the new state is triggered
+            if to_state.state != AlarmControlPanelState.TRIGGERED:
+                return
+
+            run_action(
+                {
+                    ATTR_ENTITY_ID: entity_id,
+                    "from_state": from_state,
+                    "to_state": to_state,
+                },
+                f"alarm triggered on {entity_id}",
+                event.context,
+            )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "armed": AlarmArmedTrigger,
+    "disarmed": AlarmDisarmedTrigger,
+    "triggered": AlarmTriggeredTrigger,
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for alarm control panels."""
+    return TRIGGERS

homeassistant/components/alarm_control_panel/triggers.yaml

@@ -0,0 +1,30 @@
+armed:
+  target:
+    entity:
+      domain: alarm_control_panel
+  fields:
+    mode:
+      required: false
+      default: []
+      selector:
+        select:
+          multiple: true
+          options:
+            - value: armed_home
+              label: Home
+            - value: armed_away
+              label: Away
+            - value: armed_night
+              label: Night
+            - value: armed_vacation
+              label: Vacation
+            - value: armed_custom_bypass
+              label: Custom bypass
+disarmed:
+  target:
+    entity:
+      domain: alarm_control_panel
+triggered:
+  target:
+    entity:
+      domain: alarm_control_panel

homeassistant/components/assist_satellite/strings.json

@@ -98,5 +98,27 @@
       "name": "Start conversation"
     }
   },
-  "title": "Assist satellite"
+  "title": "Assist satellite",
+  "triggers": {
+    "listening": {
+      "description": "Triggers when a satellite starts listening for a command.",
+      "description_configured": "Triggers when a satellite starts listening for a command",
+      "name": "When a satellite starts listening"
+    },
+    "processing": {
+      "description": "Triggers when a satellite starts processing a command.",
+      "description_configured": "Triggers when a satellite starts processing a command",
+      "name": "When a satellite starts processing"
+    },
+    "responding": {
+      "description": "Triggers when a satellite starts responding to a command.",
+      "description_configured": "Triggers when a satellite starts responding to a command",
+      "name": "When a satellite starts responding"
+    },
+    "idle": {
+      "description": "Triggers when a satellite goes back to idle.",
+      "description_configured": "Triggers when a satellite goes back to idle",
+      "name": "When a satellite goes back to idle"
+    }
+  }
 }

homeassistant/components/assist_satellite/trigger.py

@@ -0,0 +1,140 @@
+"""Provides triggers for assist satellites."""
+
+from typing import TYPE_CHECKING, cast, override
+
+import voluptuous as vol
+
+from homeassistant.const import (
+    ATTR_ENTITY_ID,
+    CONF_TARGET,
+    STATE_UNAVAILABLE,
+)
+from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback, split_entity_id
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.event import process_state_match
+from homeassistant.helpers.target import (
+    TargetStateChangedData,
+    async_track_target_selector_state_change_event,
+)
+from homeassistant.helpers.trigger import Trigger, TriggerActionRunner, TriggerConfig
+from homeassistant.helpers.typing import ConfigType
+
+from .const import DOMAIN
+
+STATE_TRIGGER_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_TARGET): cv.TARGET_FIELDS,
+    }
+)
+
+
+class StateTriggerBase(Trigger):
+    """Trigger for assist satellite state changes."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, STATE_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig, state: str) -> None:
+        """Initialize the state trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.target is not None
+        self._target = config.target
+        self._state = state
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+        match_config_state = process_state_match(self._state)
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Check if the new state matches the trigger state
+            if not match_config_state(to_state.state):
+                return
+
+            run_action(
+                {
+                    ATTR_ENTITY_ID: entity_id,
+                    "from_state": from_state,
+                    "to_state": to_state,
+                },
+                f"{entity_id} {self._state}",
+                event.context,
+            )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+class ListeningTrigger(StateTriggerBase):
+    """Trigger for when a satellite starts listening."""
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the listening trigger."""
+        super().__init__(hass, config, "listening")
+
+
+class ProcessingTrigger(StateTriggerBase):
+    """Trigger for when a satellite starts processing."""
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the processing trigger."""
+        super().__init__(hass, config, "processing")
+
+
+class RespondingTrigger(StateTriggerBase):
+    """Trigger for when a satellite starts responding."""
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the responding trigger."""
+        super().__init__(hass, config, "responding")
+
+
+class IdleTrigger(StateTriggerBase):
+    """Trigger for when a satellite goes back to idle."""
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the idle trigger."""
+        super().__init__(hass, config, "idle")
+
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "listening": ListeningTrigger,
+    "processing": ProcessingTrigger,
+    "responding": RespondingTrigger,
+    "idle": IdleTrigger,
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for assist satellites."""
+    return TRIGGERS

homeassistant/components/assist_satellite/triggers.yaml

@@ -0,0 +1,19 @@
+listening:
+  target:
+    entity:
+      domain: assist_satellite
+
+processing:
+  target:
+    entity:
+      domain: assist_satellite
+
+responding:
+  target:
+    entity:
+      domain: assist_satellite
+
+idle:
+  target:
+    entity:
+      domain: assist_satellite

homeassistant/components/climate/strings.json

@@ -285,5 +285,93 @@
       "name": "[%key:common::action::turn_on%]"
     }
   },
-  "title": "Climate"
+  "title": "Climate",
+  "triggers": {
+    "cooling": {
+      "description": "Triggers when a climate starts cooling.",
+      "name": "When a climate starts cooling"
+    },
+    "current_humidity_changed": {
+      "description": "Triggers when the current humidity of a climate changes.",
+      "fields": {
+        "above": {
+          "description": "Only trigger when the current humidity goes above this value.",
+          "name": "Above"
+        },
+        "below": {
+          "description": "Only trigger when the current humidity goes below this value.",
+          "name": "Below"
+        }
+      },
+      "name": "When current humidity changes"
+    },
+    "current_temperature_changed": {
+      "description": "Triggers when the current temperature of a climate changes.",
+      "fields": {
+        "above": {
+          "description": "Only trigger when the current temperature goes above this value.",
+          "name": "Above"
+        },
+        "below": {
+          "description": "Only trigger when the current temperature goes below this value.",
+          "name": "Below"
+        }
+      },
+      "name": "When current temperature changes"
+    },
+    "drying": {
+      "description": "Triggers when a climate starts drying.",
+      "name": "When a climate starts drying"
+    },
+    "heating": {
+      "description": "Triggers when a climate starts heating.",
+      "name": "When a climate starts heating"
+    },
+    "mode_changed": {
+      "description": "Triggers when the HVAC mode of a climate changes.",
+      "fields": {
+        "hvac_mode": {
+          "description": "The HVAC modes to trigger on. If empty, triggers on all mode changes.",
+          "name": "HVAC modes"
+        }
+      },
+      "name": "When HVAC mode changes"
+    },
+    "target_humidity_changed": {
+      "description": "Triggers when the target humidity of a climate changes.",
+      "fields": {
+        "above": {
+          "description": "Only trigger when the target humidity goes above this value.",
+          "name": "Above"
+        },
+        "below": {
+          "description": "Only trigger when the target humidity goes below this value.",
+          "name": "Below"
+        }
+      },
+      "name": "When target humidity changes"
+    },
+    "target_temperature_changed": {
+      "description": "Triggers when the target temperature of a climate changes.",
+      "fields": {
+        "above": {
+          "description": "Only trigger when the target temperature goes above this value.",
+          "name": "Above"
+        },
+        "below": {
+          "description": "Only trigger when the target temperature goes below this value.",
+          "name": "Below"
+        }
+      },
+      "name": "When target temperature changes"
+    },
+    "turns_off": {
+      "description": "Triggers when a climate turns off.",
+      "name": "When a climate turns off"
+    },
+    "turns_on": {
+      "description": "Triggers when a climate turns on.",
+      "name": "When a climate turns on"
+    }
+  }
 }

homeassistant/components/climate/trigger.py

@@ -0,0 +1,817 @@
+"""Provides triggers for climate."""
+
+from typing import TYPE_CHECKING, cast, override
+
+import voluptuous as vol
+
+from homeassistant.const import (
+    ATTR_ENTITY_ID,
+    ATTR_TEMPERATURE,
+    CONF_ABOVE,
+    CONF_BELOW,
+    CONF_OPTIONS,
+    CONF_TARGET,
+    STATE_UNAVAILABLE,
+)
+from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback, split_entity_id
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.target import (
+    TargetStateChangedData,
+    async_track_target_selector_state_change_event,
+)
+from homeassistant.helpers.trigger import Trigger, TriggerActionRunner, TriggerConfig
+from homeassistant.helpers.typing import ConfigType
+
+from .const import (
+    ATTR_CURRENT_HUMIDITY,
+    ATTR_CURRENT_TEMPERATURE,
+    ATTR_HUMIDITY,
+    ATTR_HVAC_ACTION,
+    ATTR_HVAC_MODE,
+    DOMAIN,
+    HVAC_MODES,
+    HVACMode,
+)
+
+CLIMATE_TRIGGER_SCHEMA = vol.Schema(
+    {
+        vol.Optional(CONF_OPTIONS, default={}): {},
+        vol.Required(CONF_TARGET): cv.TARGET_FIELDS,
+    }
+)
+
+MODE_CHANGED_TRIGGER_SCHEMA = vol.Schema(
+    {
+        vol.Optional(CONF_OPTIONS, default={}): {
+            vol.Optional(ATTR_HVAC_MODE, default=[]): vol.All(
+                cv.ensure_list, [vol.In(HVAC_MODES)]
+            ),
+        },
+        vol.Required(CONF_TARGET): cv.TARGET_FIELDS,
+    }
+)
+
+THRESHOLD_TRIGGER_SCHEMA = vol.Schema(
+    {
+        vol.Optional(CONF_OPTIONS, default={}): {
+            vol.Optional(CONF_ABOVE): vol.Coerce(float),
+            vol.Optional(CONF_BELOW): vol.Coerce(float),
+        },
+        vol.Required(CONF_TARGET): cv.TARGET_FIELDS,
+    }
+)
+
+
+class ClimateTurnsOnTrigger(Trigger):
+    """Trigger for when a climate turns on."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, CLIMATE_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the climate turns on trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.options is not None
+            assert config.target is not None
+        self._options = config.options
+        self._target = config.target
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Check if climate turned on (from off to any other mode)
+            if (
+                from_state is not None
+                and from_state.state == HVACMode.OFF
+                and to_state.state != HVACMode.OFF
+            ):
+                run_action(
+                    {
+                        ATTR_ENTITY_ID: entity_id,
+                        "from_state": from_state,
+                        "to_state": to_state,
+                    },
+                    f"climate {entity_id} turned on",
+                    event.context,
+                )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+class ClimateTurnsOffTrigger(Trigger):
+    """Trigger for when a climate turns off."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, CLIMATE_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the climate turns off trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.options is not None
+            assert config.target is not None
+        self._options = config.options
+        self._target = config.target
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Check if climate turned off (from any mode to off)
+            if (
+                from_state is not None
+                and from_state.state != HVACMode.OFF
+                and to_state.state == HVACMode.OFF
+            ):
+                run_action(
+                    {
+                        ATTR_ENTITY_ID: entity_id,
+                        "from_state": from_state,
+                        "to_state": to_state,
+                    },
+                    f"climate {entity_id} turned off",
+                    event.context,
+                )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+class ClimateModeChangedTrigger(Trigger):
+    """Trigger for when a climate mode changes."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, MODE_CHANGED_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the climate mode changed trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.options is not None
+            assert config.target is not None
+        self._options = config.options
+        self._target = config.target
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+        hvac_modes_filter = self._options[ATTR_HVAC_MODE]
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Check if hvac_mode changed
+            if from_state is not None and from_state.state != to_state.state:
+                # If hvac_modes filter is specified, check if the new mode matches
+                if hvac_modes_filter and to_state.state not in hvac_modes_filter:
+                    return
+
+                run_action(
+                    {
+                        ATTR_ENTITY_ID: entity_id,
+                        "from_state": from_state,
+                        "to_state": to_state,
+                    },
+                    f"climate {entity_id} mode changed to {to_state.state}",
+                    event.context,
+                )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+class ClimateCoolingTrigger(Trigger):
+    """Trigger for when a climate starts cooling."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, CLIMATE_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the climate cooling trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.options is not None
+            assert config.target is not None
+        self._options = config.options
+        self._target = config.target
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Check if climate started cooling
+            from_action = from_state.attributes.get(ATTR_HVAC_ACTION) if from_state else None
+            to_action = to_state.attributes.get(ATTR_HVAC_ACTION)
+
+            if from_action != "cooling" and to_action == "cooling":
+                run_action(
+                    {
+                        ATTR_ENTITY_ID: entity_id,
+                        "from_state": from_state,
+                        "to_state": to_state,
+                    },
+                    f"climate {entity_id} started cooling",
+                    event.context,
+                )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+class ClimateHeatingTrigger(Trigger):
+    """Trigger for when a climate starts heating."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, CLIMATE_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the climate heating trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.options is not None
+            assert config.target is not None
+        self._options = config.options
+        self._target = config.target
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Check if climate started heating
+            from_action = from_state.attributes.get(ATTR_HVAC_ACTION) if from_state else None
+            to_action = to_state.attributes.get(ATTR_HVAC_ACTION)
+
+            if from_action != "heating" and to_action == "heating":
+                run_action(
+                    {
+                        ATTR_ENTITY_ID: entity_id,
+                        "from_state": from_state,
+                        "to_state": to_state,
+                    },
+                    f"climate {entity_id} started heating",
+                    event.context,
+                )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+class ClimateDryingTrigger(Trigger):
+    """Trigger for when a climate starts drying."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, CLIMATE_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the climate drying trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.options is not None
+            assert config.target is not None
+        self._options = config.options
+        self._target = config.target
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Check if climate started drying
+            from_action = from_state.attributes.get(ATTR_HVAC_ACTION) if from_state else None
+            to_action = to_state.attributes.get(ATTR_HVAC_ACTION)
+
+            if from_action != "drying" and to_action == "drying":
+                run_action(
+                    {
+                        ATTR_ENTITY_ID: entity_id,
+                        "from_state": from_state,
+                        "to_state": to_state,
+                    },
+                    f"climate {entity_id} started drying",
+                    event.context,
+                )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+class ClimateTargetTemperatureChangedTrigger(Trigger):
+    """Trigger for when a climate target temperature changes."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, THRESHOLD_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the climate target temperature changed trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.options is not None
+            assert config.target is not None
+        self._options = config.options
+        self._target = config.target
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+        above = self._options.get(CONF_ABOVE)
+        below = self._options.get(CONF_BELOW)
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Check if target temperature changed
+            from_temp = (
+                from_state.attributes.get(ATTR_TEMPERATURE) if from_state else None
+            )
+            to_temp = to_state.attributes.get(ATTR_TEMPERATURE)
+
+            if to_temp is None or from_temp == to_temp:
+                return
+
+            # Apply threshold filters if specified
+            if above is not None and to_temp <= above:
+                return
+            if below is not None and to_temp >= below:
+                return
+
+            run_action(
+                {
+                    ATTR_ENTITY_ID: entity_id,
+                    "from_state": from_state,
+                    "to_state": to_state,
+                },
+                f"climate {entity_id} target temperature changed to {to_temp}",
+                event.context,
+            )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+class ClimateCurrentTemperatureChangedTrigger(Trigger):
+    """Trigger for when a climate current temperature changes."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, THRESHOLD_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the climate current temperature changed trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.options is not None
+            assert config.target is not None
+        self._options = config.options
+        self._target = config.target
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+        above = self._options.get(CONF_ABOVE)
+        below = self._options.get(CONF_BELOW)
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Check if current temperature changed
+            from_temp = (
+                from_state.attributes.get(ATTR_CURRENT_TEMPERATURE)
+                if from_state
+                else None
+            )
+            to_temp = to_state.attributes.get(ATTR_CURRENT_TEMPERATURE)
+
+            if to_temp is None or from_temp == to_temp:
+                return
+
+            # Apply threshold filters if specified
+            if above is not None and to_temp <= above:
+                return
+            if below is not None and to_temp >= below:
+                return
+
+            run_action(
+                {
+                    ATTR_ENTITY_ID: entity_id,
+                    "from_state": from_state,
+                    "to_state": to_state,
+                },
+                f"climate {entity_id} current temperature changed to {to_temp}",
+                event.context,
+            )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+class ClimateTargetHumidityChangedTrigger(Trigger):
+    """Trigger for when a climate target humidity changes."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, THRESHOLD_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the climate target humidity changed trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.options is not None
+            assert config.target is not None
+        self._options = config.options
+        self._target = config.target
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+        above = self._options.get(CONF_ABOVE)
+        below = self._options.get(CONF_BELOW)
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Check if target humidity changed
+            from_humidity = (
+                from_state.attributes.get(ATTR_HUMIDITY) if from_state else None
+            )
+            to_humidity = to_state.attributes.get(ATTR_HUMIDITY)
+
+            if to_humidity is None or from_humidity == to_humidity:
+                return
+
+            # Apply threshold filters if specified
+            if above is not None and to_humidity <= above:
+                return
+            if below is not None and to_humidity >= below:
+                return
+
+            run_action(
+                {
+                    ATTR_ENTITY_ID: entity_id,
+                    "from_state": from_state,
+                    "to_state": to_state,
+                },
+                f"climate {entity_id} target humidity changed to {to_humidity}",
+                event.context,
+            )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+class ClimateCurrentHumidityChangedTrigger(Trigger):
+    """Trigger for when a climate current humidity changes."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, THRESHOLD_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the climate current humidity changed trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.options is not None
+            assert config.target is not None
+        self._options = config.options
+        self._target = config.target
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+        above = self._options.get(CONF_ABOVE)
+        below = self._options.get(CONF_BELOW)
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Check if current humidity changed
+            from_humidity = (
+                from_state.attributes.get(ATTR_CURRENT_HUMIDITY)
+                if from_state
+                else None
+            )
+            to_humidity = to_state.attributes.get(ATTR_CURRENT_HUMIDITY)
+
+            if to_humidity is None or from_humidity == to_humidity:
+                return
+
+            # Apply threshold filters if specified
+            if above is not None and to_humidity <= above:
+                return
+            if below is not None and to_humidity >= below:
+                return
+
+            run_action(
+                {
+                    ATTR_ENTITY_ID: entity_id,
+                    "from_state": from_state,
+                    "to_state": to_state,
+                },
+                f"climate {entity_id} current humidity changed to {to_humidity}",
+                event.context,
+            )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "turns_on": ClimateTurnsOnTrigger,
+    "turns_off": ClimateTurnsOffTrigger,
+    "mode_changed": ClimateModeChangedTrigger,
+    "cooling": ClimateCoolingTrigger,
+    "heating": ClimateHeatingTrigger,
+    "drying": ClimateDryingTrigger,
+    "target_temperature_changed": ClimateTargetTemperatureChangedTrigger,
+    "current_temperature_changed": ClimateCurrentTemperatureChangedTrigger,
+    "target_humidity_changed": ClimateTargetHumidityChangedTrigger,
+    "current_humidity_changed": ClimateCurrentHumidityChangedTrigger,
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for climate."""
+    return TRIGGERS

homeassistant/components/climate/triggers.yaml

@@ -0,0 +1,128 @@
+turns_on:
+  target:
+    entity:
+      domain: climate
+
+turns_off:
+  target:
+    entity:
+      domain: climate
+
+mode_changed:
+  target:
+    entity:
+      domain: climate
+  fields:
+    hvac_mode:
+      required: false
+      default: []
+      selector:
+        select:
+          multiple: true
+          mode: dropdown
+          options:
+            - label: "Off"
+              value: "off"
+            - label: "Heat"
+              value: "heat"
+            - label: "Cool"
+              value: "cool"
+            - label: "Heat/Cool"
+              value: "heat_cool"
+            - label: "Auto"
+              value: "auto"
+            - label: "Dry"
+              value: "dry"
+            - label: "Fan only"
+              value: "fan_only"
+
+cooling:
+  target:
+    entity:
+      domain: climate
+
+heating:
+  target:
+    entity:
+      domain: climate
+
+drying:
+  target:
+    entity:
+      domain: climate
+
+target_temperature_changed:
+  target:
+    entity:
+      domain: climate
+  fields:
+    above:
+      required: false
+      selector:
+        number:
+          mode: box
+          step: 0.1
+    below:
+      required: false
+      selector:
+        number:
+          mode: box
+          step: 0.1
+
+current_temperature_changed:
+  target:
+    entity:
+      domain: climate
+  fields:
+    above:
+      required: false
+      selector:
+        number:
+          mode: box
+          step: 0.1
+    below:
+      required: false
+      selector:
+        number:
+          mode: box
+          step: 0.1
+
+target_humidity_changed:
+  target:
+    entity:
+      domain: climate
+  fields:
+    above:
+      required: false
+      selector:
+        number:
+          mode: box
+          min: 0
+          max: 100
+    below:
+      required: false
+      selector:
+        number:
+          mode: box
+          min: 0
+          max: 100
+
+current_humidity_changed:
+  target:
+    entity:
+      domain: climate
+  fields:
+    above:
+      required: false
+      selector:
+        number:
+          mode: box
+          min: 0
+          max: 100
+    below:
+      required: false
+      selector:
+        number:
+          mode: box
+          min: 0
+          max: 100

homeassistant/components/cover/strings.json

@@ -136,5 +136,75 @@
       "name": "Toggle tilt"
     }
   },
-  "title": "Cover"
+  "title": "Cover",
+  "triggers": {
+    "opens": {
+      "description": "Triggers when a cover opens.",
+      "description_configured": "Triggers when a cover opens",
+      "fields": {
+        "fully_opened": {
+          "description": "Only trigger when the cover is fully opened (position at 100%).",
+          "name": "Fully opened"
+        },
+        "device_class": {
+          "description": "The device classes to trigger on. If empty, triggers on all device classes.",
+          "name": "Device classes"
+        }
+      },
+      "name": "When a cover opens"
+    },
+    "closes": {
+      "description": "Triggers when a cover closes.",
+      "description_configured": "Triggers when a cover closes",
+      "fields": {
+        "fully_closed": {
+          "description": "Only trigger when the cover is fully closed (position at 0%).",
+          "name": "Fully closed"
+        },
+        "device_class": {
+          "description": "The device classes to trigger on. If empty, triggers on all device classes.",
+          "name": "Device classes"
+        }
+      },
+      "name": "When a cover closes"
+    },
+    "stops": {
+      "description": "Triggers when a cover stops moving.",
+      "description_configured": "Triggers when a cover stops moving",
+      "fields": {
+        "device_class": {
+          "description": "The device classes to trigger on. If empty, triggers on all device classes.",
+          "name": "Device classes"
+        }
+      },
+      "name": "When a cover stops moving"
+    },
+    "position_changed": {
+      "description": "Triggers when the position of a cover changes.",
+      "description_configured": "Triggers when the position of a cover changes",
+      "fields": {
+        "lower": {
+          "description": "The minimum position value to trigger on. Only triggers when position is at or above this value.",
+          "name": "Lower limit"
+        },
+        "upper": {
+          "description": "The maximum position value to trigger on. Only triggers when position is at or below this value.",
+          "name": "Upper limit"
+        },
+        "above": {
+          "description": "Only trigger when position is above this value.",
+          "name": "Above"
+        },
+        "below": {
+          "description": "Only trigger when position is below this value.",
+          "name": "Below"
+        },
+        "device_class": {
+          "description": "The device classes to trigger on. If empty, triggers on all device classes.",
+          "name": "Device classes"
+        }
+      },
+      "name": "When the position of a cover changes"
+    }
+  }
 }

homeassistant/components/cover/trigger.py

@@ -0,0 +1,453 @@
+"""Provides triggers for covers."""
+
+from typing import TYPE_CHECKING, cast, override
+
+import voluptuous as vol
+
+from homeassistant.const import (
+    ATTR_ENTITY_ID,
+    CONF_DEVICE_CLASS,
+    CONF_OPTIONS,
+    CONF_TARGET,
+    STATE_UNAVAILABLE,
+)
+from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback, split_entity_id
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.target import (
+    TargetStateChangedData,
+    async_track_target_selector_state_change_event,
+)
+from homeassistant.helpers.trigger import Trigger, TriggerActionRunner, TriggerConfig
+from homeassistant.helpers.typing import ConfigType
+
+from . import ATTR_CURRENT_POSITION, CoverDeviceClass, CoverState
+from .const import DOMAIN
+
+CONF_LOWER = "lower"
+CONF_UPPER = "upper"
+CONF_ABOVE = "above"
+CONF_BELOW = "below"
+CONF_FULLY_OPENED = "fully_opened"
+CONF_FULLY_CLOSED = "fully_closed"
+
+OPENS_TRIGGER_SCHEMA = vol.Schema(
+    {
+        vol.Optional(CONF_OPTIONS, default={}): {
+            vol.Optional(CONF_FULLY_OPENED, default=False): cv.boolean,
+            vol.Optional(CONF_DEVICE_CLASS, default=[]): vol.All(
+                cv.ensure_list, [vol.Coerce(CoverDeviceClass)]
+            ),
+        },
+        vol.Required(CONF_TARGET): cv.TARGET_FIELDS,
+    }
+)
+
+CLOSES_TRIGGER_SCHEMA = vol.Schema(
+    {
+        vol.Optional(CONF_OPTIONS, default={}): {
+            vol.Optional(CONF_FULLY_CLOSED, default=False): cv.boolean,
+            vol.Optional(CONF_DEVICE_CLASS, default=[]): vol.All(
+                cv.ensure_list, [vol.Coerce(CoverDeviceClass)]
+            ),
+        },
+        vol.Required(CONF_TARGET): cv.TARGET_FIELDS,
+    }
+)
+
+STOPS_TRIGGER_SCHEMA = vol.Schema(
+    {
+        vol.Optional(CONF_OPTIONS, default={}): {
+            vol.Optional(CONF_DEVICE_CLASS, default=[]): vol.All(
+                cv.ensure_list, [vol.Coerce(CoverDeviceClass)]
+            ),
+        },
+        vol.Required(CONF_TARGET): cv.TARGET_FIELDS,
+    }
+)
+
+POSITION_CHANGED_TRIGGER_SCHEMA = vol.Schema(
+    {
+        vol.Optional(CONF_OPTIONS, default={}): {
+            vol.Exclusive(CONF_LOWER, "position_range"): vol.All(
+                vol.Coerce(int), vol.Range(min=0, max=100)
+            ),
+            vol.Exclusive(CONF_UPPER, "position_range"): vol.All(
+                vol.Coerce(int), vol.Range(min=0, max=100)
+            ),
+            vol.Exclusive(CONF_ABOVE, "position_range"): vol.All(
+                vol.Coerce(int), vol.Range(min=0, max=100)
+            ),
+            vol.Exclusive(CONF_BELOW, "position_range"): vol.All(
+                vol.Coerce(int), vol.Range(min=0, max=100)
+            ),
+            vol.Optional(CONF_DEVICE_CLASS, default=[]): vol.All(
+                cv.ensure_list, [vol.Coerce(CoverDeviceClass)]
+            ),
+        },
+        vol.Required(CONF_TARGET): cv.TARGET_FIELDS,
+    }
+)
+
+
+class CoverOpensTrigger(Trigger):
+    """Trigger for when a cover opens."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, OPENS_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the cover opens trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.target is not None
+            assert config.options is not None
+        self._target = config.target
+        self._options = config.options
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+        fully_opened = self._options[CONF_FULLY_OPENED]
+        device_classes_filter = self._options[CONF_DEVICE_CLASS]
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Filter by device class if specified
+            if device_classes_filter:
+                device_class = to_state.attributes.get(CONF_DEVICE_CLASS)
+                if device_class not in device_classes_filter:
+                    return
+
+            # Trigger when cover opens or is opening
+            if to_state.state in (CoverState.OPEN, CoverState.OPENING):
+                # If fully_opened is True, only trigger when position reaches 100
+                if fully_opened:
+                    current_position = to_state.attributes.get(ATTR_CURRENT_POSITION)
+                    if current_position != 100:
+                        return
+
+                # Only trigger on state change, not if already in that state
+                if from_state and from_state.state == to_state.state:
+                    # For fully_opened, allow triggering when position changes to 100
+                    if fully_opened:
+                        from_position = from_state.attributes.get(ATTR_CURRENT_POSITION)
+                        to_position = to_state.attributes.get(ATTR_CURRENT_POSITION)
+                        if from_position == to_position:
+                            return
+                    else:
+                        return
+
+                run_action(
+                    {
+                        ATTR_ENTITY_ID: entity_id,
+                        "from_state": from_state,
+                        "to_state": to_state,
+                    },
+                    f"cover opened on {entity_id}",
+                    event.context,
+                )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+class CoverClosesTrigger(Trigger):
+    """Trigger for when a cover closes."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, CLOSES_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the cover closes trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.target is not None
+            assert config.options is not None
+        self._target = config.target
+        self._options = config.options
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+        fully_closed = self._options[CONF_FULLY_CLOSED]
+        device_classes_filter = self._options[CONF_DEVICE_CLASS]
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Filter by device class if specified
+            if device_classes_filter:
+                device_class = to_state.attributes.get(CONF_DEVICE_CLASS)
+                if device_class not in device_classes_filter:
+                    return
+
+            # Trigger when cover closes or is closing
+            if to_state.state in (CoverState.CLOSED, CoverState.CLOSING):
+                # If fully_closed is True, only trigger when position reaches 0
+                if fully_closed:
+                    current_position = to_state.attributes.get(ATTR_CURRENT_POSITION)
+                    if current_position != 0:
+                        return
+
+                # Only trigger on state change, not if already in that state
+                if from_state and from_state.state == to_state.state:
+                    # For fully_closed, allow triggering when position changes to 0
+                    if fully_closed:
+                        from_position = from_state.attributes.get(ATTR_CURRENT_POSITION)
+                        to_position = to_state.attributes.get(ATTR_CURRENT_POSITION)
+                        if from_position == to_position:
+                            return
+                    else:
+                        return
+
+                run_action(
+                    {
+                        ATTR_ENTITY_ID: entity_id,
+                        "from_state": from_state,
+                        "to_state": to_state,
+                    },
+                    f"cover closed on {entity_id}",
+                    event.context,
+                )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+class CoverStopsTrigger(Trigger):
+    """Trigger for when a cover stops moving."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, STOPS_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the cover stops trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.target is not None
+            assert config.options is not None
+        self._target = config.target
+        self._options = config.options
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+        device_classes_filter = self._options[CONF_DEVICE_CLASS]
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Filter by device class if specified
+            if device_classes_filter:
+                device_class = to_state.attributes.get(CONF_DEVICE_CLASS)
+                if device_class not in device_classes_filter:
+                    return
+
+            # Trigger when cover stops (from opening/closing to open/closed)
+            if from_state and from_state.state in (
+                CoverState.OPENING,
+                CoverState.CLOSING,
+            ):
+                if to_state.state in (CoverState.OPEN, CoverState.CLOSED):
+                    run_action(
+                        {
+                            ATTR_ENTITY_ID: entity_id,
+                            "from_state": from_state,
+                            "to_state": to_state,
+                        },
+                        f"cover stopped on {entity_id}",
+                        event.context,
+                    )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+class CoverPositionChangedTrigger(Trigger):
+    """Trigger for when a cover's position changes."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, POSITION_CHANGED_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the cover position changed trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.target is not None
+        self._target = config.target
+        self._options = config.options or {}
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+        lower_limit = self._options.get(CONF_LOWER)
+        upper_limit = self._options.get(CONF_UPPER)
+        above_limit = self._options.get(CONF_ABOVE)
+        below_limit = self._options.get(CONF_BELOW)
+        device_classes_filter = self._options.get(CONF_DEVICE_CLASS, [])
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Filter by device class if specified
+            if device_classes_filter:
+                device_class = to_state.attributes.get(CONF_DEVICE_CLASS)
+                if device_class not in device_classes_filter:
+                    return
+
+            # Get position values
+            from_position = (
+                from_state.attributes.get(ATTR_CURRENT_POSITION) if from_state else None
+            )
+            to_position = to_state.attributes.get(ATTR_CURRENT_POSITION)
+
+            # Only trigger if position value exists and has changed
+            if to_position is None or from_position == to_position:
+                return
+
+            # Apply threshold filters if configured
+            if lower_limit is not None and to_position < lower_limit:
+                return
+            if upper_limit is not None and to_position > upper_limit:
+                return
+            if above_limit is not None and to_position <= above_limit:
+                return
+            if below_limit is not None and to_position >= below_limit:
+                return
+
+            run_action(
+                {
+                    ATTR_ENTITY_ID: entity_id,
+                    "from_state": from_state,
+                    "to_state": to_state,
+                    "from_position": from_position,
+                    "to_position": to_position,
+                },
+                f"position changed on {entity_id}",
+                event.context,
+            )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "opens": CoverOpensTrigger,
+    "closes": CoverClosesTrigger,
+    "stops": CoverStopsTrigger,
+    "position_changed": CoverPositionChangedTrigger,
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for covers."""
+    return TRIGGERS

homeassistant/components/cover/triggers.yaml

@@ -0,0 +1,101 @@
+opens:
+  target:
+    entity:
+      domain: cover
+  fields:
+    fully_opened:
+      required: false
+      default: false
+      selector:
+        boolean:
+    device_class:
+      required: false
+      default: []
+      selector:
+        select:
+          multiple: true
+          options:
+            - curtain
+            - shutter
+            - blind
+
+closes:
+  target:
+    entity:
+      domain: cover
+  fields:
+    fully_closed:
+      required: false
+      default: false
+      selector:
+        boolean:
+    device_class:
+      required: false
+      default: []
+      selector:
+        select:
+          multiple: true
+          options:
+            - curtain
+            - shutter
+            - blind
+
+stops:
+  target:
+    entity:
+      domain: cover
+  fields:
+    device_class:
+      required: false
+      default: []
+      selector:
+        select:
+          multiple: true
+          options:
+            - curtain
+            - shutter
+            - blind
+
+position_changed:
+  target:
+    entity:
+      domain: cover
+  fields:
+    lower:
+      required: false
+      selector:
+        number:
+          min: 0
+          max: 100
+          mode: box
+    upper:
+      required: false
+      selector:
+        number:
+          min: 0
+          max: 100
+          mode: box
+    above:
+      required: false
+      selector:
+        number:
+          min: 0
+          max: 100
+          mode: box
+    below:
+      required: false
+      selector:
+        number:
+          min: 0
+          max: 100
+          mode: box
+    device_class:
+      required: false
+      default: []
+      selector:
+        select:
+          multiple: true
+          options:
+            - curtain
+            - shutter
+            - blind

homeassistant/components/ecobee/manifest.json

@@ -9,7 +9,7 @@
   },
   "iot_class": "cloud_polling",
   "loggers": ["pyecobee"],
-  "requirements": ["python-ecobee-api==0.3.2"],
+  "requirements": ["python-ecobee-api==0.2.20"],
   "single_config_entry": true,
   "zeroconf": [
     {

homeassistant/components/energy/data.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import asyncio
 from collections import Counter
 from collections.abc import Awaitable, Callable
-from typing import Literal, NotRequired, TypedDict
+from typing import Literal, TypedDict
 
 import voluptuous as vol
 
@@ -29,7 +29,7 @@ async def async_get_manager(hass: HomeAssistant) -> EnergyManager:
 class FlowFromGridSourceType(TypedDict):
     """Dictionary describing the 'from' stat for the grid source."""
 
-    # statistic_id of an energy meter (kWh)
+    # statistic_id of a an energy meter (kWh)
     stat_energy_from: str
 
     # statistic_id of costs ($) incurred from the energy meter
@@ -58,14 +58,6 @@ class FlowToGridSourceType(TypedDict):
     number_energy_price: float | None  # Price for energy ($/kWh)
 
 
-class GridPowerSourceType(TypedDict):
-    """Dictionary holding the source of grid power consumption."""
-
-    # statistic_id of a power meter (kW)
-    # negative values indicate grid return
-    stat_rate: str
-
-
 class GridSourceType(TypedDict):
     """Dictionary holding the source of grid energy consumption."""
 
@@ -73,7 +65,6 @@ class GridSourceType(TypedDict):
 
     flow_from: list[FlowFromGridSourceType]
     flow_to: list[FlowToGridSourceType]
-    power: NotRequired[list[GridPowerSourceType]]
 
     cost_adjustment_day: float
 
@@ -84,7 +75,6 @@ class SolarSourceType(TypedDict):
     type: Literal["solar"]
 
     stat_energy_from: str
-    stat_rate: NotRequired[str]
     config_entry_solar_forecast: list[str] | None
 
 
@@ -95,8 +85,6 @@ class BatterySourceType(TypedDict):
 
     stat_energy_from: str
     stat_energy_to: str
-    # positive when discharging, negative when charging
-    stat_rate: NotRequired[str]
 
 
 class GasSourceType(TypedDict):
@@ -148,15 +136,12 @@ class DeviceConsumption(TypedDict):
     # This is an ever increasing value
     stat_consumption: str
 
-    # Instantaneous rate of flow: W, L/min or m³/h
-    stat_rate: NotRequired[str]
-
     # An optional custom name for display in energy graphs
     name: str | None
 
     # An optional statistic_id identifying a device
     # that includes this device's consumption in its total
-    included_in_stat: NotRequired[str]
+    included_in_stat: str | None
 
 
 class EnergyPreferences(TypedDict):
@@ -209,12 +194,6 @@ FLOW_TO_GRID_SOURCE_SCHEMA = vol.Schema(
     }
 )
 
-GRID_POWER_SOURCE_SCHEMA = vol.Schema(
-    {
-        vol.Required("stat_rate"): str,
-    }
-)
-
 
 def _generate_unique_value_validator(key: str) -> Callable[[list[dict]], list[dict]]:
     """Generate a validator that ensures a value is only used once."""
@@ -245,10 +224,6 @@ GRID_SOURCE_SCHEMA = vol.Schema(
             [FLOW_TO_GRID_SOURCE_SCHEMA],
             _generate_unique_value_validator("stat_energy_to"),
         ),
-        vol.Optional("power"): vol.All(
-            [GRID_POWER_SOURCE_SCHEMA],
-            _generate_unique_value_validator("stat_rate"),
-        ),
         vol.Required("cost_adjustment_day"): vol.Coerce(float),
     }
 )
@@ -256,7 +231,6 @@ SOLAR_SOURCE_SCHEMA = vol.Schema(
     {
         vol.Required("type"): "solar",
         vol.Required("stat_energy_from"): str,
-        vol.Optional("stat_rate"): str,
         vol.Optional("config_entry_solar_forecast"): vol.Any([str], None),
     }
 )
@@ -265,7 +239,6 @@ BATTERY_SOURCE_SCHEMA = vol.Schema(
         vol.Required("type"): "battery",
         vol.Required("stat_energy_from"): str,
         vol.Required("stat_energy_to"): str,
-        vol.Optional("stat_rate"): str,
     }
 )
 GAS_SOURCE_SCHEMA = vol.Schema(
@@ -321,7 +294,6 @@ ENERGY_SOURCE_SCHEMA = vol.All(
 DEVICE_CONSUMPTION_SCHEMA = vol.Schema(
     {
         vol.Required("stat_consumption"): str,
-        vol.Optional("stat_rate"): str,
         vol.Optional("name"): str,
         vol.Optional("included_in_stat"): str,
     }

homeassistant/components/energy/validate.py

@@ -12,7 +12,6 @@ from homeassistant.const import (
     STATE_UNAVAILABLE,
     STATE_UNKNOWN,
     UnitOfEnergy,
-    UnitOfPower,
     UnitOfVolume,
 )
 from homeassistant.core import HomeAssistant, callback, valid_entity_id
@@ -24,17 +23,12 @@ ENERGY_USAGE_DEVICE_CLASSES = (sensor.SensorDeviceClass.ENERGY,)
 ENERGY_USAGE_UNITS: dict[str, tuple[UnitOfEnergy, ...]] = {
     sensor.SensorDeviceClass.ENERGY: tuple(UnitOfEnergy)
 }
-POWER_USAGE_DEVICE_CLASSES = (sensor.SensorDeviceClass.POWER,)
-POWER_USAGE_UNITS: dict[str, tuple[UnitOfPower, ...]] = {
-    sensor.SensorDeviceClass.POWER: tuple(UnitOfPower)
-}
 
 ENERGY_PRICE_UNITS = tuple(
     f"/{unit}" for units in ENERGY_USAGE_UNITS.values() for unit in units
 )
 ENERGY_UNIT_ERROR = "entity_unexpected_unit_energy"
 ENERGY_PRICE_UNIT_ERROR = "entity_unexpected_unit_energy_price"
-POWER_UNIT_ERROR = "entity_unexpected_unit_power"
 GAS_USAGE_DEVICE_CLASSES = (
     sensor.SensorDeviceClass.ENERGY,
     sensor.SensorDeviceClass.GAS,
@@ -88,10 +82,6 @@ def _get_placeholders(hass: HomeAssistant, issue_type: str) -> dict[str, str] |
                 f"{currency}{unit}" for unit in ENERGY_PRICE_UNITS
             ),
         }
-    if issue_type == POWER_UNIT_ERROR:
-        return {
-            "power_units": ", ".join(POWER_USAGE_UNITS[sensor.SensorDeviceClass.POWER]),
-        }
     if issue_type == GAS_UNIT_ERROR:
         return {
             "energy_units": ", ".join(GAS_USAGE_UNITS[sensor.SensorDeviceClass.ENERGY]),
@@ -169,7 +159,7 @@ class EnergyPreferencesValidation:
 
 
 @callback
-def _async_validate_stat_common(
+def _async_validate_usage_stat(
     hass: HomeAssistant,
     metadata: dict[str, tuple[int, recorder.models.StatisticMetaData]],
     stat_id: str,
@@ -177,41 +167,37 @@ def _async_validate_stat_common(
     allowed_units: Mapping[str, Sequence[str]],
     unit_error: str,
     issues: ValidationIssues,
-    check_negative: bool = False,
-) -> str | None:
-    """Validate common aspects of a statistic.
-
-    Returns the entity_id if validation succeeds, None otherwise.
-    """
+) -> None:
+    """Validate a statistic."""
     if stat_id not in metadata:
         issues.add_issue(hass, "statistics_not_defined", stat_id)
 
     has_entity_source = valid_entity_id(stat_id)
 
     if not has_entity_source:
-        return None
+        return
 
     entity_id = stat_id
 
     if not recorder.is_entity_recorded(hass, entity_id):
         issues.add_issue(hass, "recorder_untracked", entity_id)
-        return None
+        return
 
     if (state := hass.states.get(entity_id)) is None:
         issues.add_issue(hass, "entity_not_defined", entity_id)
-        return None
+        return
 
     if state.state in (STATE_UNAVAILABLE, STATE_UNKNOWN):
         issues.add_issue(hass, "entity_unavailable", entity_id, state.state)
-        return None
+        return
 
     try:
         current_value: float | None = float(state.state)
     except ValueError:
         issues.add_issue(hass, "entity_state_non_numeric", entity_id, state.state)
-        return None
+        return
 
-    if check_negative and current_value is not None and current_value < 0:
+    if current_value is not None and current_value < 0:
         issues.add_issue(hass, "entity_negative_state", entity_id, current_value)
 
     device_class = state.attributes.get(ATTR_DEVICE_CLASS)
@@ -225,36 +211,6 @@ def _async_validate_stat_common(
         if device_class and unit not in allowed_units.get(device_class, []):
             issues.add_issue(hass, unit_error, entity_id, unit)
 
-    return entity_id
-
-
-@callback
-def _async_validate_usage_stat(
-    hass: HomeAssistant,
-    metadata: dict[str, tuple[int, recorder.models.StatisticMetaData]],
-    stat_id: str,
-    allowed_device_classes: Sequence[str],
-    allowed_units: Mapping[str, Sequence[str]],
-    unit_error: str,
-    issues: ValidationIssues,
-) -> None:
-    """Validate a statistic."""
-    entity_id = _async_validate_stat_common(
-        hass,
-        metadata,
-        stat_id,
-        allowed_device_classes,
-        allowed_units,
-        unit_error,
-        issues,
-        check_negative=True,
-    )
-
-    if entity_id is None:
-        return
-
-    state = hass.states.get(entity_id)
-    assert state is not None
     state_class = state.attributes.get(sensor.ATTR_STATE_CLASS)
 
     allowed_state_classes = [
@@ -299,39 +255,6 @@ def _async_validate_price_entity(
         issues.add_issue(hass, unit_error, entity_id, unit)
 
 
-@callback
-def _async_validate_power_stat(
-    hass: HomeAssistant,
-    metadata: dict[str, tuple[int, recorder.models.StatisticMetaData]],
-    stat_id: str,
-    allowed_device_classes: Sequence[str],
-    allowed_units: Mapping[str, Sequence[str]],
-    unit_error: str,
-    issues: ValidationIssues,
-) -> None:
-    """Validate a power statistic."""
-    entity_id = _async_validate_stat_common(
-        hass,
-        metadata,
-        stat_id,
-        allowed_device_classes,
-        allowed_units,
-        unit_error,
-        issues,
-        check_negative=False,
-    )
-
-    if entity_id is None:
-        return
-
-    state = hass.states.get(entity_id)
-    assert state is not None
-    state_class = state.attributes.get(sensor.ATTR_STATE_CLASS)
-
-    if state_class != sensor.SensorStateClass.MEASUREMENT:
-        issues.add_issue(hass, "entity_unexpected_state_class", entity_id, state_class)
-
-
 @callback
 def _async_validate_cost_stat(
     hass: HomeAssistant,
@@ -386,260 +309,11 @@ def _async_validate_auto_generated_cost_entity(
         issues.add_issue(hass, "recorder_untracked", cost_entity_id)
 
 
-def _validate_grid_source(
-    hass: HomeAssistant,
-    source: data.GridSourceType,
-    statistics_metadata: dict[str, tuple[int, recorder.models.StatisticMetaData]],
-    wanted_statistics_metadata: set[str],
-    source_result: ValidationIssues,
-    validate_calls: list[functools.partial[None]],
-) -> None:
-    """Validate grid energy source."""
-    flow_from: data.FlowFromGridSourceType
-    for flow_from in source["flow_from"]:
-        wanted_statistics_metadata.add(flow_from["stat_energy_from"])
-        validate_calls.append(
-            functools.partial(
-                _async_validate_usage_stat,
-                hass,
-                statistics_metadata,
-                flow_from["stat_energy_from"],
-                ENERGY_USAGE_DEVICE_CLASSES,
-                ENERGY_USAGE_UNITS,
-                ENERGY_UNIT_ERROR,
-                source_result,
-            )
-        )
-
-        if (stat_cost := flow_from.get("stat_cost")) is not None:
-            wanted_statistics_metadata.add(stat_cost)
-            validate_calls.append(
-                functools.partial(
-                    _async_validate_cost_stat,
-                    hass,
-                    statistics_metadata,
-                    stat_cost,
-                    source_result,
-                )
-            )
-        elif (entity_energy_price := flow_from.get("entity_energy_price")) is not None:
-            validate_calls.append(
-                functools.partial(
-                    _async_validate_price_entity,
-                    hass,
-                    entity_energy_price,
-                    source_result,
-                    ENERGY_PRICE_UNITS,
-                    ENERGY_PRICE_UNIT_ERROR,
-                )
-            )
-
-        if (
-            flow_from.get("entity_energy_price") is not None
-            or flow_from.get("number_energy_price") is not None
-        ):
-            validate_calls.append(
-                functools.partial(
-                    _async_validate_auto_generated_cost_entity,
-                    hass,
-                    flow_from["stat_energy_from"],
-                    source_result,
-                )
-            )
-
-    flow_to: data.FlowToGridSourceType
-    for flow_to in source["flow_to"]:
-        wanted_statistics_metadata.add(flow_to["stat_energy_to"])
-        validate_calls.append(
-            functools.partial(
-                _async_validate_usage_stat,
-                hass,
-                statistics_metadata,
-                flow_to["stat_energy_to"],
-                ENERGY_USAGE_DEVICE_CLASSES,
-                ENERGY_USAGE_UNITS,
-                ENERGY_UNIT_ERROR,
-                source_result,
-            )
-        )
-
-        if (stat_compensation := flow_to.get("stat_compensation")) is not None:
-            wanted_statistics_metadata.add(stat_compensation)
-            validate_calls.append(
-                functools.partial(
-                    _async_validate_cost_stat,
-                    hass,
-                    statistics_metadata,
-                    stat_compensation,
-                    source_result,
-                )
-            )
-        elif (entity_energy_price := flow_to.get("entity_energy_price")) is not None:
-            validate_calls.append(
-                functools.partial(
-                    _async_validate_price_entity,
-                    hass,
-                    entity_energy_price,
-                    source_result,
-                    ENERGY_PRICE_UNITS,
-                    ENERGY_PRICE_UNIT_ERROR,
-                )
-            )
-
-        if (
-            flow_to.get("entity_energy_price") is not None
-            or flow_to.get("number_energy_price") is not None
-        ):
-            validate_calls.append(
-                functools.partial(
-                    _async_validate_auto_generated_cost_entity,
-                    hass,
-                    flow_to["stat_energy_to"],
-                    source_result,
-                )
-            )
-
-    for power_stat in source.get("power", []):
-        wanted_statistics_metadata.add(power_stat["stat_rate"])
-        validate_calls.append(
-            functools.partial(
-                _async_validate_power_stat,
-                hass,
-                statistics_metadata,
-                power_stat["stat_rate"],
-                POWER_USAGE_DEVICE_CLASSES,
-                POWER_USAGE_UNITS,
-                POWER_UNIT_ERROR,
-                source_result,
-            )
-        )
-
-
-def _validate_gas_source(
-    hass: HomeAssistant,
-    source: data.GasSourceType,
-    statistics_metadata: dict[str, tuple[int, recorder.models.StatisticMetaData]],
-    wanted_statistics_metadata: set[str],
-    source_result: ValidationIssues,
-    validate_calls: list[functools.partial[None]],
-) -> None:
-    """Validate gas energy source."""
-    wanted_statistics_metadata.add(source["stat_energy_from"])
-    validate_calls.append(
-        functools.partial(
-            _async_validate_usage_stat,
-            hass,
-            statistics_metadata,
-            source["stat_energy_from"],
-            GAS_USAGE_DEVICE_CLASSES,
-            GAS_USAGE_UNITS,
-            GAS_UNIT_ERROR,
-            source_result,
-        )
-    )
-
-    if (stat_cost := source.get("stat_cost")) is not None:
-        wanted_statistics_metadata.add(stat_cost)
-        validate_calls.append(
-            functools.partial(
-                _async_validate_cost_stat,
-                hass,
-                statistics_metadata,
-                stat_cost,
-                source_result,
-            )
-        )
-    elif (entity_energy_price := source.get("entity_energy_price")) is not None:
-        validate_calls.append(
-            functools.partial(
-                _async_validate_price_entity,
-                hass,
-                entity_energy_price,
-                source_result,
-                GAS_PRICE_UNITS,
-                GAS_PRICE_UNIT_ERROR,
-            )
-        )
-
-    if (
-        source.get("entity_energy_price") is not None
-        or source.get("number_energy_price") is not None
-    ):
-        validate_calls.append(
-            functools.partial(
-                _async_validate_auto_generated_cost_entity,
-                hass,
-                source["stat_energy_from"],
-                source_result,
-            )
-        )
-
-
-def _validate_water_source(
-    hass: HomeAssistant,
-    source: data.WaterSourceType,
-    statistics_metadata: dict[str, tuple[int, recorder.models.StatisticMetaData]],
-    wanted_statistics_metadata: set[str],
-    source_result: ValidationIssues,
-    validate_calls: list[functools.partial[None]],
-) -> None:
-    """Validate water energy source."""
-    wanted_statistics_metadata.add(source["stat_energy_from"])
-    validate_calls.append(
-        functools.partial(
-            _async_validate_usage_stat,
-            hass,
-            statistics_metadata,
-            source["stat_energy_from"],
-            WATER_USAGE_DEVICE_CLASSES,
-            WATER_USAGE_UNITS,
-            WATER_UNIT_ERROR,
-            source_result,
-        )
-    )
-
-    if (stat_cost := source.get("stat_cost")) is not None:
-        wanted_statistics_metadata.add(stat_cost)
-        validate_calls.append(
-            functools.partial(
-                _async_validate_cost_stat,
-                hass,
-                statistics_metadata,
-                stat_cost,
-                source_result,
-            )
-        )
-    elif (entity_energy_price := source.get("entity_energy_price")) is not None:
-        validate_calls.append(
-            functools.partial(
-                _async_validate_price_entity,
-                hass,
-                entity_energy_price,
-                source_result,
-                WATER_PRICE_UNITS,
-                WATER_PRICE_UNIT_ERROR,
-            )
-        )
-
-    if (
-        source.get("entity_energy_price") is not None
-        or source.get("number_energy_price") is not None
-    ):
-        validate_calls.append(
-            functools.partial(
-                _async_validate_auto_generated_cost_entity,
-                hass,
-                source["stat_energy_from"],
-                source_result,
-            )
-        )
-
-
 async def async_validate(hass: HomeAssistant) -> EnergyPreferencesValidation:
     """Validate the energy configuration."""
     manager: data.EnergyManager = await data.async_get_manager(hass)
     statistics_metadata: dict[str, tuple[int, recorder.models.StatisticMetaData]] = {}
-    validate_calls: list[functools.partial[None]] = []
+    validate_calls = []
     wanted_statistics_metadata: set[str] = set()
 
     result = EnergyPreferencesValidation()
@@ -653,35 +327,215 @@ async def async_validate(hass: HomeAssistant) -> EnergyPreferencesValidation:
         result.energy_sources.append(source_result)
 
         if source["type"] == "grid":
-            _validate_grid_source(
-                hass,
-                source,
-                statistics_metadata,
-                wanted_statistics_metadata,
-                source_result,
-                validate_calls,
-            )
+            flow: data.FlowFromGridSourceType | data.FlowToGridSourceType
+            for flow in source["flow_from"]:
+                wanted_statistics_metadata.add(flow["stat_energy_from"])
+                validate_calls.append(
+                    functools.partial(
+                        _async_validate_usage_stat,
+                        hass,
+                        statistics_metadata,
+                        flow["stat_energy_from"],
+                        ENERGY_USAGE_DEVICE_CLASSES,
+                        ENERGY_USAGE_UNITS,
+                        ENERGY_UNIT_ERROR,
+                        source_result,
+                    )
+                )
+
+                if (stat_cost := flow.get("stat_cost")) is not None:
+                    wanted_statistics_metadata.add(stat_cost)
+                    validate_calls.append(
+                        functools.partial(
+                            _async_validate_cost_stat,
+                            hass,
+                            statistics_metadata,
+                            stat_cost,
+                            source_result,
+                        )
+                    )
+                elif (
+                    entity_energy_price := flow.get("entity_energy_price")
+                ) is not None:
+                    validate_calls.append(
+                        functools.partial(
+                            _async_validate_price_entity,
+                            hass,
+                            entity_energy_price,
+                            source_result,
+                            ENERGY_PRICE_UNITS,
+                            ENERGY_PRICE_UNIT_ERROR,
+                        )
+                    )
+
+                if (
+                    flow.get("entity_energy_price") is not None
+                    or flow.get("number_energy_price") is not None
+                ):
+                    validate_calls.append(
+                        functools.partial(
+                            _async_validate_auto_generated_cost_entity,
+                            hass,
+                            flow["stat_energy_from"],
+                            source_result,
+                        )
+                    )
+
+            for flow in source["flow_to"]:
+                wanted_statistics_metadata.add(flow["stat_energy_to"])
+                validate_calls.append(
+                    functools.partial(
+                        _async_validate_usage_stat,
+                        hass,
+                        statistics_metadata,
+                        flow["stat_energy_to"],
+                        ENERGY_USAGE_DEVICE_CLASSES,
+                        ENERGY_USAGE_UNITS,
+                        ENERGY_UNIT_ERROR,
+                        source_result,
+                    )
+                )
+
+                if (stat_compensation := flow.get("stat_compensation")) is not None:
+                    wanted_statistics_metadata.add(stat_compensation)
+                    validate_calls.append(
+                        functools.partial(
+                            _async_validate_cost_stat,
+                            hass,
+                            statistics_metadata,
+                            stat_compensation,
+                            source_result,
+                        )
+                    )
+                elif (
+                    entity_energy_price := flow.get("entity_energy_price")
+                ) is not None:
+                    validate_calls.append(
+                        functools.partial(
+                            _async_validate_price_entity,
+                            hass,
+                            entity_energy_price,
+                            source_result,
+                            ENERGY_PRICE_UNITS,
+                            ENERGY_PRICE_UNIT_ERROR,
+                        )
+                    )
+
+                if (
+                    flow.get("entity_energy_price") is not None
+                    or flow.get("number_energy_price") is not None
+                ):
+                    validate_calls.append(
+                        functools.partial(
+                            _async_validate_auto_generated_cost_entity,
+                            hass,
+                            flow["stat_energy_to"],
+                            source_result,
+                        )
+                    )
 
         elif source["type"] == "gas":
-            _validate_gas_source(
-                hass,
-                source,
-                statistics_metadata,
-                wanted_statistics_metadata,
-                source_result,
-                validate_calls,
+            wanted_statistics_metadata.add(source["stat_energy_from"])
+            validate_calls.append(
+                functools.partial(
+                    _async_validate_usage_stat,
+                    hass,
+                    statistics_metadata,
+                    source["stat_energy_from"],
+                    GAS_USAGE_DEVICE_CLASSES,
+                    GAS_USAGE_UNITS,
+                    GAS_UNIT_ERROR,
+                    source_result,
+                )
             )
 
+            if (stat_cost := source.get("stat_cost")) is not None:
+                wanted_statistics_metadata.add(stat_cost)
+                validate_calls.append(
+                    functools.partial(
+                        _async_validate_cost_stat,
+                        hass,
+                        statistics_metadata,
+                        stat_cost,
+                        source_result,
+                    )
+                )
+            elif (entity_energy_price := source.get("entity_energy_price")) is not None:
+                validate_calls.append(
+                    functools.partial(
+                        _async_validate_price_entity,
+                        hass,
+                        entity_energy_price,
+                        source_result,
+                        GAS_PRICE_UNITS,
+                        GAS_PRICE_UNIT_ERROR,
+                    )
+                )
+
+            if (
+                source.get("entity_energy_price") is not None
+                or source.get("number_energy_price") is not None
+            ):
+                validate_calls.append(
+                    functools.partial(
+                        _async_validate_auto_generated_cost_entity,
+                        hass,
+                        source["stat_energy_from"],
+                        source_result,
+                    )
+                )
+
         elif source["type"] == "water":
-            _validate_water_source(
-                hass,
-                source,
-                statistics_metadata,
-                wanted_statistics_metadata,
-                source_result,
-                validate_calls,
+            wanted_statistics_metadata.add(source["stat_energy_from"])
+            validate_calls.append(
+                functools.partial(
+                    _async_validate_usage_stat,
+                    hass,
+                    statistics_metadata,
+                    source["stat_energy_from"],
+                    WATER_USAGE_DEVICE_CLASSES,
+                    WATER_USAGE_UNITS,
+                    WATER_UNIT_ERROR,
+                    source_result,
+                )
             )
 
+            if (stat_cost := source.get("stat_cost")) is not None:
+                wanted_statistics_metadata.add(stat_cost)
+                validate_calls.append(
+                    functools.partial(
+                        _async_validate_cost_stat,
+                        hass,
+                        statistics_metadata,
+                        stat_cost,
+                        source_result,
+                    )
+                )
+            elif (entity_energy_price := source.get("entity_energy_price")) is not None:
+                validate_calls.append(
+                    functools.partial(
+                        _async_validate_price_entity,
+                        hass,
+                        entity_energy_price,
+                        source_result,
+                        WATER_PRICE_UNITS,
+                        WATER_PRICE_UNIT_ERROR,
+                    )
+                )
+
+            if (
+                source.get("entity_energy_price") is not None
+                or source.get("number_energy_price") is not None
+            ):
+                validate_calls.append(
+                    functools.partial(
+                        _async_validate_auto_generated_cost_entity,
+                        hass,
+                        source["stat_energy_from"],
+                        source_result,
+                    )
+                )
+
         elif source["type"] == "solar":
             wanted_statistics_metadata.add(source["stat_energy_from"])
             validate_calls.append(

homeassistant/components/foscam/camera.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import asyncio
-from urllib.parse import quote
 
 import voluptuous as vol
 
@@ -153,9 +152,7 @@ class HassFoscamCamera(FoscamEntity, Camera):
     async def stream_source(self) -> str | None:
         """Return the stream source."""
         if self._rtsp_port:
-            _username = quote(self._username)
-            _password = quote(self._password)
-            return f"rtsp://{_username}:{_password}@{self._foscam_session.host}:{self._rtsp_port}/video{self._stream}"
+            return f"rtsp://{self._username}:{self._password}@{self._foscam_session.host}:{self._rtsp_port}/video{self._stream}"
 
         return None
 

homeassistant/components/frontend/__init__.py

@@ -481,13 +481,6 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
         sidebar_title="climate",
         sidebar_default_visible=False,
     )
-    async_register_built_in_panel(
-        hass,
-        "home",
-        sidebar_icon="mdi:home",
-        sidebar_title="home",
-        sidebar_default_visible=False,
-    )
 
     async_register_built_in_panel(hass, "profile")
 

homeassistant/components/google/manifest.json

@@ -7,5 +7,5 @@
   "documentation": "https://www.home-assistant.io/integrations/google",
   "iot_class": "cloud_polling",
   "loggers": ["googleapiclient"],
-  "requirements": ["gcal-sync==8.0.0", "oauth2client==4.1.3", "ical==11.1.0"]
+  "requirements": ["gcal-sync==8.0.0", "oauth2client==4.1.3", "ical==11.0.0"]
 }

homeassistant/components/home_connect/manifest.json

@@ -22,6 +22,6 @@
   "iot_class": "cloud_push",
   "loggers": ["aiohomeconnect"],
   "quality_scale": "platinum",
-  "requirements": ["aiohomeconnect==0.23.1"],
+  "requirements": ["aiohomeconnect==0.23.0"],
   "zeroconf": ["_homeconnect._tcp.local."]
 }

homeassistant/components/home_connect/select.py

@@ -412,8 +412,8 @@ class HomeConnectProgramSelectEntity(HomeConnectEntity, SelectEntity):
         """Set the program value."""
         event = self.appliance.events.get(cast(EventKey, self.bsh_key))
         self._attr_current_option = (
-            PROGRAMS_TRANSLATION_KEYS_MAP.get(ProgramKey(event_value))
-            if event and isinstance(event_value := event.value, str)
+            PROGRAMS_TRANSLATION_KEYS_MAP.get(cast(ProgramKey, event.value))
+            if event
             else None
         )
 

homeassistant/components/home_connect/sensor.py

@@ -556,11 +556,8 @@ class HomeConnectSensor(HomeConnectEntity, SensorEntity):
         status = self.appliance.status[cast(StatusKey, self.bsh_key)].value
         self._update_native_value(status)
 
-    def _update_native_value(self, status: str | float | None) -> None:
+    def _update_native_value(self, status: str | float) -> None:
         """Set the value of the sensor based on the given value."""
-        if status is None:
-            self._attr_native_value = None
-            return
         match self.device_class:
             case SensorDeviceClass.TIMESTAMP:
                 self._attr_native_value = dt_util.utcnow() + timedelta(

homeassistant/components/homeassistant_connect_zbt2/config_flow.py

@@ -76,18 +76,9 @@ class ZBT2FirmwareMixin(ConfigEntryBaseFlow, FirmwareInstallFlowProtocol):
     """Mixin for Home Assistant Connect ZBT-2 firmware methods."""
 
     context: ConfigFlowContext
-
+    BOOTLOADER_RESET_METHODS = [ResetTarget.RTS_DTR]
     ZIGBEE_BAUDRATE = 460800
 
-    # 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
     ) -> ConfigFlowResult:

homeassistant/components/homeassistant_connect_zbt2/manifest.json

@@ -6,12 +6,6 @@
   "dependencies": ["hardware", "usb", "homeassistant_hardware"],
   "documentation": "https://www.home-assistant.io/integrations/homeassistant_connect_zbt2",
   "integration_type": "hardware",
-  "loggers": [
-    "bellows",
-    "universal_silabs_flasher",
-    "zigpy.serial",
-    "serial_asyncio_fast"
-  ],
   "quality_scale": "bronze",
   "usb": [
     {

homeassistant/components/homeassistant_connect_zbt2/update.py

@@ -14,6 +14,7 @@ from homeassistant.components.homeassistant_hardware.update import (
 from homeassistant.components.homeassistant_hardware.util import (
     ApplicationType,
     FirmwareInfo,
+    ResetTarget,
 )
 from homeassistant.components.update import UpdateDeviceClass
 from homeassistant.const import EntityCategory
@@ -23,7 +24,6 @@ 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__)
@@ -134,8 +134,7 @@ async def async_setup_entry(
 class FirmwareUpdateEntity(BaseFirmwareUpdateEntity):
     """Connect ZBT-2 firmware update entity."""
 
-    BOOTLOADER_RESET_METHODS = ZBT2FirmwareMixin.BOOTLOADER_RESET_METHODS
-    APPLICATION_PROBE_METHODS = ZBT2FirmwareMixin.APPLICATION_PROBE_METHODS
+    bootloader_reset_methods = [ResetTarget.RTS_DTR]
 
     def __init__(
         self,

homeassistant/components/homeassistant_hardware/firmware_config_flow.py

@@ -81,7 +81,6 @@ class BaseFirmwareInstallFlow(ConfigEntryBaseFlow, ABC):
 
     ZIGBEE_BAUDRATE = 115200  # Default, subclasses may override
     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
@@ -231,11 +230,7 @@ class BaseFirmwareInstallFlow(ConfigEntryBaseFlow, ABC):
         # Installing new firmware is only truly required if the wrong type is
         # installed: upgrading to the latest release of the current firmware type
         # isn't strictly necessary for functionality.
-        self._probed_firmware_info = await probe_silabs_firmware_info(
-            self._device,
-            bootloader_reset_methods=self.BOOTLOADER_RESET_METHODS,
-            application_probe_methods=self.APPLICATION_PROBE_METHODS,
-        )
+        self._probed_firmware_info = await probe_silabs_firmware_info(self._device)
 
         firmware_install_required = self._probed_firmware_info is None or (
             self._probed_firmware_info.firmware_type != expected_installed_firmware_type
@@ -300,7 +295,6 @@ class BaseFirmwareInstallFlow(ConfigEntryBaseFlow, ABC):
             fw_data=fw_data,
             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

@@ -7,7 +7,7 @@
   "documentation": "https://www.home-assistant.io/integrations/homeassistant_hardware",
   "integration_type": "system",
   "requirements": [
-    "universal-silabs-flasher==0.1.0",
+    "universal-silabs-flasher==0.0.37",
     "ha-silabs-firmware-client==0.3.0"
   ]
 }

homeassistant/components/homeassistant_hardware/update.py

@@ -86,8 +86,7 @@ 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]]
+    bootloader_reset_methods: list[ResetTarget] = []
 
     _attr_supported_features = (
         UpdateEntityFeature.INSTALL | UpdateEntityFeature.PROGRESS
@@ -279,8 +278,7 @@ class BaseFirmwareUpdateEntity(
                 device=self._current_device,
                 fw_data=fw_data,
                 expected_installed_firmware_type=self.entity_description.expected_firmware_type,
-                bootloader_reset_methods=self.BOOTLOADER_RESET_METHODS,
-                application_probe_methods=self.APPLICATION_PROBE_METHODS,
+                bootloader_reset_methods=self.bootloader_reset_methods,
                 progress_callback=self._update_progress,
                 domain=self._config_entry.domain,
             )

homeassistant/components/homeassistant_hardware/util.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import asyncio
 from collections import defaultdict
-from collections.abc import AsyncIterator, Callable, Sequence
+from collections.abc import AsyncIterator, Callable, Iterable, Sequence
 from contextlib import AsyncExitStack, asynccontextmanager
 from dataclasses import dataclass
 from enum import StrEnum
@@ -309,20 +309,15 @@ async def guess_firmware_info(hass: HomeAssistant, device_path: str) -> Firmware
 
 
 async def probe_silabs_firmware_info(
-    device: str,
-    *,
-    bootloader_reset_methods: Sequence[ResetTarget],
-    application_probe_methods: Sequence[tuple[ApplicationType, int]],
+    device: str, *, probe_methods: Iterable[ApplicationType] | None = None
 ) -> FirmwareInfo | None:
     """Probe the running firmware on a SiLabs 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
+        **(
+            {"probe_methods": [m.as_flasher_application_type() for m in probe_methods]}
+            if probe_methods
+            else {}
         ),
     )
 
@@ -348,18 +343,11 @@ 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]],
+    device: str, *, probe_methods: Iterable[ApplicationType] | None = None
 ) -> ApplicationType | None:
     """Probe the running firmware type on a SiLabs device."""
 
-    fw_info = await probe_silabs_firmware_info(
-        device,
-        bootloader_reset_methods=bootloader_reset_methods,
-        application_probe_methods=application_probe_methods,
-    )
+    fw_info = await probe_silabs_firmware_info(device, probe_methods=probe_methods)
     if fw_info is None:
         return None
 
@@ -371,22 +359,12 @@ async def async_flash_silabs_firmware(
     device: str,
     fw_data: bytes,
     expected_installed_firmware_type: ApplicationType,
-    bootloader_reset_methods: Sequence[ResetTarget],
-    application_probe_methods: Sequence[tuple[ApplicationType, int]],
+    bootloader_reset_methods: Sequence[ResetTarget] = (),
     progress_callback: Callable[[int, int], None] | None = None,
     *,
     domain: str = DOMAIN,
 ) -> FirmwareInfo:
     """Flash firmware to the SiLabs device."""
-    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}"
-        )
-
     async with async_firmware_update_context(hass, device, domain):
         firmware_info = await guess_firmware_info(hass, device)
         _LOGGER.debug("Identified firmware info: %s", firmware_info)
@@ -395,9 +373,11 @@ async def async_flash_silabs_firmware(
 
         flasher = Flasher(
             device=device,
-            probe_methods=tuple(
-                (m.as_flasher_application_type(), baudrate)
-                for m, baudrate in application_probe_methods
+            probe_methods=(
+                ApplicationType.GECKO_BOOTLOADER.as_flasher_application_type(),
+                ApplicationType.EZSP.as_flasher_application_type(),
+                ApplicationType.SPINEL.as_flasher_application_type(),
+                ApplicationType.CPC.as_flasher_application_type(),
             ),
             bootloader_reset=tuple(
                 m.as_flasher_reset_target() for m in bootloader_reset_methods
@@ -421,13 +401,7 @@ async def async_flash_silabs_firmware(
 
             probed_firmware_info = await probe_silabs_firmware_info(
                 device,
-                bootloader_reset_methods=bootloader_reset_methods,
-                # Only probe for the expected installed firmware type
-                application_probe_methods=[
-                    (method, baudrate)
-                    for method, baudrate in application_probe_methods
-                    if method == expected_installed_firmware_type
-                ],
+                probe_methods=(expected_installed_firmware_type,),
             )
 
         if probed_firmware_info is None:

homeassistant/components/homeassistant_sky_connect/config_flow.py

@@ -16,7 +16,6 @@ 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,
@@ -80,20 +79,6 @@ class SkyConnectFirmwareMixin(ConfigEntryBaseFlow, FirmwareInstallFlowProtocol):
 
     context: ConfigFlowContext
 
-    ZIGBEE_BAUDRATE = 115200
-    # 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."""
         placeholders = {

homeassistant/components/homeassistant_sky_connect/manifest.json

@@ -6,12 +6,6 @@
   "dependencies": ["hardware", "usb", "homeassistant_hardware"],
   "documentation": "https://www.home-assistant.io/integrations/homeassistant_sky_connect",
   "integration_type": "hardware",
-  "loggers": [
-    "bellows",
-    "universal_silabs_flasher",
-    "zigpy.serial",
-    "serial_asyncio_fast"
-  ],
   "usb": [
     {
       "description": "*skyconnect v1.0*",

homeassistant/components/homeassistant_sky_connect/update.py

@@ -23,7 +23,6 @@ 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,
@@ -152,8 +151,8 @@ async def async_setup_entry(
 class FirmwareUpdateEntity(BaseFirmwareUpdateEntity):
     """SkyConnect firmware update entity."""
 
-    BOOTLOADER_RESET_METHODS = SkyConnectFirmwareMixin.BOOTLOADER_RESET_METHODS
-    APPLICATION_PROBE_METHODS = SkyConnectFirmwareMixin.APPLICATION_PROBE_METHODS
+    # The ZBT-1 does not have a hardware bootloader trigger
+    bootloader_reset_methods = []
 
     def __init__(
         self,

homeassistant/components/homeassistant_yellow/config_flow.py

@@ -82,18 +82,7 @@ else:
 class YellowFirmwareMixin(ConfigEntryBaseFlow, FirmwareInstallFlowProtocol):
     """Mixin for Home Assistant Yellow firmware methods."""
 
-    ZIGBEE_BAUDRATE = 115200
     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
@@ -157,11 +146,7 @@ class HomeAssistantYellowConfigFlow(
         assert self._device is not None
 
         # We do not actually use any portion of `BaseFirmwareConfigFlow` beyond this
-        self._probed_firmware_info = await probe_silabs_firmware_info(
-            self._device,
-            bootloader_reset_methods=self.BOOTLOADER_RESET_METHODS,
-            application_probe_methods=self.APPLICATION_PROBE_METHODS,
-        )
+        self._probed_firmware_info = await probe_silabs_firmware_info(self._device)
 
         # Kick off ZHA hardware discovery automatically if Zigbee firmware is running
         if (

homeassistant/components/homeassistant_yellow/manifest.json

@@ -7,11 +7,5 @@
   "dependencies": ["hardware", "homeassistant_hardware"],
   "documentation": "https://www.home-assistant.io/integrations/homeassistant_yellow",
   "integration_type": "hardware",
-  "loggers": [
-    "bellows",
-    "universal_silabs_flasher",
-    "zigpy.serial",
-    "serial_asyncio_fast"
-  ],
   "single_config_entry": true
 }

homeassistant/components/homeassistant_yellow/update.py

@@ -14,6 +14,7 @@ from homeassistant.components.homeassistant_hardware.update import (
 from homeassistant.components.homeassistant_hardware.util import (
     ApplicationType,
     FirmwareInfo,
+    ResetTarget,
 )
 from homeassistant.components.update import UpdateDeviceClass
 from homeassistant.const import EntityCategory
@@ -23,7 +24,6 @@ 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__)
@@ -150,8 +150,7 @@ async def async_setup_entry(
 class FirmwareUpdateEntity(BaseFirmwareUpdateEntity):
     """Yellow firmware update entity."""
 
-    BOOTLOADER_RESET_METHODS = YellowFirmwareMixin.BOOTLOADER_RESET_METHODS
-    APPLICATION_PROBE_METHODS = YellowFirmwareMixin.APPLICATION_PROBE_METHODS
+    bootloader_reset_methods = [ResetTarget.YELLOW]  # Triggers a GPIO reset
 
     def __init__(
         self,

homeassistant/components/lamarzocco/manifest.json

@@ -37,5 +37,5 @@
   "iot_class": "cloud_push",
   "loggers": ["pylamarzocco"],
   "quality_scale": "platinum",
-  "requirements": ["pylamarzocco==2.1.3"]
+  "requirements": ["pylamarzocco==2.1.2"]
 }

homeassistant/components/lamarzocco/update.py

@@ -125,7 +125,7 @@ class LaMarzoccoUpdateEntity(LaMarzoccoEntity, UpdateEntity):
             await self.coordinator.device.update_firmware()
             while (
                 update_progress := await self.coordinator.device.get_firmware()
-            ).command_status is not UpdateStatus.UPDATED:
+            ).command_status is UpdateStatus.IN_PROGRESS:
                 if counter >= MAX_UPDATE_WAIT:
                     _raise_timeout_error()
                 self._attr_update_percentage = update_progress.progress_percentage

homeassistant/components/light/strings.json

@@ -462,5 +462,40 @@
       }
     }
   },
-  "title": "Light"
+  "title": "Light",
+  "triggers": {
+    "turns_on": {
+      "description": "Triggers when a light turns on.",
+      "description_configured": "Triggers when a light turns on",
+      "name": "When a light turns on"
+    },
+    "turns_off": {
+      "description": "Triggers when a light turns off.",
+      "description_configured": "Triggers when a light turns off",
+      "name": "When a light turns off"
+    },
+    "brightness_changed": {
+      "description": "Triggers when the brightness of a light changes.",
+      "description_configured": "Triggers when the brightness of a light changes",
+      "fields": {
+        "lower": {
+          "description": "The minimum brightness value to trigger on. Only triggers when brightness is at or above this value.",
+          "name": "Lower limit"
+        },
+        "upper": {
+          "description": "The maximum brightness value to trigger on. Only triggers when brightness is at or below this value.",
+          "name": "Upper limit"
+        },
+        "above": {
+          "description": "Only trigger when brightness is above this value.",
+          "name": "Above"
+        },
+        "below": {
+          "description": "Only trigger when brightness is below this value.",
+          "name": "Below"
+        }
+      },
+      "name": "When the brightness of a light changes"
+    }
+  }
 }

homeassistant/components/light/trigger.py

@@ -0,0 +1,288 @@
+"""Provides triggers for lights."""
+
+from typing import TYPE_CHECKING, cast, override
+
+import voluptuous as vol
+
+from homeassistant.const import (
+    ATTR_ENTITY_ID,
+    CONF_OPTIONS,
+    CONF_TARGET,
+    STATE_OFF,
+    STATE_ON,
+    STATE_UNAVAILABLE,
+)
+from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback, split_entity_id
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.target import (
+    TargetStateChangedData,
+    async_track_target_selector_state_change_event,
+)
+from homeassistant.helpers.trigger import Trigger, TriggerActionRunner, TriggerConfig
+from homeassistant.helpers.typing import ConfigType
+
+from .const import DOMAIN
+
+ATTR_BRIGHTNESS = "brightness"
+CONF_LOWER = "lower"
+CONF_UPPER = "upper"
+CONF_ABOVE = "above"
+CONF_BELOW = "below"
+
+TURNS_ON_TRIGGER_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_TARGET): cv.TARGET_FIELDS,
+    }
+)
+
+TURNS_OFF_TRIGGER_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_TARGET): cv.TARGET_FIELDS,
+    }
+)
+
+BRIGHTNESS_CHANGED_TRIGGER_SCHEMA = vol.Schema(
+    {
+        vol.Optional(CONF_OPTIONS, default={}): {
+            vol.Exclusive(CONF_LOWER, "brightness_range"): vol.All(
+                vol.Coerce(int), vol.Range(min=0, max=255)
+            ),
+            vol.Exclusive(CONF_UPPER, "brightness_range"): vol.All(
+                vol.Coerce(int), vol.Range(min=0, max=255)
+            ),
+            vol.Exclusive(CONF_ABOVE, "brightness_range"): vol.All(
+                vol.Coerce(int), vol.Range(min=0, max=255)
+            ),
+            vol.Exclusive(CONF_BELOW, "brightness_range"): vol.All(
+                vol.Coerce(int), vol.Range(min=0, max=255)
+            ),
+        },
+        vol.Required(CONF_TARGET): cv.TARGET_FIELDS,
+    }
+)
+
+
+class LightTurnsOnTrigger(Trigger):
+    """Trigger for when a light turns on."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, TURNS_ON_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the light turns on trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.target is not None
+        self._target = config.target
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Trigger when light turns on (from off to on)
+            if from_state and from_state.state == STATE_OFF and to_state.state == STATE_ON:
+                run_action(
+                    {
+                        ATTR_ENTITY_ID: entity_id,
+                        "from_state": from_state,
+                        "to_state": to_state,
+                    },
+                    f"light turned on on {entity_id}",
+                    event.context,
+                )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+class LightTurnsOffTrigger(Trigger):
+    """Trigger for when a light turns off."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, TURNS_OFF_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the light turns off trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.target is not None
+        self._target = config.target
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Trigger when light turns off (from on to off)
+            if from_state and from_state.state == STATE_ON and to_state.state == STATE_OFF:
+                run_action(
+                    {
+                        ATTR_ENTITY_ID: entity_id,
+                        "from_state": from_state,
+                        "to_state": to_state,
+                    },
+                    f"light turned off on {entity_id}",
+                    event.context,
+                )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+class LightBrightnessChangedTrigger(Trigger):
+    """Trigger for when a light's brightness changes."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, BRIGHTNESS_CHANGED_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the light brightness changed trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.target is not None
+        self._target = config.target
+        self._options = config.options or {}
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+        lower_limit = self._options.get(CONF_LOWER)
+        upper_limit = self._options.get(CONF_UPPER)
+        above_limit = self._options.get(CONF_ABOVE)
+        below_limit = self._options.get(CONF_BELOW)
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Get brightness values
+            from_brightness = (
+                from_state.attributes.get(ATTR_BRIGHTNESS) if from_state else None
+            )
+            to_brightness = to_state.attributes.get(ATTR_BRIGHTNESS)
+
+            # Only trigger if brightness value exists and has changed
+            if to_brightness is None or from_brightness == to_brightness:
+                return
+
+            # Apply threshold filters if configured
+            if lower_limit is not None and to_brightness < lower_limit:
+                return
+            if upper_limit is not None and to_brightness > upper_limit:
+                return
+            if above_limit is not None and to_brightness <= above_limit:
+                return
+            if below_limit is not None and to_brightness >= below_limit:
+                return
+
+            run_action(
+                {
+                    ATTR_ENTITY_ID: entity_id,
+                    "from_state": from_state,
+                    "to_state": to_state,
+                    "from_brightness": from_brightness,
+                    "to_brightness": to_brightness,
+                },
+                f"brightness changed on {entity_id}",
+                event.context,
+            )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "turns_on": LightTurnsOnTrigger,
+    "turns_off": LightTurnsOffTrigger,
+    "brightness_changed": LightBrightnessChangedTrigger,
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for lights."""
+    return TRIGGERS

homeassistant/components/light/triggers.yaml

@@ -0,0 +1,43 @@
+turns_on:
+  target:
+    entity:
+      domain: light
+
+turns_off:
+  target:
+    entity:
+      domain: light
+
+brightness_changed:
+  target:
+    entity:
+      domain: light
+  fields:
+    lower:
+      required: false
+      selector:
+        number:
+          min: 0
+          max: 255
+          mode: box
+    upper:
+      required: false
+      selector:
+        number:
+          min: 0
+          max: 255
+          mode: box
+    above:
+      required: false
+      selector:
+        number:
+          min: 0
+          max: 255
+          mode: box
+    below:
+      required: false
+      selector:
+        number:
+          min: 0
+          max: 255
+          mode: box

homeassistant/components/local_calendar/manifest.json

@@ -7,5 +7,5 @@
   "documentation": "https://www.home-assistant.io/integrations/local_calendar",
   "iot_class": "local_polling",
   "loggers": ["ical"],
-  "requirements": ["ical==11.1.0"]
+  "requirements": ["ical==11.0.0"]
 }

homeassistant/components/local_todo/manifest.json

@@ -5,5 +5,5 @@
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/local_todo",
   "iot_class": "local_polling",
-  "requirements": ["ical==11.1.0"]
+  "requirements": ["ical==11.0.0"]
 }

homeassistant/components/lunatone/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "local_polling",
   "quality_scale": "silver",
-  "requirements": ["lunatone-rest-api-client==0.5.7"]
+  "requirements": ["lunatone-rest-api-client==0.5.3"]
 }

homeassistant/components/media_player/strings.json

@@ -367,5 +367,63 @@
       "name": "Turn up volume"
     }
   },
-  "title": "Media player"
+  "title": "Media player",
+  "triggers": {
+    "turns_on": {
+      "description": "Triggers when a media player turns on.",
+      "description_configured": "Triggers when a media player turns on",
+      "name": "When a media player turns on"
+    },
+    "turns_off": {
+      "description": "Triggers when a media player turns off.",
+      "description_configured": "Triggers when a media player turns off",
+      "name": "When a media player turns off"
+    },
+    "playing": {
+      "description": "Triggers when a media player starts playing.",
+      "description_configured": "Triggers when a media player starts playing",
+      "fields": {
+        "media_content_type": {
+          "description": "The media content types to trigger on. If empty, triggers on all content types.",
+          "name": "Media content types"
+        }
+      },
+      "name": "When a media player starts playing"
+    },
+    "paused": {
+      "description": "Triggers when a media player pauses.",
+      "description_configured": "Triggers when a media player pauses",
+      "name": "When a media player pauses"
+    },
+    "stopped": {
+      "description": "Triggers when a media player stops playing.",
+      "description_configured": "Triggers when a media player stops playing",
+      "name": "When a media player stops playing"
+    },
+    "muted": {
+      "description": "Triggers when a media player gets muted.",
+      "description_configured": "Triggers when a media player gets muted",
+      "name": "When a media player gets muted"
+    },
+    "unmuted": {
+      "description": "Triggers when a media player gets unmuted.",
+      "description_configured": "Triggers when a media player gets unmuted",
+      "name": "When a media player gets unmuted"
+    },
+    "volume_changed": {
+      "description": "Triggers when a media player volume changes.",
+      "description_configured": "Triggers when a media player volume changes",
+      "fields": {
+        "above": {
+          "description": "Only trigger when volume is above this level (0.0-1.0).",
+          "name": "Above"
+        },
+        "below": {
+          "description": "Only trigger when volume is below this level (0.0-1.0).",
+          "name": "Below"
+        }
+      },
+      "name": "When a media player volume changes"
+    }
+  }
 }

homeassistant/components/media_player/trigger.py

@@ -0,0 +1,676 @@
+"""Provides triggers for media players."""
+
+from typing import TYPE_CHECKING, cast, override
+
+import voluptuous as vol
+
+from homeassistant.const import (
+    ATTR_ENTITY_ID,
+    CONF_OPTIONS,
+    CONF_TARGET,
+    STATE_IDLE,
+    STATE_OFF,
+    STATE_PAUSED,
+    STATE_PLAYING,
+    STATE_UNAVAILABLE,
+)
+from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback, split_entity_id
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.target import (
+    TargetStateChangedData,
+    async_track_target_selector_state_change_event,
+)
+from homeassistant.helpers.trigger import Trigger, TriggerActionRunner, TriggerConfig
+from homeassistant.helpers.typing import ConfigType
+
+from .const import (
+    ATTR_MEDIA_CONTENT_TYPE,
+    ATTR_MEDIA_VOLUME_LEVEL,
+    ATTR_MEDIA_VOLUME_MUTED,
+    DOMAIN,
+)
+
+TURNS_ON_TRIGGER_SCHEMA = vol.Schema(
+    {
+        vol.Optional(CONF_OPTIONS, default={}): {},
+        vol.Required(CONF_TARGET): cv.TARGET_FIELDS,
+    }
+)
+
+TURNS_OFF_TRIGGER_SCHEMA = vol.Schema(
+    {
+        vol.Optional(CONF_OPTIONS, default={}): {},
+        vol.Required(CONF_TARGET): cv.TARGET_FIELDS,
+    }
+)
+
+PLAYING_TRIGGER_SCHEMA = vol.Schema(
+    {
+        vol.Optional(CONF_OPTIONS, default={}): {
+            vol.Optional(ATTR_MEDIA_CONTENT_TYPE, default=[]): vol.All(
+                cv.ensure_list, [cv.string]
+            ),
+        },
+        vol.Required(CONF_TARGET): cv.TARGET_FIELDS,
+    }
+)
+
+
+STOPPED_TRIGGER_SCHEMA = vol.Schema(
+    {
+        vol.Optional(CONF_OPTIONS, default={}): {},
+        vol.Required(CONF_TARGET): cv.TARGET_FIELDS,
+    }
+)
+
+MUTED_TRIGGER_SCHEMA = vol.Schema(
+    {
+        vol.Optional(CONF_OPTIONS, default={}): {},
+        vol.Required(CONF_TARGET): cv.TARGET_FIELDS,
+    }
+)
+
+UNMUTED_TRIGGER_SCHEMA = vol.Schema(
+    {
+        vol.Optional(CONF_OPTIONS, default={}): {},
+        vol.Required(CONF_TARGET): cv.TARGET_FIELDS,
+    }
+)
+
+VOLUME_CHANGED_TRIGGER_SCHEMA = vol.Schema(
+    {
+        vol.Optional(CONF_OPTIONS, default={}): {
+            vol.Optional("above"): vol.All(vol.Coerce(float), vol.Range(min=0.0, max=1.0)),
+            vol.Optional("below"): vol.All(vol.Coerce(float), vol.Range(min=0.0, max=1.0)),
+        },
+        vol.Required(CONF_TARGET): cv.TARGET_FIELDS,
+    }
+)
+
+
+PAUSED_TRIGGER_SCHEMA = vol.Schema(
+    {
+        vol.Optional(CONF_OPTIONS, default={}): {},
+        vol.Required(CONF_TARGET): cv.TARGET_FIELDS,
+    }
+)
+
+
+class MediaPlayerTurnsOnTrigger(Trigger):
+    """Trigger for when a media player turns on."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, TURNS_ON_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the media player turns on trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.target is not None
+        self._target = config.target
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Trigger when turning on from off state
+            if (
+                from_state is not None
+                and from_state.state == STATE_OFF
+                and to_state.state != STATE_OFF
+            ):
+                run_action(
+                    {
+                        ATTR_ENTITY_ID: entity_id,
+                        "from_state": from_state,
+                        "to_state": to_state,
+                    },
+                    f"media player {entity_id} turned on",
+                    event.context,
+                )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+class MediaPlayerTurnsOffTrigger(Trigger):
+    """Trigger for when a media player turns off."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, TURNS_OFF_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the media player turns off trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.target is not None
+        self._target = config.target
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Trigger when turning off
+            if (
+                from_state is not None
+                and from_state.state != STATE_OFF
+                and to_state.state == STATE_OFF
+            ):
+                run_action(
+                    {
+                        ATTR_ENTITY_ID: entity_id,
+                        "from_state": from_state,
+                        "to_state": to_state,
+                    },
+                    f"media player {entity_id} turned off",
+                    event.context,
+                )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+class MediaPlayerPlayingTrigger(Trigger):
+    """Trigger for when a media player starts playing."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, PLAYING_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the media player playing trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.options is not None
+            assert config.target is not None
+        self._options = config.options
+        self._target = config.target
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+        media_content_types_filter = self._options[ATTR_MEDIA_CONTENT_TYPE]
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Trigger when starting to play
+            if (
+                from_state is not None
+                and from_state.state != STATE_PLAYING
+                and to_state.state == STATE_PLAYING
+            ):
+                # If media_content_type filter is specified, check if it matches
+                if media_content_types_filter:
+                    media_content_type = to_state.attributes.get(ATTR_MEDIA_CONTENT_TYPE)
+                    if media_content_type not in media_content_types_filter:
+                        return
+
+                run_action(
+                    {
+                        ATTR_ENTITY_ID: entity_id,
+                        "from_state": from_state,
+                        "to_state": to_state,
+                    },
+                    f"media player {entity_id} started playing",
+                    event.context,
+                )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+class MediaPlayerPausedTrigger(Trigger):
+    """Trigger for when a media player pauses."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, PAUSED_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the media player paused trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.target is not None
+        self._target = config.target
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Trigger when pausing
+            if (
+                from_state is not None
+                and from_state.state != STATE_PAUSED
+                and to_state.state == STATE_PAUSED
+            ):
+                run_action(
+                    {
+                        ATTR_ENTITY_ID: entity_id,
+                        "from_state": from_state,
+                        "to_state": to_state,
+                    },
+                    f"media player {entity_id} paused",
+                    event.context,
+                )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+class MediaPlayerStoppedTrigger(Trigger):
+    """Trigger for when a media player stops playing."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, STOPPED_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the media player stopped trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.target is not None
+        self._target = config.target
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Trigger when stopping (to idle or off from playing/paused states)
+            if (
+                from_state is not None
+                and from_state.state in (STATE_PLAYING, STATE_PAUSED)
+                and to_state.state in (STATE_IDLE, STATE_OFF)
+            ):
+                run_action(
+                    {
+                        ATTR_ENTITY_ID: entity_id,
+                        "from_state": from_state,
+                        "to_state": to_state,
+                    },
+                    f"media player {entity_id} stopped",
+                    event.context,
+                )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+class MediaPlayerMutedTrigger(Trigger):
+    """Trigger for when a media player gets muted."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, MUTED_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the media player muted trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.target is not None
+        self._target = config.target
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Trigger when muting
+            if (
+                from_state is not None
+                and not from_state.attributes.get(ATTR_MEDIA_VOLUME_MUTED, False)
+                and to_state.attributes.get(ATTR_MEDIA_VOLUME_MUTED, False)
+            ):
+                run_action(
+                    {
+                        ATTR_ENTITY_ID: entity_id,
+                        "from_state": from_state,
+                        "to_state": to_state,
+                    },
+                    f"media player {entity_id} muted",
+                    event.context,
+                )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+class MediaPlayerUnmutedTrigger(Trigger):
+    """Trigger for when a media player gets unmuted."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, UNMUTED_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the media player unmuted trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.target is not None
+        self._target = config.target
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Trigger when unmuting
+            if (
+                from_state is not None
+                and from_state.attributes.get(ATTR_MEDIA_VOLUME_MUTED, False)
+                and not to_state.attributes.get(ATTR_MEDIA_VOLUME_MUTED, False)
+            ):
+                run_action(
+                    {
+                        ATTR_ENTITY_ID: entity_id,
+                        "from_state": from_state,
+                        "to_state": to_state,
+                    },
+                    f"media player {entity_id} unmuted",
+                    event.context,
+                )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+class MediaPlayerVolumeChangedTrigger(Trigger):
+    """Trigger for when a media player volume changes."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, VOLUME_CHANGED_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the media player volume changed trigger."""
+        super().__init__(hass, config)
+        if TYPE_CHECKING:
+            assert config.options is not None
+            assert config.target is not None
+        self._options = config.options
+        self._target = config.target
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+        above_threshold = self._options.get("above")
+        below_threshold = self._options.get("below")
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and call action."""
+            event = target_state_change_data.state_change_event
+            entity_id = event.data["entity_id"]
+            from_state = event.data["old_state"]
+            to_state = event.data["new_state"]
+
+            # Ignore unavailable states
+            if to_state is None or to_state.state == STATE_UNAVAILABLE:
+                return
+
+            # Get volume levels
+            old_volume = (
+                from_state.attributes.get(ATTR_MEDIA_VOLUME_LEVEL)
+                if from_state is not None
+                else None
+            )
+            new_volume = to_state.attributes.get(ATTR_MEDIA_VOLUME_LEVEL)
+
+            # Volume must have changed
+            if old_volume == new_volume or new_volume is None:
+                return
+
+            # Check thresholds if specified
+            if above_threshold is not None and new_volume <= above_threshold:
+                return
+
+            if below_threshold is not None and new_volume >= below_threshold:
+                return
+
+            run_action(
+                {
+                    ATTR_ENTITY_ID: entity_id,
+                    "from_state": from_state,
+                    "to_state": to_state,
+                },
+                f"media player {entity_id} volume changed",
+                event.context,
+            )
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            """Filter entities of this domain."""
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        return async_track_target_selector_state_change_event(
+            self._hass, self._target, state_change_listener, entity_filter
+        )
+
+
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "turns_on": MediaPlayerTurnsOnTrigger,
+    "turns_off": MediaPlayerTurnsOffTrigger,
+    "playing": MediaPlayerPlayingTrigger,
+    "paused": MediaPlayerPausedTrigger,
+    "stopped": MediaPlayerStoppedTrigger,
+    "muted": MediaPlayerMutedTrigger,
+    "unmuted": MediaPlayerUnmutedTrigger,
+    "volume_changed": MediaPlayerVolumeChangedTrigger,
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for media players."""
+    return TRIGGERS

homeassistant/components/media_player/triggers.yaml

@@ -0,0 +1,65 @@
+turns_on:
+  target:
+    entity:
+      domain: media_player
+
+turns_off:
+  target:
+    entity:
+      domain: media_player
+
+playing:
+  target:
+    entity:
+      domain: media_player
+  fields:
+    media_content_type:
+      required: false
+      default: []
+      selector:
+        select:
+          multiple: true
+          custom_value: true
+          options: []
+
+paused:
+  target:
+    entity:
+      domain: media_player
+
+stopped:
+  target:
+    entity:
+      domain: media_player
+
+muted:
+  target:
+    entity:
+      domain: media_player
+
+unmuted:
+  target:
+    entity:
+      domain: media_player
+
+volume_changed:
+  target:
+    entity:
+      domain: media_player
+  fields:
+    above:
+      required: false
+      selector:
+        number:
+          min: 0.0
+          max: 1.0
+          step: 0.01
+          mode: slider
+    below:
+      required: false
+      selector:
+        number:
+          min: 0.0
+          max: 1.0
+          step: 0.01
+          mode: slider

homeassistant/components/mill/manifest.json

@@ -7,5 +7,5 @@
   "documentation": "https://www.home-assistant.io/integrations/mill",
   "iot_class": "local_polling",
   "loggers": ["mill", "mill_local"],
-  "requirements": ["millheater==0.14.1", "mill-local==0.3.0"]
+  "requirements": ["millheater==0.14.0", "mill-local==0.3.0"]
 }

homeassistant/components/mobile_app/binary_sensor.py

@@ -61,12 +61,10 @@ async def async_setup_entry(
 
         async_add_entities([MobileAppBinarySensor(data, config_entry)])
 
-    config_entry.async_on_unload(
-        async_dispatcher_connect(
-            hass,
-            f"{DOMAIN}_{ENTITY_TYPE}_register",
-            handle_sensor_registration,
-        )
+    async_dispatcher_connect(
+        hass,
+        f"{DOMAIN}_{ENTITY_TYPE}_register",
+        handle_sensor_registration,
     )
 
 

homeassistant/components/mobile_app/sensor.py

@@ -72,12 +72,10 @@ async def async_setup_entry(
 
         async_add_entities([MobileAppSensor(data, config_entry)])
 
-    config_entry.async_on_unload(
-        async_dispatcher_connect(
-            hass,
-            f"{DOMAIN}_{ENTITY_TYPE}_register",
-            handle_sensor_registration,
-        )
+    async_dispatcher_connect(
+        hass,
+        f"{DOMAIN}_{ENTITY_TYPE}_register",
+        handle_sensor_registration,
     )
 
 

homeassistant/components/onedrive/strings.json

@@ -109,7 +109,7 @@
       "message": "Cannot read {filename}, no access to path; `allowlist_external_dirs` may need to be adjusted in `configuration.yaml`"
     },
     "oauth2_implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
+      "message": "OAuth2 implementation unavailable, will retry"
     },
     "update_failed": {
       "message": "Failed to update drive state"

homeassistant/components/point/strings.json

@@ -36,7 +36,7 @@
   },
   "exceptions": {
     "oauth2_implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
+      "message": "OAuth2 implementation unavailable, will retry"
     }
   }
 }

homeassistant/components/recorder/auto_repairs/schema.py

@@ -12,7 +12,7 @@ from sqlalchemy.orm import DeclarativeBase
 from sqlalchemy.orm.attributes import InstrumentedAttribute
 
 from ..const import SupportedDialect
-from ..db_schema import DOUBLE_PRECISION_TYPE_SQL, DOUBLE_TYPE, MYSQL_COLLATE
+from ..db_schema import DOUBLE_PRECISION_TYPE_SQL, DOUBLE_TYPE
 from ..util import session_scope
 
 if TYPE_CHECKING:
@@ -105,13 +105,12 @@ def _validate_table_schema_has_correct_collation(
             or dialect_kwargs.get("mariadb_collate")
             or connection.dialect._fetch_setting(connection, "collation_server")  # type: ignore[attr-defined]  # noqa: SLF001
         )
-        if collate and collate != MYSQL_COLLATE:
+        if collate and collate != "utf8mb4_unicode_ci":
             _LOGGER.debug(
-                "Database %s collation is not %s",
+                "Database %s collation is not utf8mb4_unicode_ci",
                 table,
-                MYSQL_COLLATE,
             )
-            schema_errors.add(f"{table}.{MYSQL_COLLATE}")
+            schema_errors.add(f"{table}.utf8mb4_unicode_ci")
     return schema_errors
 
 
@@ -241,7 +240,7 @@ def correct_db_schema_utf8(
     table_name = table_object.__tablename__
     if (
         f"{table_name}.4-byte UTF-8" in schema_errors
-        or f"{table_name}.{MYSQL_COLLATE}" in schema_errors
+        or f"{table_name}.utf8mb4_unicode_ci" in schema_errors
     ):
         from ..migration import (  # noqa: PLC0415
             _correct_table_character_set_and_collation,

homeassistant/components/recorder/db_schema.py

@@ -71,7 +71,7 @@ class LegacyBase(DeclarativeBase):
     """Base class for tables, used for schema migration."""
 
 
-SCHEMA_VERSION = 53
+SCHEMA_VERSION = 52
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -128,7 +128,7 @@ LEGACY_STATES_ENTITY_ID_LAST_UPDATED_TS_INDEX = "ix_states_entity_id_last_update
 LEGACY_MAX_LENGTH_EVENT_CONTEXT_ID: Final = 36
 CONTEXT_ID_BIN_MAX_LENGTH = 16
 
-MYSQL_COLLATE = "utf8mb4_bin"
+MYSQL_COLLATE = "utf8mb4_unicode_ci"
 MYSQL_DEFAULT_CHARSET = "utf8mb4"
 MYSQL_ENGINE = "InnoDB"
 

homeassistant/components/recorder/migration.py

@@ -1361,7 +1361,7 @@ class _SchemaVersion20Migrator(_SchemaVersionMigrator, target_version=20):
 class _SchemaVersion21Migrator(_SchemaVersionMigrator, target_version=21):
     def _apply_update(self) -> None:
         """Version specific update method."""
-        # Try to change the character set of events, states and statistics_meta tables
+        # Try to change the character set of the statistic_meta table
         if self.engine.dialect.name == SupportedDialect.MYSQL:
             for table in ("events", "states", "statistics_meta"):
                 _correct_table_character_set_and_collation(table, self.session_maker)
@@ -2125,23 +2125,6 @@ class _SchemaVersion52Migrator(_SchemaVersionMigrator, target_version=52):
                 )
 
 
-class _SchemaVersion53Migrator(_SchemaVersionMigrator, target_version=53):
-    def _apply_update(self) -> None:
-        """Version specific update method."""
-        # Try to change the character set of events, states and statistics_meta tables
-        if self.engine.dialect.name == SupportedDialect.MYSQL:
-            for table in (
-                "events",
-                "event_data",
-                "states",
-                "state_attributes",
-                "statistics",
-                "statistics_meta",
-                "statistics_short_term",
-            ):
-                _correct_table_character_set_and_collation(table, self.session_maker)
-
-
 def _migrate_statistics_columns_to_timestamp_removing_duplicates(
     hass: HomeAssistant,
     instance: Recorder,
@@ -2184,10 +2167,8 @@ def _correct_table_character_set_and_collation(
     """Correct issues detected by validate_db_schema."""
     # Attempt to convert the table to utf8mb4
     _LOGGER.warning(
-        "Updating table %s to character set %s and collation %s. %s",
+        "Updating character set and collation of table %s to utf8mb4. %s",
         table,
-        MYSQL_DEFAULT_CHARSET,
-        MYSQL_COLLATE,
         MIGRATION_NOTE_MINUTES,
     )
     with (

homeassistant/components/remote_calendar/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["ical"],
   "quality_scale": "silver",
-  "requirements": ["ical==11.1.0"]
+  "requirements": ["ical==11.0.0"]
 }

homeassistant/components/ruuvitag_ble/__init__.py

@@ -22,7 +22,7 @@ _LOGGER = logging.getLogger(__name__)
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
-    """Set up Ruuvi BLE device from a config entry."""
+    """Set up Ruuvitag BLE device from a config entry."""
     address = entry.unique_id
     assert address is not None
     data = RuuvitagBluetoothDeviceData()

homeassistant/components/ruuvitag_ble/manifest.json

@@ -1,6 +1,6 @@
 {
   "domain": "ruuvitag_ble",
-  "name": "Ruuvi BLE",
+  "name": "RuuviTag BLE",
   "bluetooth": [
     {
       "connectable": false,

homeassistant/components/ruuvitag_ble/sensor.py

@@ -191,7 +191,7 @@ async def async_setup_entry(
     entry: config_entries.ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
-    """Set up the Ruuvi BLE sensors."""
+    """Set up the Ruuvitag BLE sensors."""
     coordinator: PassiveBluetoothProcessorCoordinator = hass.data[DOMAIN][
         entry.entry_id
     ]
@@ -210,7 +210,7 @@ class RuuvitagBluetoothSensorEntity(
     ],
     SensorEntity,
 ):
-    """Representation of a Ruuvi BLE sensor."""
+    """Representation of a Ruuvitag BLE sensor."""
 
     @property
     def native_value(self) -> int | float | None:

homeassistant/components/satel_integra/alarm_control_panel.py

@@ -3,9 +3,10 @@
 from __future__ import annotations
 
 import asyncio
+from collections import OrderedDict
 import logging
 
-from satel_integra.satel_integra import AlarmState, AsyncSatel
+from satel_integra.satel_integra import AlarmState
 
 from homeassistant.components.alarm_control_panel import (
     AlarmControlPanelEntity,
@@ -13,7 +14,7 @@ from homeassistant.components.alarm_control_panel import (
     AlarmControlPanelState,
     CodeFormat,
 )
-from homeassistant.config_entries import ConfigSubentry
+from homeassistant.const import CONF_NAME
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
@@ -25,19 +26,6 @@ from .const import (
     SUBENTRY_TYPE_PARTITION,
     SatelConfigEntry,
 )
-from .entity import SatelIntegraEntity
-
-ALARM_STATE_MAP = {
-    AlarmState.TRIGGERED: AlarmControlPanelState.TRIGGERED,
-    AlarmState.TRIGGERED_FIRE: AlarmControlPanelState.TRIGGERED,
-    AlarmState.ENTRY_TIME: AlarmControlPanelState.PENDING,
-    AlarmState.ARMED_MODE3: AlarmControlPanelState.ARMED_HOME,
-    AlarmState.ARMED_MODE2: AlarmControlPanelState.ARMED_HOME,
-    AlarmState.ARMED_MODE1: AlarmControlPanelState.ARMED_HOME,
-    AlarmState.ARMED_MODE0: AlarmControlPanelState.ARMED_AWAY,
-    AlarmState.EXIT_COUNTDOWN_OVER_10: AlarmControlPanelState.ARMING,
-    AlarmState.EXIT_COUNTDOWN_UNDER_10: AlarmControlPanelState.ARMING,
-}
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -57,54 +45,48 @@ async def async_setup_entry(
     )
 
     for subentry in partition_subentries:
-        partition_num: int = subentry.data[CONF_PARTITION_NUMBER]
-        arm_home_mode: int = subentry.data[CONF_ARM_HOME_MODE]
+        partition_num = subentry.data[CONF_PARTITION_NUMBER]
+        zone_name = subentry.data[CONF_NAME]
+        arm_home_mode = subentry.data[CONF_ARM_HOME_MODE]
 
         async_add_entities(
             [
                 SatelIntegraAlarmPanel(
                     controller,
-                    config_entry.entry_id,
-                    subentry,
-                    partition_num,
+                    zone_name,
                     arm_home_mode,
+                    partition_num,
+                    config_entry.entry_id,
                 )
             ],
             config_subentry_id=subentry.subentry_id,
         )
 
 
-class SatelIntegraAlarmPanel(SatelIntegraEntity, AlarmControlPanelEntity):
+class SatelIntegraAlarmPanel(AlarmControlPanelEntity):
     """Representation of an AlarmDecoder-based alarm panel."""
 
     _attr_code_format = CodeFormat.NUMBER
+    _attr_should_poll = False
     _attr_supported_features = (
         AlarmControlPanelEntityFeature.ARM_HOME
         | AlarmControlPanelEntityFeature.ARM_AWAY
     )
 
     def __init__(
-        self,
-        controller: AsyncSatel,
-        config_entry_id: str,
-        subentry: ConfigSubentry,
-        device_number: int,
-        arm_home_mode: int,
+        self, controller, name, arm_home_mode, partition_id, config_entry_id
     ) -> None:
         """Initialize the alarm panel."""
-        super().__init__(
-            controller,
-            config_entry_id,
-            subentry,
-            device_number,
-        )
-
+        self._attr_name = name
+        self._attr_unique_id = f"{config_entry_id}_alarm_panel_{partition_id}"
         self._arm_home_mode = arm_home_mode
+        self._partition_id = partition_id
+        self._satel = controller
 
     async def async_added_to_hass(self) -> None:
         """Update alarm status and register callbacks for future updates."""
-        self._attr_alarm_state = self._read_alarm_state()
-
+        _LOGGER.debug("Starts listening for panel messages")
+        self._update_alarm_status()
         self.async_on_remove(
             async_dispatcher_connect(
                 self.hass, SIGNAL_PANEL_MESSAGE, self._update_alarm_status
@@ -112,29 +94,55 @@ class SatelIntegraAlarmPanel(SatelIntegraEntity, AlarmControlPanelEntity):
         )
 
     @callback
-    def _update_alarm_status(self) -> None:
+    def _update_alarm_status(self):
         """Handle alarm status update."""
         state = self._read_alarm_state()
-
+        _LOGGER.debug("Got status update, current status: %s", state)
         if state != self._attr_alarm_state:
             self._attr_alarm_state = state
             self.async_write_ha_state()
+        else:
+            _LOGGER.debug("Ignoring alarm status message, same state")
 
-    def _read_alarm_state(self) -> AlarmControlPanelState | None:
+    def _read_alarm_state(self):
         """Read current status of the alarm and translate it into HA status."""
 
+        # Default - disarmed:
+        hass_alarm_status = AlarmControlPanelState.DISARMED
+
         if not self._satel.connected:
-            _LOGGER.debug("Alarm panel not connected")
             return None
 
-        for satel_state, ha_state in ALARM_STATE_MAP.items():
+        state_map = OrderedDict(
+            [
+                (AlarmState.TRIGGERED, AlarmControlPanelState.TRIGGERED),
+                (AlarmState.TRIGGERED_FIRE, AlarmControlPanelState.TRIGGERED),
+                (AlarmState.ENTRY_TIME, AlarmControlPanelState.PENDING),
+                (AlarmState.ARMED_MODE3, AlarmControlPanelState.ARMED_HOME),
+                (AlarmState.ARMED_MODE2, AlarmControlPanelState.ARMED_HOME),
+                (AlarmState.ARMED_MODE1, AlarmControlPanelState.ARMED_HOME),
+                (AlarmState.ARMED_MODE0, AlarmControlPanelState.ARMED_AWAY),
+                (
+                    AlarmState.EXIT_COUNTDOWN_OVER_10,
+                    AlarmControlPanelState.PENDING,
+                ),
+                (
+                    AlarmState.EXIT_COUNTDOWN_UNDER_10,
+                    AlarmControlPanelState.PENDING,
+                ),
+            ]
+        )
+        _LOGGER.debug("State map of Satel: %s", self._satel.partition_states)
+
+        for satel_state, ha_state in state_map.items():
             if (
                 satel_state in self._satel.partition_states
-                and self._device_number in self._satel.partition_states[satel_state]
+                and self._partition_id in self._satel.partition_states[satel_state]
             ):
-                return ha_state
+                hass_alarm_status = ha_state
+                break
 
-        return AlarmControlPanelState.DISARMED
+        return hass_alarm_status
 
     async def async_alarm_disarm(self, code: str | None = None) -> None:
         """Send disarm command."""
@@ -146,21 +154,25 @@ class SatelIntegraAlarmPanel(SatelIntegraEntity, AlarmControlPanelEntity):
             self._attr_alarm_state == AlarmControlPanelState.TRIGGERED
         )
 
-        await self._satel.disarm(code, [self._device_number])
+        _LOGGER.debug("Disarming, self._attr_alarm_state: %s", self._attr_alarm_state)
+
+        await self._satel.disarm(code, [self._partition_id])
 
         if clear_alarm_necessary:
             # Wait 1s before clearing the alarm
             await asyncio.sleep(1)
-            await self._satel.clear_alarm(code, [self._device_number])
+            await self._satel.clear_alarm(code, [self._partition_id])
 
     async def async_alarm_arm_away(self, code: str | None = None) -> None:
         """Send arm away command."""
+        _LOGGER.debug("Arming away")
 
         if code:
-            await self._satel.arm(code, [self._device_number])
+            await self._satel.arm(code, [self._partition_id])
 
     async def async_alarm_arm_home(self, code: str | None = None) -> None:
         """Send arm home command."""
+        _LOGGER.debug("Arming home")
 
         if code:
-            await self._satel.arm(code, [self._device_number], self._arm_home_mode)
+            await self._satel.arm(code, [self._partition_id], self._arm_home_mode)

homeassistant/components/satel_integra/binary_sensor.py

@@ -8,22 +8,25 @@ from homeassistant.components.binary_sensor import (
     BinarySensorDeviceClass,
     BinarySensorEntity,
 )
-from homeassistant.config_entries import ConfigSubentry
+from homeassistant.const import CONF_NAME
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .const import (
     CONF_OUTPUT_NUMBER,
+    CONF_OUTPUTS,
     CONF_ZONE_NUMBER,
     CONF_ZONE_TYPE,
+    CONF_ZONES,
+    DOMAIN,
     SIGNAL_OUTPUTS_UPDATED,
     SIGNAL_ZONES_UPDATED,
     SUBENTRY_TYPE_OUTPUT,
     SUBENTRY_TYPE_ZONE,
     SatelConfigEntry,
 )
-from .entity import SatelIntegraEntity
 
 
 async def async_setup_entry(
@@ -43,16 +46,18 @@ async def async_setup_entry(
     for subentry in zone_subentries:
         zone_num: int = subentry.data[CONF_ZONE_NUMBER]
         zone_type: BinarySensorDeviceClass = subentry.data[CONF_ZONE_TYPE]
+        zone_name: str = subentry.data[CONF_NAME]
 
         async_add_entities(
             [
                 SatelIntegraBinarySensor(
                     controller,
-                    config_entry.entry_id,
-                    subentry,
                     zone_num,
+                    zone_name,
                     zone_type,
+                    CONF_ZONES,
                     SIGNAL_ZONES_UPDATED,
+                    config_entry.entry_id,
                 )
             ],
             config_subentry_id=subentry.subentry_id,
@@ -66,44 +71,51 @@ async def async_setup_entry(
     for subentry in output_subentries:
         output_num: int = subentry.data[CONF_OUTPUT_NUMBER]
         ouput_type: BinarySensorDeviceClass = subentry.data[CONF_ZONE_TYPE]
+        output_name: str = subentry.data[CONF_NAME]
 
         async_add_entities(
             [
                 SatelIntegraBinarySensor(
                     controller,
-                    config_entry.entry_id,
-                    subentry,
                     output_num,
+                    output_name,
                     ouput_type,
+                    CONF_OUTPUTS,
                     SIGNAL_OUTPUTS_UPDATED,
+                    config_entry.entry_id,
                 )
             ],
             config_subentry_id=subentry.subentry_id,
         )
 
 
-class SatelIntegraBinarySensor(SatelIntegraEntity, BinarySensorEntity):
+class SatelIntegraBinarySensor(BinarySensorEntity):
     """Representation of an Satel Integra binary sensor."""
 
+    _attr_should_poll = False
+    _attr_has_entity_name = True
+    _attr_name = None
+
     def __init__(
         self,
         controller: AsyncSatel,
-        config_entry_id: str,
-        subentry: ConfigSubentry,
         device_number: int,
+        device_name: str,
         device_class: BinarySensorDeviceClass,
+        sensor_type: str,
         react_to_signal: str,
+        config_entry_id: str,
     ) -> None:
         """Initialize the binary_sensor."""
-        super().__init__(
-            controller,
-            config_entry_id,
-            subentry,
-            device_number,
-        )
+        self._device_number = device_number
+        self._attr_unique_id = f"{config_entry_id}_{sensor_type}_{device_number}"
+        self._react_to_signal = react_to_signal
+        self._satel = controller
 
         self._attr_device_class = device_class
-        self._react_to_signal = react_to_signal
+        self._attr_device_info = DeviceInfo(
+            name=device_name, identifiers={(DOMAIN, self._attr_unique_id)}
+        )
 
     async def async_added_to_hass(self) -> None:
         """Register callbacks."""

homeassistant/components/satel_integra/entity.py

@@ -1,58 +0,0 @@
-"""Satel Integra base entity."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from satel_integra.satel_integra import AsyncSatel
-
-from homeassistant.config_entries import ConfigSubentry
-from homeassistant.const import CONF_NAME
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.entity import Entity
-
-from .const import (
-    DOMAIN,
-    SUBENTRY_TYPE_OUTPUT,
-    SUBENTRY_TYPE_PARTITION,
-    SUBENTRY_TYPE_SWITCHABLE_OUTPUT,
-    SUBENTRY_TYPE_ZONE,
-)
-
-SubentryTypeToEntityType: dict[str, str] = {
-    SUBENTRY_TYPE_PARTITION: "alarm_panel",
-    SUBENTRY_TYPE_SWITCHABLE_OUTPUT: "switch",
-    SUBENTRY_TYPE_ZONE: "zones",
-    SUBENTRY_TYPE_OUTPUT: "outputs",
-}
-
-
-class SatelIntegraEntity(Entity):
-    """Defines a base Satel Integra entity."""
-
-    _attr_should_poll = False
-    _attr_has_entity_name = True
-    _attr_name = None
-
-    def __init__(
-        self,
-        controller: AsyncSatel,
-        config_entry_id: str,
-        subentry: ConfigSubentry,
-        device_number: int,
-    ) -> None:
-        """Initialize the Satel Integra entity."""
-
-        self._satel = controller
-        self._device_number = device_number
-
-        entity_type = SubentryTypeToEntityType[subentry.subentry_type]
-
-        if TYPE_CHECKING:
-            assert entity_type is not None
-
-        self._attr_unique_id = f"{config_entry_id}_{entity_type}_{device_number}"
-
-        self._attr_device_info = DeviceInfo(
-            name=subentry.data[CONF_NAME], identifiers={(DOMAIN, self._attr_unique_id)}
-        )

homeassistant/components/satel_integra/switch.py

@@ -7,19 +7,19 @@ from typing import Any
 from satel_integra.satel_integra import AsyncSatel
 
 from homeassistant.components.switch import SwitchEntity
-from homeassistant.config_entries import ConfigSubentry
-from homeassistant.const import CONF_CODE
+from homeassistant.const import CONF_CODE, CONF_NAME
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .const import (
     CONF_SWITCHABLE_OUTPUT_NUMBER,
+    DOMAIN,
     SIGNAL_OUTPUTS_UPDATED,
     SUBENTRY_TYPE_SWITCHABLE_OUTPUT,
     SatelConfigEntry,
 )
-from .entity import SatelIntegraEntity
 
 
 async def async_setup_entry(
@@ -38,41 +38,46 @@ async def async_setup_entry(
 
     for subentry in switchable_output_subentries:
         switchable_output_num: int = subentry.data[CONF_SWITCHABLE_OUTPUT_NUMBER]
+        switchable_output_name: str = subentry.data[CONF_NAME]
 
         async_add_entities(
             [
                 SatelIntegraSwitch(
                     controller,
-                    config_entry.entry_id,
-                    subentry,
                     switchable_output_num,
+                    switchable_output_name,
                     config_entry.options.get(CONF_CODE),
+                    config_entry.entry_id,
                 ),
             ],
             config_subentry_id=subentry.subentry_id,
         )
 
 
-class SatelIntegraSwitch(SatelIntegraEntity, SwitchEntity):
-    """Representation of an Satel Integra switch."""
+class SatelIntegraSwitch(SwitchEntity):
+    """Representation of an Satel switch."""
+
+    _attr_should_poll = False
+    _attr_has_entity_name = True
+    _attr_name = None
 
     def __init__(
         self,
         controller: AsyncSatel,
-        config_entry_id: str,
-        subentry: ConfigSubentry,
         device_number: int,
+        device_name: str,
         code: str | None,
+        config_entry_id: str,
     ) -> None:
         """Initialize the switch."""
-        super().__init__(
-            controller,
-            config_entry_id,
-            subentry,
-            device_number,
-        )
-
+        self._device_number = device_number
+        self._attr_unique_id = f"{config_entry_id}_switch_{device_number}"
         self._code = code
+        self._satel = controller
+
+        self._attr_device_info = DeviceInfo(
+            name=device_name, identifiers={(DOMAIN, self._attr_unique_id)}
+        )
 
     async def async_added_to_hass(self) -> None:
         """Register callbacks."""

homeassistant/components/sensor/icons.json

@@ -118,9 +118,6 @@
     "pm25": {
       "default": "mdi:molecule"
     },
-    "pm4": {
-      "default": "mdi:molecule"
-    },
     "power": {
       "default": "mdi:flash"
     },

homeassistant/components/senz/__init__.py

@@ -7,7 +7,6 @@ import logging
 
 from aiosenz import SENZAPI, Thermostat
 from httpx import RequestError
-import jwt
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import Platform
@@ -33,10 +32,9 @@ CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 PLATFORMS = [Platform.CLIMATE, Platform.SENSOR]
 
 type SENZDataUpdateCoordinator = DataUpdateCoordinator[dict[str, Thermostat]]
-type SENZConfigEntry = ConfigEntry[SENZDataUpdateCoordinator]
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: SENZConfigEntry) -> bool:
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up SENZ from a config entry."""
     try:
         implementation = await async_get_config_entry_implementation(hass, entry)
@@ -73,37 +71,16 @@ async def async_setup_entry(hass: HomeAssistant, entry: SENZConfigEntry) -> bool
 
     await coordinator.async_config_entry_first_refresh()
 
-    entry.runtime_data = coordinator
+    hass.data.setdefault(DOMAIN, {})[entry.entry_id] = coordinator
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: SENZConfigEntry) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
-    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
+    if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
+        hass.data[DOMAIN].pop(entry.entry_id)
 
-
-async def async_migrate_entry(
-    hass: HomeAssistant, config_entry: SENZConfigEntry
-) -> bool:
-    """Migrate old entry."""
-
-    # Use sub(ject) from access_token as unique_id
-    if config_entry.version == 1 and config_entry.minor_version == 1:
-        token = jwt.decode(
-            config_entry.data["token"]["access_token"],
-            options={"verify_signature": False},
-        )
-        uid = token["sub"]
-        hass.config_entries.async_update_entry(
-            config_entry, unique_id=uid, minor_version=2
-        )
-        _LOGGER.info(
-            "Migration to version %s.%s successful",
-            config_entry.version,
-            config_entry.minor_version,
-        )
-
-    return True
+    return unload_ok

homeassistant/components/senz/climate.py

@@ -12,23 +12,24 @@ from homeassistant.components.climate import (
     HVACAction,
     HVACMode,
 )
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import ATTR_TEMPERATURE, PRECISION_TENTHS, UnitOfTemperature
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from . import SENZConfigEntry, SENZDataUpdateCoordinator
+from . import SENZDataUpdateCoordinator
 from .const import DOMAIN
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: SENZConfigEntry,
+    entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the SENZ climate entities from a config entry."""
-    coordinator = entry.runtime_data
+    coordinator: SENZDataUpdateCoordinator = hass.data[DOMAIN][entry.entry_id]
     async_add_entities(
         SENZClimate(thermostat, coordinator) for thermostat in coordinator.data.values()
     )

homeassistant/components/senz/config_flow.py

@@ -2,9 +2,6 @@
 
 import logging
 
-import jwt
-
-from homeassistant.config_entries import ConfigFlowResult
 from homeassistant.helpers import config_entry_oauth2_flow
 
 from .const import DOMAIN
@@ -15,8 +12,6 @@ class OAuth2FlowHandler(
 ):
     """Config flow to handle SENZ OAuth2 authentication."""
 
-    VERSION = 1
-    MINOR_VERSION = 2
     DOMAIN = DOMAIN
 
     @property
@@ -28,15 +23,3 @@ class OAuth2FlowHandler(
     def extra_authorize_data(self) -> dict:
         """Extra data that needs to be appended to the authorize url."""
         return {"scope": "restapi offline_access"}
-
-    async def async_oauth_create_entry(self, data: dict) -> ConfigFlowResult:
-        """Create or update the config entry."""
-
-        token = jwt.decode(
-            data["token"]["access_token"], options={"verify_signature": False}
-        )
-        uid = token["sub"]
-        await self.async_set_unique_id(uid)
-
-        self._abort_if_unique_id_configured()
-        return await super().async_oauth_create_entry(data)

homeassistant/components/senz/diagnostics.py

@@ -3,9 +3,10 @@
 from typing import Any
 
 from homeassistant.components.diagnostics import async_redact_data
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 
-from . import SENZConfigEntry
+from .const import DOMAIN
 
 TO_REDACT = [
     "access_token",
@@ -14,11 +15,13 @@ TO_REDACT = [
 
 
 async def async_get_config_entry_diagnostics(
-    hass: HomeAssistant, entry: SENZConfigEntry
+    hass: HomeAssistant, entry: ConfigEntry
 ) -> dict[str, Any]:
     """Return diagnostics for a config entry."""
 
-    raw_data = ([device.raw_data for device in entry.runtime_data.data.values()],)
+    raw_data = (
+        [device.raw_data for device in hass.data[DOMAIN][entry.entry_id].data.values()],
+    )
 
     return {
         "entry_data": async_redact_data(entry.data, TO_REDACT),

homeassistant/components/senz/sensor.py

@@ -13,13 +13,14 @@ from homeassistant.components.sensor import (
     SensorEntityDescription,
     SensorStateClass,
 )
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import UnitOfTemperature
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from . import SENZConfigEntry, SENZDataUpdateCoordinator
+from . import SENZDataUpdateCoordinator
 from .const import DOMAIN
 
 
@@ -44,11 +45,11 @@ SENSORS: tuple[SenzSensorDescription, ...] = (
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: SENZConfigEntry,
+    entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the SENZ sensor entities from a config entry."""
-    coordinator = entry.runtime_data
+    coordinator: SENZDataUpdateCoordinator = hass.data[DOMAIN][entry.entry_id]
     async_add_entities(
         SENZSensor(thermostat, coordinator, description)
         for description in SENSORS

homeassistant/components/smartthings/strings.json

@@ -663,7 +663,7 @@
   },
   "exceptions": {
     "oauth2_implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
+      "message": "OAuth2 implementation unavailable, will retry"
     }
   },
   "issues": {

homeassistant/components/spotify/strings.json

@@ -34,7 +34,7 @@
   },
   "exceptions": {
     "oauth2_implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
+      "message": "OAuth2 implementation unavailable, will retry"
     }
   },
   "system_health": {

homeassistant/components/template/alarm_control_panel.py

@@ -219,6 +219,7 @@ class AbstractTemplateAlarmControlPanel(
         self._attr_code_arm_required: bool = config[CONF_CODE_ARM_REQUIRED]
         self._attr_code_format = config[CONF_CODE_FORMAT].value
 
+        self._state: AlarmControlPanelState | None = None
         self._attr_supported_features: AlarmControlPanelEntityFeature = (
             AlarmControlPanelEntityFeature(0)
         )
@@ -243,6 +244,11 @@ class AbstractTemplateAlarmControlPanel(
             if (action_config := config.get(action_id)) is not None:
                 yield (action_id, action_config, supported_feature)
 
+    @property
+    def alarm_state(self) -> AlarmControlPanelState | None:
+        """Return the state of the device."""
+        return self._state
+
     async def _async_handle_restored_state(self) -> None:
         if (
             (last_state := await self.async_get_last_state()) is not None
@@ -250,14 +256,14 @@ class AbstractTemplateAlarmControlPanel(
             and last_state.state in _VALID_STATES
             # The trigger might have fired already while we waited for stored data,
             # then we should not restore state
-            and self._attr_alarm_state is None
+            and self._state is None
         ):
-            self._attr_alarm_state = AlarmControlPanelState(last_state.state)
+            self._state = AlarmControlPanelState(last_state.state)
 
     def _handle_state(self, result: Any) -> None:
         # Validate state
         if result in _VALID_STATES:
-            self._attr_alarm_state = result
+            self._state = result
             _LOGGER.debug("Valid state - %s", result)
             return
 
@@ -267,7 +273,7 @@ class AbstractTemplateAlarmControlPanel(
             self.entity_id,
             ", ".join(_VALID_STATES),
         )
-        self._attr_alarm_state = None
+        self._state = None
 
     async def _async_alarm_arm(self, state: Any, script: Script | None, code: Any):
         """Arm the panel to specified state with supplied script."""
@@ -278,7 +284,7 @@ class AbstractTemplateAlarmControlPanel(
             )
 
         if self._attr_assumed_state:
-            self._attr_alarm_state = state
+            self._state = state
             self.async_write_ha_state()
 
     async def async_alarm_arm_away(self, code: str | None = None) -> None:
@@ -370,7 +376,7 @@ class StateAlarmControlPanelEntity(TemplateEntity, AbstractTemplateAlarmControlP
     @callback
     def _update_state(self, result):
         if isinstance(result, TemplateError):
-            self._attr_alarm_state = None
+            self._state = None
             return
 
         self._handle_state(result)
@@ -380,7 +386,7 @@ class StateAlarmControlPanelEntity(TemplateEntity, AbstractTemplateAlarmControlP
         """Set up templates."""
         if self._template:
             self.add_template_attribute(
-                "_attr_alarm_state", self._template, None, self._update_state
+                "_state", self._template, None, self._update_state
             )
         super()._async_setup_templates()
 

homeassistant/components/tesla_wall_connector/manifest.json

@@ -20,5 +20,5 @@
   "documentation": "https://www.home-assistant.io/integrations/tesla_wall_connector",
   "iot_class": "local_polling",
   "loggers": ["tesla_wall_connector"],
-  "requirements": ["tesla-wall-connector==1.1.0"]
+  "requirements": ["tesla-wall-connector==1.0.2"]
 }

homeassistant/components/teslemetry/update.py

@@ -237,7 +237,7 @@ class TeslemetryStreamingUpdateEntity(
         if self._download_percentage > 1 and self._download_percentage < 100:
             self._attr_in_progress = True
             self._attr_update_percentage = self._download_percentage
-        elif self._install_percentage > 10:
+        elif self._install_percentage > 1:
             self._attr_in_progress = True
             self._attr_update_percentage = self._install_percentage
         else:

homeassistant/components/tuya/const.py

@@ -709,7 +709,6 @@ class DPCode(StrEnum):
     DEW_POINT_TEMP = "dew_point_temp"
     DISINFECTION = "disinfection"
     DO_NOT_DISTURB = "do_not_disturb"
-    DOORBELL_PIC = "doorbell_pic"
     DOORCONTACT_STATE = "doorcontact_state"  # Status of door window sensor
     DOORCONTACT_STATE_2 = "doorcontact_state_2"
     DOORCONTACT_STATE_3 = "doorcontact_state_3"

homeassistant/components/tuya/diagnostics.py

@@ -2,7 +2,9 @@
 
 from __future__ import annotations
 
-from typing import Any
+from contextlib import suppress
+import json
+from typing import Any, cast
 
 from tuya_sharing import CustomerDevice
 
@@ -15,13 +17,6 @@ from homeassistant.util import dt as dt_util
 from . import TuyaConfigEntry
 from .const import DOMAIN, DPCode
 
-_REDACTED_DPCODES = {
-    DPCode.ALARM_MESSAGE,
-    DPCode.ALARM_MSG,
-    DPCode.DOORBELL_PIC,
-    DPCode.MOVEMENT_DETECT_PIC,
-}
-
 
 async def async_get_config_entry_diagnostics(
     hass: HomeAssistant, entry: TuyaConfigEntry
@@ -102,24 +97,34 @@ def _async_device_as_dict(
     # Gather Tuya states
     for dpcode, value in device.status.items():
         # These statuses may contain sensitive information, redact these..
-        if dpcode in _REDACTED_DPCODES:
+        if dpcode in {DPCode.ALARM_MESSAGE, DPCode.MOVEMENT_DETECT_PIC}:
             data["status"][dpcode] = REDACTED
             continue
 
+        with suppress(ValueError, TypeError):
+            value = json.loads(value)
         data["status"][dpcode] = value
 
     # Gather Tuya functions
     for function in device.function.values():
+        value = function.values
+        with suppress(ValueError, TypeError, AttributeError):
+            value = json.loads(cast(str, function.values))
+
         data["function"][function.code] = {
             "type": function.type,
-            "value": function.values,
+            "value": value,
         }
 
     # Gather Tuya status ranges
     for status_range in device.status_range.values():
+        value = status_range.values
+        with suppress(ValueError, TypeError, AttributeError):
+            value = json.loads(status_range.values)
+
         data["status_range"][status_range.code] = {
             "type": status_range.type,
-            "value": status_range.values,
+            "value": value,
         }
 
     # Gather information how this Tuya device is represented in Home Assistant

homeassistant/components/tuya/light.py

@@ -24,7 +24,6 @@ from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import color as color_util
-from homeassistant.util.json import json_loads_object
 
 from . import TuyaConfigEntry
 from .const import TUYA_DISCOVERY_NEW, DeviceCategory, DPCode, DPType, WorkMode
@@ -500,11 +499,11 @@ class TuyaLightEntity(TuyaEntity, LightEntity):
                 values = self.device.status_range[dpcode].values
 
             # Fetch color data type information
-            if function_data := json_loads_object(values):
+            if function_data := json.loads(values):
                 self._color_data_type = ColorTypeData(
-                    h_type=IntegerTypeData(dpcode, **cast(dict, function_data["h"])),
-                    s_type=IntegerTypeData(dpcode, **cast(dict, function_data["s"])),
-                    v_type=IntegerTypeData(dpcode, **cast(dict, function_data["v"])),
+                    h_type=IntegerTypeData(dpcode, **function_data["h"]),
+                    s_type=IntegerTypeData(dpcode, **function_data["s"]),
+                    v_type=IntegerTypeData(dpcode, **function_data["v"]),
                 )
             else:
                 # If no type is found, use a default one
@@ -771,12 +770,12 @@ class TuyaLightEntity(TuyaEntity, LightEntity):
         if not (status_data := self.device.status[self._color_data_dpcode]):
             return None
 
-        if not (status := json_loads_object(status_data)):
+        if not (status := json.loads(status_data)):
             return None
 
         return ColorData(
             type_data=self._color_data_type,
-            h_value=cast(int, status["h"]),
-            s_value=cast(int, status["s"]),
-            v_value=cast(int, status["v"]),
+            h_value=status["h"],
+            s_value=status["s"],
+            v_value=status["v"],
         )

homeassistant/components/tuya/models.py

@@ -5,11 +5,12 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 import base64
 from dataclasses import dataclass
-from typing import Any, Literal, Self, cast, overload
+import json
+from typing import Any, Literal, Self, overload
 
 from tuya_sharing import CustomerDevice
 
-from homeassistant.util.json import json_loads, json_loads_object
+from homeassistant.util.json import json_loads
 
 from .const import DPCode, DPType
 from .util import parse_dptype, remap_value
@@ -87,7 +88,7 @@ class IntegerTypeData(TypeInformation):
     @classmethod
     def from_json(cls, dpcode: DPCode, data: str) -> Self | None:
         """Load JSON string and return a IntegerTypeData object."""
-        if not (parsed := cast(dict[str, Any] | None, json_loads_object(data))):
+        if not (parsed := json.loads(data)):
             return None
 
         return cls(
@@ -110,9 +111,9 @@ class BitmapTypeInformation(TypeInformation):
     @classmethod
     def from_json(cls, dpcode: DPCode, data: str) -> Self | None:
         """Load JSON string and return a BitmapTypeInformation object."""
-        if not (parsed := json_loads_object(data)):
+        if not (parsed := json.loads(data)):
             return None
-        return cls(dpcode, **cast(dict[str, list[str]], parsed))
+        return cls(dpcode, **parsed)
 
 
 @dataclass
@@ -124,9 +125,9 @@ class EnumTypeData(TypeInformation):
     @classmethod
     def from_json(cls, dpcode: DPCode, data: str) -> Self | None:
         """Load JSON string and return a EnumTypeData object."""
-        if not (parsed := json_loads_object(data)):
+        if not (parsed := json.loads(data)):
             return None
-        return cls(dpcode, **cast(dict[str, list[str]], parsed))
+        return cls(dpcode, **parsed)
 
 
 _TYPE_INFORMATION_MAPPINGS: dict[DPType, type[TypeInformation]] = {

homeassistant/components/twitch/strings.json

@@ -61,7 +61,7 @@
   },
   "exceptions": {
     "oauth2_implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
+      "message": "OAuth2 implementation unavailable, will retry"
     }
   }
 }

homeassistant/components/velux/__init__.py

@@ -5,12 +5,7 @@ from __future__ import annotations
 from pyvlx import PyVLX, PyVLXException
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import (
-    CONF_HOST,
-    CONF_MAC,
-    CONF_PASSWORD,
-    EVENT_HOMEASSISTANT_STOP,
-)
+from homeassistant.const import CONF_HOST, CONF_PASSWORD, EVENT_HOMEASSISTANT_STOP
 from homeassistant.core import HomeAssistant, ServiceCall
 from homeassistant.helpers import device_registry as dr, issue_registry as ir
 
@@ -35,10 +30,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: VeluxConfigEntry) -> boo
 
     entry.runtime_data = pyvlx
 
-    connections = None
-    if (mac := entry.data.get(CONF_MAC)) is not None:
-        connections = {(dr.CONNECTION_NETWORK_MAC, mac)}
-
     device_registry = dr.async_get(hass)
     device_registry.async_get_or_create(
         config_entry_id=entry.entry_id,
@@ -52,7 +43,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: VeluxConfigEntry) -> boo
         sw_version=(
             str(pyvlx.klf200.version.softwareversion) if pyvlx.klf200.version else None
         ),
-        connections=connections,
     )
 
     async def on_hass_stop(event):

homeassistant/components/velux/button.py

@@ -14,8 +14,6 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from . import VeluxConfigEntry
 from .const import DOMAIN
 
-PARALLEL_UPDATES = 1
-
 
 async def async_setup_entry(
     hass: HomeAssistant,

homeassistant/components/velux/cover.py

@@ -56,32 +56,37 @@ class VeluxCover(VeluxEntity, CoverEntity):
     def __init__(self, node: OpeningDevice, config_entry_id: str) -> None:
         """Initialize VeluxCover."""
         super().__init__(node, config_entry_id)
-        # Features common to all covers
-        self._attr_supported_features = (
-            CoverEntityFeature.OPEN
-            | CoverEntityFeature.CLOSE
-            | CoverEntityFeature.SET_POSITION
-            | CoverEntityFeature.STOP
-        )
         # Window is the default device class for covers
         self._attr_device_class = CoverDeviceClass.WINDOW
         if isinstance(node, Awning):
             self._attr_device_class = CoverDeviceClass.AWNING
+        if isinstance(node, Blind):
+            self._attr_device_class = CoverDeviceClass.BLIND
+            self._is_blind = True
         if isinstance(node, GarageDoor):
             self._attr_device_class = CoverDeviceClass.GARAGE
         if isinstance(node, Gate):
             self._attr_device_class = CoverDeviceClass.GATE
         if isinstance(node, RollerShutter):
             self._attr_device_class = CoverDeviceClass.SHUTTER
-        if isinstance(node, Blind):
-            self._attr_device_class = CoverDeviceClass.BLIND
-            self._is_blind = True
-            self._attr_supported_features |= (
+
+    @property
+    def supported_features(self) -> CoverEntityFeature:
+        """Flag supported features."""
+        supported_features = (
+            CoverEntityFeature.OPEN
+            | CoverEntityFeature.CLOSE
+            | CoverEntityFeature.SET_POSITION
+            | CoverEntityFeature.STOP
+        )
+        if self.current_cover_tilt_position is not None:
+            supported_features |= (
                 CoverEntityFeature.OPEN_TILT
                 | CoverEntityFeature.CLOSE_TILT
                 | CoverEntityFeature.SET_TILT_POSITION
                 | CoverEntityFeature.STOP_TILT
             )
+        return supported_features
 
     @property
     def current_cover_position(self) -> int:

homeassistant/components/velux/quality_scale.yaml

@@ -37,7 +37,9 @@ rules:
   entity-unavailable: todo
   integration-owner: done
   log-when-unavailable: todo
-  parallel-updates: done
+  parallel-updates:
+    status: todo
+    comment: button still needs it
   reauthentication-flow: todo
   test-coverage:
     status: todo

homeassistant/components/vesync/manifest.json

@@ -13,5 +13,5 @@
   "documentation": "https://www.home-assistant.io/integrations/vesync",
   "iot_class": "cloud_polling",
   "loggers": ["pyvesync"],
-  "requirements": ["pyvesync==3.2.2"]
+  "requirements": ["pyvesync==3.2.1"]
 }

homeassistant/components/vicare/binary_sensor.py

@@ -144,11 +144,6 @@ GLOBAL_SENSORS: tuple[ViCareBinarySensorEntityDescription, ...] = (
         device_class=BinarySensorDeviceClass.DOOR,
         value_getter=lambda api: api.isValveOpen(),
     ),
-    ViCareBinarySensorEntityDescription(
-        key="ventilation_frost_protection",
-        translation_key="ventilation_frost_protection",
-        value_getter=lambda api: api.getHeatExchangerFrostProtectionActive(),
-    ),
 )
 
 

homeassistant/components/vicare/const.py

@@ -35,7 +35,6 @@ CONF_HEATING_TYPE = "heating_type"
 DEFAULT_CACHE_DURATION = 60
 
 VICARE_BAR = "bar"
-VICARE_CELSIUS = "celsius"
 VICARE_CUBIC_METER = "cubicMeter"
 VICARE_KW = "kilowatt"
 VICARE_KWH = "kilowattHour"

homeassistant/components/vicare/icons.json

@@ -16,15 +16,6 @@
       "domestic_hot_water_pump": {
         "default": "mdi:pump"
       },
-      "filter_hours": {
-        "default": "mdi:counter"
-      },
-      "filter_overdue_hours": {
-        "default": "mdi:counter"
-      },
-      "filter_remaining_hours": {
-        "default": "mdi:counter"
-      },
       "frost_protection": {
         "default": "mdi:snowflake"
       },
@@ -37,12 +28,6 @@
       "solar_pump": {
         "default": "mdi:pump"
       },
-      "supply_fan_hours": {
-        "default": "mdi:counter"
-      },
-      "supply_fan_speed": {
-        "default": "mdi:rotate-right"
-      },
       "valve": {
         "default": "mdi:pipe-valve"
       }
@@ -116,12 +101,6 @@
       "ess_state_of_charge": {
         "default": "mdi:home-battery"
       },
-      "heating_rod_hours": {
-        "default": "mdi:counter"
-      },
-      "heating_rod_starts": {
-        "default": "mdi:counter"
-      },
       "pcc_energy_consumption": {
         "default": "mdi:transmission-tower-export"
       },
@@ -137,15 +116,9 @@
       "valve_position": {
         "default": "mdi:pipe-valve"
       },
-      "ventilation_input_volumeflow": {
-        "default": "mdi:air-filter"
-      },
       "ventilation_level": {
         "default": "mdi:fan"
       },
-      "ventilation_output_volumeflow": {
-        "default": "mdi:air-filter"
-      },
       "volumetric_flow": {
         "default": "mdi:gauge"
       },

homeassistant/components/vicare/manifest.json

@@ -12,5 +12,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["PyViCare"],
-  "requirements": ["PyViCare==2.55.0"]
+  "requirements": ["PyViCare==2.54.0"]
 }

homeassistant/components/vicare/sensor.py

@@ -26,9 +26,7 @@ from homeassistant.components.sensor import (
     SensorStateClass,
 )
 from homeassistant.const import (
-    CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
     PERCENTAGE,
-    REVOLUTIONS_PER_MINUTE,
     EntityCategory,
     UnitOfEnergy,
     UnitOfMass,
@@ -44,7 +42,6 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .const import (
     VICARE_BAR,
-    VICARE_CELSIUS,
     VICARE_CUBIC_METER,
     VICARE_KW,
     VICARE_KWH,
@@ -59,9 +56,7 @@ from .utils import (
     get_burners,
     get_circuits,
     get_compressors,
-    get_condensers,
     get_device_serial,
-    get_evaporators,
     is_supported,
     normalize_state,
 )
@@ -79,7 +74,6 @@ VICARE_UNIT_TO_DEVICE_CLASS = {
 
 VICARE_UNIT_TO_HA_UNIT = {
     VICARE_BAR: UnitOfPressure.BAR,
-    VICARE_CELSIUS: UnitOfTemperature.CELSIUS,
     VICARE_CUBIC_METER: UnitOfVolume.CUBIC_METERS,
     VICARE_KW: UnitOfPower.KILO_WATT,
     VICARE_KWH: UnitOfEnergy.KILO_WATT_HOUR,
@@ -117,14 +111,6 @@ GLOBAL_SENSORS: tuple[ViCareSensorEntityDescription, ...] = (
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
     ),
-    ViCareSensorEntityDescription(
-        key="outside_humidity",
-        translation_key="outside_humidity",
-        native_unit_of_measurement=PERCENTAGE,
-        value_getter=lambda api: api.getOutsideHumidity(),
-        device_class=SensorDeviceClass.HUMIDITY,
-        state_class=SensorStateClass.MEASUREMENT,
-    ),
     ViCareSensorEntityDescription(
         key="return_temperature",
         translation_key="return_temperature",
@@ -1006,101 +992,6 @@ GLOBAL_SENSORS: tuple[ViCareSensorEntityDescription, ...] = (
         value_getter=lambda api: api.getHydraulicSeparatorTemperature(),
     ),
     SUPPLY_TEMPERATURE_SENSOR,
-    ViCareSensorEntityDescription(
-        key="supply_humidity",
-        translation_key="supply_humidity",
-        device_class=SensorDeviceClass.HUMIDITY,
-        native_unit_of_measurement=PERCENTAGE,
-        state_class=SensorStateClass.MEASUREMENT,
-        value_getter=lambda api: api.getSupplyHumidity(),
-    ),
-    ViCareSensorEntityDescription(
-        key="supply_fan_hours",
-        translation_key="supply_fan_hours",
-        native_unit_of_measurement=UnitOfTime.HOURS,
-        value_getter=lambda api: api.getSupplyFanHours(),
-        entity_category=EntityCategory.DIAGNOSTIC,
-        state_class=SensorStateClass.TOTAL_INCREASING,
-        entity_registry_enabled_default=False,
-    ),
-    ViCareSensorEntityDescription(
-        key="supply_fan_speed",
-        translation_key="supply_fan_speed",
-        native_unit_of_measurement=REVOLUTIONS_PER_MINUTE,
-        value_getter=lambda api: api.getSupplyFanSpeed(),
-        entity_category=EntityCategory.DIAGNOSTIC,
-        state_class=SensorStateClass.MEASUREMENT,
-        entity_registry_enabled_default=False,
-    ),
-    ViCareSensorEntityDescription(
-        key="filter_hours",
-        translation_key="filter_hours",
-        native_unit_of_measurement=UnitOfTime.HOURS,
-        value_getter=lambda api: api.getFilterHours(),
-        entity_category=EntityCategory.DIAGNOSTIC,
-        state_class=SensorStateClass.TOTAL_INCREASING,
-        entity_registry_enabled_default=False,
-    ),
-    ViCareSensorEntityDescription(
-        key="filter_remaining_hours",
-        translation_key="filter_remaining_hours",
-        native_unit_of_measurement=UnitOfTime.HOURS,
-        value_getter=lambda api: api.getFilterRemainingHours(),
-        entity_category=EntityCategory.DIAGNOSTIC,
-        state_class=SensorStateClass.TOTAL_INCREASING,
-        entity_registry_enabled_default=False,
-    ),
-    ViCareSensorEntityDescription(
-        key="filter_overdue_hours",
-        translation_key="filter_overdue_hours",
-        native_unit_of_measurement=UnitOfTime.HOURS,
-        value_getter=lambda api: api.getFilterOverdueHours(),
-        entity_category=EntityCategory.DIAGNOSTIC,
-        state_class=SensorStateClass.TOTAL_INCREASING,
-        entity_registry_enabled_default=False,
-    ),
-    ViCareSensorEntityDescription(
-        key="pm01",
-        device_class=SensorDeviceClass.PM1,
-        native_unit_of_measurement=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
-        state_class=SensorStateClass.MEASUREMENT,
-        value_getter=lambda api: api.getAirborneDustPM1(),
-    ),
-    ViCareSensorEntityDescription(
-        key="pm02",
-        device_class=SensorDeviceClass.PM25,
-        native_unit_of_measurement=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
-        state_class=SensorStateClass.MEASUREMENT,
-        value_getter=lambda api: api.getAirborneDustPM2d5(),
-    ),
-    ViCareSensorEntityDescription(
-        key="pm04",
-        device_class=SensorDeviceClass.PM4,
-        native_unit_of_measurement=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
-        state_class=SensorStateClass.MEASUREMENT,
-        value_getter=lambda api: api.getAirborneDustPM4(),
-    ),
-    ViCareSensorEntityDescription(
-        key="pm10",
-        device_class=SensorDeviceClass.PM10,
-        native_unit_of_measurement=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
-        state_class=SensorStateClass.MEASUREMENT,
-        value_getter=lambda api: api.getAirborneDustPM10(),
-    ),
-    ViCareSensorEntityDescription(
-        key="ventilation_input_volumeflow",
-        translation_key="ventilation_input_volumeflow",
-        native_unit_of_measurement=UnitOfVolumeFlowRate.CUBIC_METERS_PER_HOUR,
-        value_getter=lambda api: api.getSupplyVolumeFlow(),
-        state_class=SensorStateClass.MEASUREMENT,
-    ),
-    ViCareSensorEntityDescription(
-        key="ventilation_output_volumeflow",
-        translation_key="ventilation_output_volumeflow",
-        native_unit_of_measurement=UnitOfVolumeFlowRate.CUBIC_METERS_PER_HOUR,
-        value_getter=lambda api: api.getExhaustVolumeFlow(),
-        state_class=SensorStateClass.MEASUREMENT,
-    ),
 )
 
 CIRCUIT_SENSORS: tuple[ViCareSensorEntityDescription, ...] = (
@@ -1199,84 +1090,6 @@ COMPRESSOR_SENSORS: tuple[ViCareSensorEntityDescription, ...] = (
         value_getter=lambda api: normalize_state(api.getPhase()),
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
-    ViCareSensorEntityDescription(
-        key="compressor_inlet_temperature",
-        translation_key="compressor_inlet_temperature",
-        device_class=SensorDeviceClass.TEMPERATURE,
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        value_getter=lambda api: api.getCompressorInletTemperature(),
-        unit_getter=lambda api: api.getCompressorInletTemperatureUnit(),
-        entity_registry_enabled_default=False,
-    ),
-    ViCareSensorEntityDescription(
-        key="compressor_outlet_temperature",
-        translation_key="compressor_outlet_temperature",
-        device_class=SensorDeviceClass.TEMPERATURE,
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        value_getter=lambda api: api.getCompressorOutletTemperature(),
-        unit_getter=lambda api: api.getCompressorOutletTemperatureUnit(),
-        entity_registry_enabled_default=False,
-    ),
-    ViCareSensorEntityDescription(
-        key="compressor_inlet_pressure",
-        translation_key="compressor_inlet_pressure",
-        device_class=SensorDeviceClass.PRESSURE,
-        native_unit_of_measurement=UnitOfPressure.BAR,
-        value_getter=lambda api: api.getCompressorInletPressure(),
-        unit_getter=lambda api: api.getCompressorInletPressureUnit(),
-        entity_registry_enabled_default=False,
-    ),
-    ViCareSensorEntityDescription(
-        key="compressor_outlet_pressure",
-        translation_key="compressor_outlet_pressure",
-        device_class=SensorDeviceClass.PRESSURE,
-        native_unit_of_measurement=UnitOfPressure.BAR,
-        value_getter=lambda api: api.getCompressorOutletPressure(),
-        unit_getter=lambda api: api.getCompressorOutletPressureUnit(),
-        entity_registry_enabled_default=False,
-    ),
-)
-
-CONDENSER_SENSORS: tuple[ViCareSensorEntityDescription, ...] = (
-    ViCareSensorEntityDescription(
-        key="condenser_liquid_temperature",
-        translation_key="condenser_liquid_temperature",
-        device_class=SensorDeviceClass.TEMPERATURE,
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        value_getter=lambda api: api.getCondensorLiquidTemperature(),
-        unit_getter=lambda api: api.getCondensorLiquidTemperatureUnit(),
-        entity_registry_enabled_default=False,
-    ),
-    ViCareSensorEntityDescription(
-        key="condenser_subcooling_temperature",
-        translation_key="condenser_subcooling_temperature",
-        device_class=SensorDeviceClass.TEMPERATURE,
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        value_getter=lambda api: api.getCondensorSubcoolingTemperature(),
-        unit_getter=lambda api: api.getCondensorSubcoolingTemperatureUnit(),
-        entity_registry_enabled_default=False,
-    ),
-)
-
-EVAPORATOR_SENSORS: tuple[ViCareSensorEntityDescription, ...] = (
-    ViCareSensorEntityDescription(
-        key="evaporator_overheat_temperature",
-        translation_key="evaporator_overheat_temperature",
-        device_class=SensorDeviceClass.TEMPERATURE,
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        value_getter=lambda api: api.getEvaporatorOverheatTemperature(),
-        unit_getter=lambda api: api.getEvaporatorOverheatTemperatureUnit(),
-        entity_registry_enabled_default=False,
-    ),
-    ViCareSensorEntityDescription(
-        key="evaporator_liquid_temperature",
-        translation_key="evaporator_liquid_temperature",
-        device_class=SensorDeviceClass.TEMPERATURE,
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        value_getter=lambda api: api.getEvaporatorLiquidTemperature(),
-        unit_getter=lambda api: api.getEvaporatorLiquidTemperatureUnit(),
-        entity_registry_enabled_default=False,
-    ),
 )
 
 
@@ -1303,8 +1116,6 @@ def _build_entities(
             (get_circuits(device.api), CIRCUIT_SENSORS),
             (get_burners(device.api), BURNER_SENSORS),
             (get_compressors(device.api), COMPRESSOR_SENSORS),
-            (get_condensers(device.api), CONDENSER_SENSORS),
-            (get_evaporators(device.api), EVAPORATOR_SENSORS),
         ):
             entities.extend(
                 ViCareSensor(

homeassistant/components/vicare/strings.json

@@ -78,9 +78,6 @@
       },
       "valve": {
         "name": "Valve"
-      },
-      "ventilation_frost_protection": {
-        "name": "Ventilation frost protection"
       }
     },
     "button": {
@@ -215,18 +212,6 @@
       "compressor_hours_loadclass5": {
         "name": "Compressor hours load class 5"
       },
-      "compressor_inlet_pressure": {
-        "name": "Compressor inlet pressure"
-      },
-      "compressor_inlet_temperature": {
-        "name": "Compressor inlet temperature"
-      },
-      "compressor_outlet_pressure": {
-        "name": "Compressor outlet pressure"
-      },
-      "compressor_outlet_temperature": {
-        "name": "Compressor outlet temperature"
-      },
       "compressor_phase": {
         "name": "Compressor phase",
         "state": {
@@ -244,12 +229,6 @@
       "compressor_starts": {
         "name": "Compressor starts"
       },
-      "condenser_liquid_temperature": {
-        "name": "Condenser liquid temperature"
-      },
-      "condenser_subcooling_temperature": {
-        "name": "Condenser subcooling temperature"
-      },
       "dhw_storage_bottom_temperature": {
         "name": "DHW storage bottom temperature"
       },
@@ -324,21 +303,6 @@
           "standby": "[%key:common::state::standby%]"
         }
       },
-      "evaporator_liquid_temperature": {
-        "name": "Evaporator liquid temperature"
-      },
-      "evaporator_overheat_temperature": {
-        "name": "Evaporator overheat temperature"
-      },
-      "filter_hours": {
-        "name": "Filter hours"
-      },
-      "filter_overdue_hours": {
-        "name": "Filter overdue hours"
-      },
-      "filter_remaining_hours": {
-        "name": "Filter remaining hours"
-      },
       "fuel_need": {
         "name": "Fuel need"
       },
@@ -432,9 +396,6 @@
       "hydraulic_separator_temperature": {
         "name": "Hydraulic separator temperature"
       },
-      "outside_humidity": {
-        "name": "Outside humidity"
-      },
       "outside_temperature": {
         "name": "Outside temperature"
       },
@@ -538,15 +499,6 @@
       "spf_total": {
         "name": "Seasonal performance factor"
       },
-      "supply_fan_hours": {
-        "name": "Supply fan hours"
-      },
-      "supply_fan_speed": {
-        "name": "Supply fan speed"
-      },
-      "supply_humidity": {
-        "name": "Supply humidity"
-      },
       "supply_pressure": {
         "name": "Supply pressure"
       },
@@ -556,9 +508,6 @@
       "valve_position": {
         "name": "Valve position"
       },
-      "ventilation_input_volumeflow": {
-        "name": "Ventilation input volume flow"
-      },
       "ventilation_level": {
         "name": "Ventilation level",
         "state": {
@@ -569,9 +518,6 @@
           "standby": "[%key:common::state::standby%]"
         }
       },
-      "ventilation_output_volumeflow": {
-        "name": "Ventilation output volume flow"
-      },
       "ventilation_reason": {
         "name": "Ventilation reason",
         "state": {

homeassistant/components/vicare/utils.py

@@ -130,28 +130,6 @@ def get_compressors(device: PyViCareDevice) -> list[PyViCareHeatingDeviceCompone
     return []
 
 
-def get_condensers(device: PyViCareDevice) -> list[PyViCareHeatingDeviceComponent]:
-    """Return the list of condensers."""
-    try:
-        return device.condensors
-    except PyViCareNotSupportedFeatureError:
-        _LOGGER.debug("No condensers found")
-    except AttributeError as error:
-        _LOGGER.debug("No condensers found: %s", error)
-    return []
-
-
-def get_evaporators(device: PyViCareDevice) -> list[PyViCareHeatingDeviceComponent]:
-    """Return the list of evaporators."""
-    try:
-        return device.evaporators
-    except PyViCareNotSupportedFeatureError:
-        _LOGGER.debug("No evaporators found")
-    except AttributeError as error:
-        _LOGGER.debug("No evaporators found: %s", error)
-    return []
-
-
 def filter_state(state: str) -> str | None:
     """Return the state if not 'nothing' or 'unknown'."""
     return None if state in ("nothing", "unknown") else state

homeassistant/components/volvo/strings.json

@@ -363,7 +363,7 @@
       "message": "Unable to retrieve vehicle details."
     },
     "oauth2_implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
+      "message": "OAuth2 implementation unavailable, will retry"
     },
     "unauthorized": {
       "message": "Authentication failed. {message}"

homeassistant/components/withings/strings.json

@@ -334,7 +334,7 @@
   },
   "exceptions": {
     "oauth2_implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
+      "message": "OAuth2 implementation unavailable, will retry"
     }
   }
 }

homeassistant/components/xbox/__init__.py

@@ -9,12 +9,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv
 
 from .const import DOMAIN
-from .coordinator import (
-    XboxConfigEntry,
-    XboxConsolesCoordinator,
-    XboxCoordinators,
-    XboxUpdateCoordinator,
-)
+from .coordinator import XboxConfigEntry, XboxUpdateCoordinator
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -35,9 +30,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: XboxConfigEntry) -> bool
     coordinator = XboxUpdateCoordinator(hass, entry)
     await coordinator.async_config_entry_first_refresh()
 
-    consoles = XboxConsolesCoordinator(hass, entry, coordinator)
-
-    entry.runtime_data = XboxCoordinators(coordinator, consoles)
+    entry.runtime_data = coordinator
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
@@ -60,14 +53,16 @@ async def async_migrate_unique_id(hass: HomeAssistant, entry: XboxConfigEntry) -
     if entry.version == 1 and entry.minor_version < 2:
         # Migrate unique_id from `xbox` to account xuid and
         # change generic entry name to user's gamertag
-        coordinator = entry.runtime_data.status
-        xuid = coordinator.client.xuid
-        gamertag = coordinator.data.presence[xuid].gamertag
-
         return hass.config_entries.async_update_entry(
             entry,
-            unique_id=xuid,
-            title=(gamertag if entry.title == "Home Assistant Cloud" else entry.title),
+            unique_id=entry.runtime_data.client.xuid,
+            title=(
+                entry.runtime_data.data.presence[
+                    entry.runtime_data.client.xuid
+                ].gamertag
+                if entry.title == "Home Assistant Cloud"
+                else entry.title
+            ),
             minor_version=2,
         )
 

homeassistant/components/xbox/binary_sensor.py

@@ -44,6 +44,7 @@ class XboxBinarySensorEntityDescription(
     """Xbox binary sensor description."""
 
     is_on_fn: Callable[[Person], bool | None]
+    deprecated: bool | None = None
 
 
 def profile_attributes(person: Person, _: Title | None) -> dict[str, Any]:
@@ -111,7 +112,7 @@ async def async_setup_entry(
 ) -> None:
     """Set up Xbox Live friends."""
     xuids_added: set[str] = set()
-    coordinator = entry.runtime_data.status
+    coordinator = entry.runtime_data
 
     @callback
     def add_entities() -> None:
@@ -119,16 +120,16 @@ async def async_setup_entry(
 
         current_xuids = set(coordinator.data.presence)
         if new_xuids := current_xuids - xuids_added:
-            async_add_entities(
-                [
-                    XboxBinarySensorEntity(coordinator, xuid, description)
-                    for xuid in new_xuids
-                    for description in SENSOR_DESCRIPTIONS
-                    if check_deprecated_entity(
-                        hass, xuid, description, BINARY_SENSOR_DOMAIN
-                    )
-                ]
-            )
+            for xuid in new_xuids:
+                async_add_entities(
+                    [
+                        XboxBinarySensorEntity(coordinator, xuid, description)
+                        for description in SENSOR_DESCRIPTIONS
+                        if check_deprecated_entity(
+                            hass, xuid, description, BINARY_SENSOR_DOMAIN
+                        )
+                    ]
+                )
             xuids_added |= new_xuids
         xuids_added &= current_xuids
 

homeassistant/components/xbox/const.py

@@ -4,3 +4,5 @@ DOMAIN = "xbox"
 
 OAUTH2_AUTHORIZE = "https://login.live.com/oauth20_authorize.srf"
 OAUTH2_TOKEN = "https://login.live.com/oauth20_token.srf"
+
+EVENT_NEW_FAVORITE = "xbox/new_favorite"

homeassistant/components/xbox/coordinator.py

@@ -35,7 +35,7 @@ from .const import DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
-type XboxConfigEntry = ConfigEntry[XboxCoordinators]
+type XboxConfigEntry = ConfigEntry[XboxUpdateCoordinator]
 
 
 @dataclass
@@ -55,25 +55,17 @@ class XboxData:
     title_info: dict[str, Title] = field(default_factory=dict)
 
 
-@dataclass
-class XboxCoordinators:
-    """Xbox coordinators."""
-
-    status: XboxUpdateCoordinator
-    consoles: XboxConsolesCoordinator
-
-
 class XboxUpdateCoordinator(DataUpdateCoordinator[XboxData]):
     """Store Xbox Console Status."""
 
-    config_entry: XboxConfigEntry
+    config_entry: ConfigEntry
     consoles: SmartglassConsoleList
     client: XboxLiveClient
 
     def __init__(
         self,
         hass: HomeAssistant,
-        config_entry: XboxConfigEntry,
+        config_entry: ConfigEntry,
     ) -> None:
         """Initialize."""
         super().__init__(
@@ -288,43 +280,3 @@ class XboxUpdateCoordinator(DataUpdateCoordinator[XboxData]):
             for entry in self.hass.config_entries.async_entries(DOMAIN)
             if entry.unique_id is not None
         }
-
-
-class XboxConsolesCoordinator(DataUpdateCoordinator[SmartglassConsoleList]):
-    """Update list of Xbox consoles."""
-
-    config_entry: XboxConfigEntry
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        config_entry: XboxConfigEntry,
-        coordinator: XboxUpdateCoordinator,
-    ) -> None:
-        """Initialize."""
-        super().__init__(
-            hass,
-            _LOGGER,
-            config_entry=config_entry,
-            name=DOMAIN,
-            update_interval=timedelta(minutes=10),
-        )
-        self.client = coordinator.client
-        self.async_set_updated_data(coordinator.consoles)
-
-    async def _async_update_data(self) -> SmartglassConsoleList:
-        """Fetch console data."""
-
-        try:
-            return await self.client.smartglass.get_console_list()
-        except TimeoutException as e:
-            raise UpdateFailed(
-                translation_domain=DOMAIN,
-                translation_key="timeout_exception",
-            ) from e
-        except (RequestError, HTTPStatusError) as e:
-            _LOGGER.debug("Xbox exception:", exc_info=True)
-            raise UpdateFailed(
-                translation_domain=DOMAIN,
-                translation_key="request_exception",
-            ) from e

homeassistant/components/xbox/entity.py

@@ -94,7 +94,8 @@ class XboxBaseEntity(CoordinatorEntity[XboxUpdateCoordinator]):
         """Return entity specific state attributes."""
         return (
             fn(self.data, self.title_info)
-            if (fn := self.entity_description.attributes_fn)
+            if hasattr(self.entity_description, "attributes_fn")
+            and (fn := self.entity_description.attributes_fn)
             else super().extra_state_attributes
         )
 
@@ -121,7 +122,7 @@ class XboxConsoleBaseEntity(CoordinatorEntity[XboxUpdateCoordinator]):
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, console.id)},
             manufacturer="Microsoft",
-            model=MAP_MODEL.get(self._console.console_type),
+            model=MAP_MODEL.get(self._console.console_type, "Unknown"),
             name=console.name,
         )
 
@@ -134,11 +135,11 @@ class XboxConsoleBaseEntity(CoordinatorEntity[XboxUpdateCoordinator]):
 def check_deprecated_entity(
     hass: HomeAssistant,
     xuid: str,
-    entity_description: XboxBaseEntityDescription,
+    entity_description: EntityDescription,
     entity_domain: str,
 ) -> bool:
     """Check for deprecated entity and remove it."""
-    if not entity_description.deprecated:
+    if not getattr(entity_description, "deprecated", False):
         return True
     ent_reg = er.async_get(hass)
     if entity_id := ent_reg.async_get_entity_id(

homeassistant/components/xbox/image.py

@@ -64,7 +64,7 @@ async def async_setup_entry(
 ) -> None:
     """Set up Xbox images."""
 
-    coordinator = config_entry.runtime_data.status
+    coordinator = config_entry.runtime_data
 
     xuids_added: set[str] = set()
 

homeassistant/components/xbox/manifest.json

@@ -3,7 +3,7 @@
   "name": "Xbox",
   "codeowners": ["@hunterjm", "@tr4nt0r"],
   "config_flow": true,
-  "dependencies": ["application_credentials"],
+  "dependencies": ["auth", "application_credentials"],
   "dhcp": [
     {
       "hostname": "xbox*"

homeassistant/components/xbox/media_player.py

@@ -56,7 +56,7 @@ async def async_setup_entry(
 ) -> None:
     """Set up Xbox media_player from a config entry."""
 
-    coordinator = entry.runtime_data.status
+    coordinator = entry.runtime_data
 
     async_add_entities(
         [