Prevent sensor updates caused by fluctuating “last seen” timestamps in Xbox integration (#156419)

Co-authored-by: Joostlek <joostlek@outlook.com>

.github/workflows/ci.yaml

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

.github/workflows/codeql.yml

@@ -24,11 +24,11 @@ jobs:
         uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
+        uses: github/codeql-action/init@014f16e7ab1402f30e7c3329d33797e7948572db # v4.31.3
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
+        uses: github/codeql-action/analyze@014f16e7ab1402f30e7c3329d33797e7948572db # v4.31.3
         with:
           category: "/language:python"

.strict-typing

@@ -231,6 +231,7 @@ homeassistant.components.google_cloud.*
 homeassistant.components.google_drive.*
 homeassistant.components.google_photos.*
 homeassistant.components.google_sheets.*
+homeassistant.components.google_weather.*
 homeassistant.components.govee_ble.*
 homeassistant.components.gpsd.*
 homeassistant.components.greeneye_monitor.*

CODEOWNERS

@@ -607,6 +607,8 @@ build.json @home-assistant/supervisor
 /tests/components/google_tasks/ @allenporter
 /homeassistant/components/google_travel_time/ @eifinger
 /tests/components/google_travel_time/ @eifinger
+/homeassistant/components/google_weather/ @tronikos
+/tests/components/google_weather/ @tronikos
 /homeassistant/components/govee_ble/ @bdraco
 /tests/components/govee_ble/ @bdraco
 /homeassistant/components/govee_light_local/ @Galorhallen
@@ -1374,6 +1376,8 @@ build.json @home-assistant/supervisor
 /tests/components/sanix/ @tomaszsluszniak
 /homeassistant/components/satel_integra/ @Tommatheussen
 /tests/components/satel_integra/ @Tommatheussen
+/homeassistant/components/saunum/ @mettolen
+/tests/components/saunum/ @mettolen
 /homeassistant/components/scene/ @home-assistant/core
 /tests/components/scene/ @home-assistant/core
 /homeassistant/components/schedule/ @home-assistant/core

build.yaml

@@ -1,10 +1,10 @@
 image: ghcr.io/home-assistant/{arch}-homeassistant
 build_from:
-  aarch64: ghcr.io/home-assistant/aarch64-homeassistant-base:2025.10.1
-  armhf: ghcr.io/home-assistant/armhf-homeassistant-base:2025.10.1
-  armv7: ghcr.io/home-assistant/armv7-homeassistant-base:2025.10.1
-  amd64: ghcr.io/home-assistant/amd64-homeassistant-base:2025.10.1
-  i386: ghcr.io/home-assistant/i386-homeassistant-base:2025.10.1
+  aarch64: ghcr.io/home-assistant/aarch64-homeassistant-base:2025.11.0
+  armhf: ghcr.io/home-assistant/armhf-homeassistant-base:2025.11.0
+  armv7: ghcr.io/home-assistant/armv7-homeassistant-base:2025.11.0
+  amd64: ghcr.io/home-assistant/amd64-homeassistant-base:2025.11.0
+  i386: ghcr.io/home-assistant/i386-homeassistant-base:2025.11.0
 cosign:
   base_identity: https://github.com/home-assistant/docker/.*
   identity: https://github.com/home-assistant/core/.*

homeassistant/brands/google.json

@@ -15,6 +15,7 @@
     "google_tasks",
     "google_translate",
     "google_travel_time",
+    "google_weather",
     "google_wifi",
     "google",
     "nest",

homeassistant/components/alarm_control_panel/strings.json

@@ -143,28 +143,5 @@
       "name": "Trigger"
     }
   },
-  "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"
-    }
-  }
+  "title": "Alarm control panel"
 }

homeassistant/components/alarm_control_panel/trigger.py

@@ -1,283 +0,0 @@
-"""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

@@ -1,30 +0,0 @@
-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/alexa_devices/coordinator.py

@@ -16,6 +16,7 @@ from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers import device_registry as dr
+from homeassistant.helpers.debounce import Debouncer
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
 from .const import _LOGGER, CONF_LOGIN_DATA, DOMAIN
@@ -43,6 +44,9 @@ class AmazonDevicesCoordinator(DataUpdateCoordinator[dict[str, AmazonDevice]]):
             name=entry.title,
             config_entry=entry,
             update_interval=timedelta(seconds=SCAN_INTERVAL),
+            request_refresh_debouncer=Debouncer(
+                hass, _LOGGER, cooldown=30, immediate=False
+            ),
         )
         self.api = AmazonEchoApi(
             session,

homeassistant/components/assist_satellite/strings.json

@@ -98,27 +98,5 @@
       "name": "Start conversation"
     }
   },
-  "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"
-    }
-  }
+  "title": "Assist satellite"
 }

homeassistant/components/assist_satellite/trigger.py

@@ -1,140 +0,0 @@
-"""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

@@ -1,19 +0,0 @@
-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/asuswrt/bridge.py

@@ -111,8 +111,6 @@ def handle_errors_and_zip[_AsusWrtBridgeT: AsusWrtBridge](
 
             if isinstance(data, dict):
                 return dict(zip(keys, list(data.values()), strict=False))
-            if not isinstance(data, (list, tuple)):
-                raise UpdateFailed("Received invalid data type")
             return dict(zip(keys, data, strict=False))
 
         return _wrapper

homeassistant/components/bsblan/climate.py

@@ -74,8 +74,11 @@ class BSBLANClimate(BSBLanEntity, ClimateEntity):
         super().__init__(data.fast_coordinator, data)
         self._attr_unique_id = f"{format_mac(data.device.MAC)}-climate"
 
-        self._attr_min_temp = data.static.min_temp.value
-        self._attr_max_temp = data.static.max_temp.value
+        # Set temperature range if available, otherwise use Home Assistant defaults
+        if data.static.min_temp is not None and data.static.min_temp.value is not None:
+            self._attr_min_temp = data.static.min_temp.value
+        if data.static.max_temp is not None and data.static.max_temp.value is not None:
+            self._attr_max_temp = data.static.max_temp.value
         self._attr_temperature_unit = data.fast_coordinator.client.get_temperature_unit
 
     @property

homeassistant/components/bsblan/manifest.json

@@ -7,7 +7,7 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["bsblan"],
-  "requirements": ["python-bsblan==3.1.0"],
+  "requirements": ["python-bsblan==3.1.1"],
   "zeroconf": [
     {
       "name": "bsb-lan*",

homeassistant/components/climate/strings.json

@@ -285,93 +285,5 @@
       "name": "[%key:common::action::turn_on%]"
     }
   },
-  "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"
-    }
-  }
+  "title": "Climate"
 }

homeassistant/components/climate/trigger.py

@@ -1,817 +0,0 @@
-"""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

@@ -1,128 +0,0 @@
-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/cloud/__init__.py

@@ -55,6 +55,7 @@ from .const import (
     CONF_ALIASES,
     CONF_API_SERVER,
     CONF_COGNITO_CLIENT_ID,
+    CONF_DISCOVERY_SERVICE_ACTIONS,
     CONF_ENTITY_CONFIG,
     CONF_FILTER,
     CONF_GOOGLE_ACTIONS,
@@ -139,6 +140,7 @@ CONFIG_SCHEMA = vol.Schema(
                 {
                     vol.Required(CONF_MODE): vol.In([MODE_DEV]),
                     vol.Required(CONF_API_SERVER): str,
+                    vol.Optional(CONF_DISCOVERY_SERVICE_ACTIONS): {str: cv.url},
                 }
             ),
             _BASE_CONFIG_SCHEMA.extend(

homeassistant/components/cloud/const.py

@@ -79,6 +79,7 @@ CONF_ACCOUNT_LINK_SERVER = "account_link_server"
 CONF_ACCOUNTS_SERVER = "accounts_server"
 CONF_ACME_SERVER = "acme_server"
 CONF_API_SERVER = "api_server"
+CONF_DISCOVERY_SERVICE_ACTIONS = "discovery_service_actions"
 CONF_RELAYER_SERVER = "relayer_server"
 CONF_REMOTESTATE_SERVER = "remotestate_server"
 CONF_SERVICEHANDLERS_SERVER = "servicehandlers_server"

homeassistant/components/cover/strings.json

@@ -136,75 +136,5 @@
       "name": "Toggle tilt"
     }
   },
-  "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"
-    }
-  }
+  "title": "Cover"
 }

homeassistant/components/cover/trigger.py

@@ -1,453 +0,0 @@
-"""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

@@ -1,101 +0,0 @@
-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.2.20"],
+  "requirements": ["python-ecobee-api==0.3.2"],
   "single_config_entry": true,
   "zeroconf": [
     {

homeassistant/components/emoncms/quality_scale.yaml

@@ -0,0 +1,84 @@
+rules:
+  # todo : add get_feed_list to the library
+  # todo : see if we can drop some extra attributes
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: |
+      This integration does not provide additional actions.
+  appropriate-polling: done
+  brands: done
+  common-modules: done
+  config-flow-test-coverage:
+    status: todo
+    comment: |
+      test_reconfigure_api_error should use a mock config entry fixture
+      test_user_flow_failure should use a mock config entry fixture
+      move test_user_flow_* to the top of the file
+  config-flow: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: |
+      This integration does not provide additional actions.
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup:
+    status: exempt
+    comment: |
+      No events are explicitly registered by the integration.
+  entity-unique-id: done
+  has-entity-name: done
+  runtime-data: done
+  test-before-configure: done
+  test-before-setup: done
+  unique-config-entry: done
+
+  # Silver
+  action-exceptions: done
+  config-entry-unloading: done
+  docs-configuration-parameters: done
+  docs-installation-parameters: done
+  entity-unavailable: todo
+  integration-owner: done
+  log-when-unavailable: done
+  parallel-updates: todo
+  reauthentication-flow: todo
+  test-coverage:
+    status: todo
+    comment: |
+      test the entry state in test_failure
+
+  # Gold
+  devices: todo
+  diagnostics: todo
+  discovery-update-info: todo
+  discovery: todo
+  docs-data-update: done
+  docs-examples:
+    status: exempt
+    comment: |
+      This integration does not provide any automation
+  docs-known-limitations: todo
+  docs-supported-devices: todo
+  docs-supported-functions: done
+  docs-troubleshooting: done
+  docs-use-cases: todo
+  dynamic-devices: todo
+  entity-category: todo
+  entity-device-class:
+    status: todo
+    comment: change device_class=SensorDeviceClass.SIGNAL_STRENGTH to SOUND_PRESSURE
+  entity-disabled-by-default: todo
+  entity-translations: done
+  exception-translations: todo
+  icon-translations: todo
+  reconfiguration-flow: done
+  repair-issues: todo
+  stale-devices: todo
+
+  # Platinum
+  async-dependency: done
+  inject-websession: done
+  strict-typing: todo

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, TypedDict
+from typing import Literal, NotRequired, 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 a an energy meter (kWh)
+    # statistic_id of an energy meter (kWh)
     stat_energy_from: str
 
     # statistic_id of costs ($) incurred from the energy meter
@@ -58,6 +58,14 @@ 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."""
 
@@ -65,6 +73,7 @@ class GridSourceType(TypedDict):
 
     flow_from: list[FlowFromGridSourceType]
     flow_to: list[FlowToGridSourceType]
+    power: NotRequired[list[GridPowerSourceType]]
 
     cost_adjustment_day: float
 
@@ -75,6 +84,7 @@ class SolarSourceType(TypedDict):
     type: Literal["solar"]
 
     stat_energy_from: str
+    stat_rate: NotRequired[str]
     config_entry_solar_forecast: list[str] | None
 
 
@@ -85,6 +95,8 @@ class BatterySourceType(TypedDict):
 
     stat_energy_from: str
     stat_energy_to: str
+    # positive when discharging, negative when charging
+    stat_rate: NotRequired[str]
 
 
 class GasSourceType(TypedDict):
@@ -136,12 +148,15 @@ 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: str | None
+    included_in_stat: NotRequired[str]
 
 
 class EnergyPreferences(TypedDict):
@@ -194,6 +209,12 @@ 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."""
@@ -224,6 +245,10 @@ 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),
     }
 )
@@ -231,6 +256,7 @@ 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),
     }
 )
@@ -239,6 +265,7 @@ 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(
@@ -294,6 +321,7 @@ 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,6 +12,7 @@ from homeassistant.const import (
     STATE_UNAVAILABLE,
     STATE_UNKNOWN,
     UnitOfEnergy,
+    UnitOfPower,
     UnitOfVolume,
 )
 from homeassistant.core import HomeAssistant, callback, valid_entity_id
@@ -23,12 +24,17 @@ 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,
@@ -82,6 +88,10 @@ 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]),
@@ -159,7 +169,7 @@ class EnergyPreferencesValidation:
 
 
 @callback
-def _async_validate_usage_stat(
+def _async_validate_stat_common(
     hass: HomeAssistant,
     metadata: dict[str, tuple[int, recorder.models.StatisticMetaData]],
     stat_id: str,
@@ -167,37 +177,41 @@ def _async_validate_usage_stat(
     allowed_units: Mapping[str, Sequence[str]],
     unit_error: str,
     issues: ValidationIssues,
-) -> None:
-    """Validate a statistic."""
+    check_negative: bool = False,
+) -> str | None:
+    """Validate common aspects of a statistic.
+
+    Returns the entity_id if validation succeeds, None otherwise.
+    """
     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
+        return None
 
     entity_id = stat_id
 
     if not recorder.is_entity_recorded(hass, entity_id):
         issues.add_issue(hass, "recorder_untracked", entity_id)
-        return
+        return None
 
     if (state := hass.states.get(entity_id)) is None:
         issues.add_issue(hass, "entity_not_defined", entity_id)
-        return
+        return None
 
     if state.state in (STATE_UNAVAILABLE, STATE_UNKNOWN):
         issues.add_issue(hass, "entity_unavailable", entity_id, state.state)
-        return
+        return None
 
     try:
         current_value: float | None = float(state.state)
     except ValueError:
         issues.add_issue(hass, "entity_state_non_numeric", entity_id, state.state)
-        return
+        return None
 
-    if current_value is not None and current_value < 0:
+    if check_negative and 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)
@@ -211,6 +225,36 @@ def _async_validate_usage_stat(
         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 = [
@@ -255,6 +299,39 @@ 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,
@@ -309,11 +386,260 @@ 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 = []
+    validate_calls: list[functools.partial[None]] = []
     wanted_statistics_metadata: set[str] = set()
 
     result = EnergyPreferencesValidation()
@@ -327,215 +653,35 @@ async def async_validate(hass: HomeAssistant) -> EnergyPreferencesValidation:
         result.energy_sources.append(source_result)
 
         if source["type"] == "grid":
-            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,
-                        )
-                    )
+            _validate_grid_source(
+                hass,
+                source,
+                statistics_metadata,
+                wanted_statistics_metadata,
+                source_result,
+                validate_calls,
+            )
 
         elif source["type"] == "gas":
-            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,
-                )
+            _validate_gas_source(
+                hass,
+                source,
+                statistics_metadata,
+                wanted_statistics_metadata,
+                source_result,
+                validate_calls,
             )
 
-            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":
-            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,
-                )
+            _validate_water_source(
+                hass,
+                source,
+                statistics_metadata,
+                wanted_statistics_metadata,
+                source_result,
+                validate_calls,
             )
 
-            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/enphase_envoy/diagnostics.py

@@ -147,6 +147,8 @@ async def async_get_config_entry_diagnostics(
         "ctmeter_production_phases": envoy_data.ctmeter_production_phases,
         "ctmeter_consumption_phases": envoy_data.ctmeter_consumption_phases,
         "ctmeter_storage_phases": envoy_data.ctmeter_storage_phases,
+        "ctmeters": envoy_data.ctmeters,
+        "ctmeters_phases": envoy_data.ctmeters_phases,
         "dry_contact_status": envoy_data.dry_contact_status,
         "dry_contact_settings": envoy_data.dry_contact_settings,
         "inverters": envoy_data.inverters,
@@ -179,6 +181,7 @@ async def async_get_config_entry_diagnostics(
         "ct_consumption_meter": envoy.consumption_meter_type,
         "ct_production_meter": envoy.production_meter_type,
         "ct_storage_meter": envoy.storage_meter_type,
+        "ct_meters": list(envoy_data.ctmeters.keys()),
     }
 
     fixture_data: dict[str, Any] = {}

homeassistant/components/enphase_envoy/sensor.py

@@ -399,330 +399,189 @@ class EnvoyCTSensorEntityDescription(SensorEntityDescription):
     cttype: str | None = None
 
 
-CT_NET_CONSUMPTION_SENSORS = (
-    EnvoyCTSensorEntityDescription(
-        key="lifetime_net_consumption",
-        translation_key="lifetime_net_consumption",
-        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
-        state_class=SensorStateClass.TOTAL_INCREASING,
-        device_class=SensorDeviceClass.ENERGY,
-        suggested_unit_of_measurement=UnitOfEnergy.MEGA_WATT_HOUR,
-        suggested_display_precision=3,
-        value_fn=attrgetter("energy_delivered"),
-        on_phase=None,
-        cttype=CtType.NET_CONSUMPTION,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="lifetime_net_production",
-        translation_key="lifetime_net_production",
-        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
-        state_class=SensorStateClass.TOTAL_INCREASING,
-        device_class=SensorDeviceClass.ENERGY,
-        suggested_unit_of_measurement=UnitOfEnergy.MEGA_WATT_HOUR,
-        suggested_display_precision=3,
-        value_fn=attrgetter("energy_received"),
-        on_phase=None,
-        cttype=CtType.NET_CONSUMPTION,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="net_consumption",
-        translation_key="net_consumption",
-        native_unit_of_measurement=UnitOfPower.WATT,
-        state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.POWER,
-        suggested_unit_of_measurement=UnitOfPower.KILO_WATT,
-        suggested_display_precision=3,
-        value_fn=attrgetter("active_power"),
-        on_phase=None,
-        cttype=CtType.NET_CONSUMPTION,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="frequency",
-        translation_key="net_ct_frequency",
-        native_unit_of_measurement=UnitOfFrequency.HERTZ,
-        state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.FREQUENCY,
-        suggested_display_precision=1,
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("frequency"),
-        on_phase=None,
-        cttype=CtType.NET_CONSUMPTION,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="voltage",
-        translation_key="net_ct_voltage",
-        native_unit_of_measurement=UnitOfElectricPotential.VOLT,
-        state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.VOLTAGE,
-        suggested_unit_of_measurement=UnitOfElectricPotential.VOLT,
-        suggested_display_precision=1,
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("voltage"),
-        on_phase=None,
-        cttype=CtType.NET_CONSUMPTION,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="net_ct_current",
-        translation_key="net_ct_current",
-        native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
-        state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.CURRENT,
-        suggested_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
-        suggested_display_precision=3,
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("current"),
-        on_phase=None,
-        cttype=CtType.NET_CONSUMPTION,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="net_ct_powerfactor",
-        translation_key="net_ct_powerfactor",
-        device_class=SensorDeviceClass.POWER_FACTOR,
-        state_class=SensorStateClass.MEASUREMENT,
-        suggested_display_precision=2,
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("power_factor"),
-        on_phase=None,
-        cttype=CtType.NET_CONSUMPTION,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="net_consumption_ct_metering_status",
-        translation_key="net_ct_metering_status",
-        device_class=SensorDeviceClass.ENUM,
-        entity_category=EntityCategory.DIAGNOSTIC,
-        options=list(CtMeterStatus),
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("metering_status"),
-        on_phase=None,
-        cttype=CtType.NET_CONSUMPTION,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="net_consumption_ct_status_flags",
-        translation_key="net_ct_status_flags",
-        state_class=None,
-        entity_category=EntityCategory.DIAGNOSTIC,
-        entity_registry_enabled_default=False,
-        value_fn=lambda ct: 0 if ct.status_flags is None else len(ct.status_flags),
-        on_phase=None,
-        cttype=CtType.NET_CONSUMPTION,
-    ),
-)
-
-
-CT_NET_CONSUMPTION_PHASE_SENSORS = {
-    (on_phase := PHASENAMES[phase]): [
-        replace(
-            sensor,
-            key=f"{sensor.key}_l{phase + 1}",
-            translation_key=f"{sensor.translation_key}_phase",
-            entity_registry_enabled_default=False,
-            on_phase=on_phase,
-            translation_placeholders={"phase_name": f"l{phase + 1}"},
+# All ct types unified in common setup
+CT_SENSORS = (
+    [
+        EnvoyCTSensorEntityDescription(
+            key=key,
+            translation_key=key,
+            native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
+            state_class=SensorStateClass.TOTAL_INCREASING,
+            device_class=SensorDeviceClass.ENERGY,
+            suggested_unit_of_measurement=UnitOfEnergy.MEGA_WATT_HOUR,
+            suggested_display_precision=3,
+            value_fn=attrgetter("energy_delivered"),
+            on_phase=None,
+            cttype=cttype,
+        )
+        for cttype, key in (
+            (CtType.NET_CONSUMPTION, "lifetime_net_consumption"),
+            # Production CT energy_delivered is not used
+            (CtType.STORAGE, "lifetime_battery_discharged"),
         )
-        for sensor in list(CT_NET_CONSUMPTION_SENSORS)
     ]
-    for phase in range(3)
-}
-
-CT_PRODUCTION_SENSORS = (
-    EnvoyCTSensorEntityDescription(
-        key="production_ct_frequency",
-        translation_key="production_ct_frequency",
-        native_unit_of_measurement=UnitOfFrequency.HERTZ,
-        state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.FREQUENCY,
-        suggested_display_precision=1,
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("frequency"),
-        on_phase=None,
-        cttype=CtType.PRODUCTION,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="production_ct_voltage",
-        translation_key="production_ct_voltage",
-        native_unit_of_measurement=UnitOfElectricPotential.VOLT,
-        state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.VOLTAGE,
-        suggested_unit_of_measurement=UnitOfElectricPotential.VOLT,
-        suggested_display_precision=1,
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("voltage"),
-        on_phase=None,
-        cttype=CtType.PRODUCTION,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="production_ct_current",
-        translation_key="production_ct_current",
-        native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
-        state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.CURRENT,
-        suggested_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
-        suggested_display_precision=3,
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("current"),
-        on_phase=None,
-        cttype=CtType.PRODUCTION,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="production_ct_powerfactor",
-        translation_key="production_ct_powerfactor",
-        device_class=SensorDeviceClass.POWER_FACTOR,
-        state_class=SensorStateClass.MEASUREMENT,
-        suggested_display_precision=2,
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("power_factor"),
-        on_phase=None,
-        cttype=CtType.PRODUCTION,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="production_ct_metering_status",
-        translation_key="production_ct_metering_status",
-        device_class=SensorDeviceClass.ENUM,
-        options=list(CtMeterStatus),
-        entity_category=EntityCategory.DIAGNOSTIC,
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("metering_status"),
-        on_phase=None,
-        cttype=CtType.PRODUCTION,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="production_ct_status_flags",
-        translation_key="production_ct_status_flags",
-        state_class=None,
-        entity_category=EntityCategory.DIAGNOSTIC,
-        entity_registry_enabled_default=False,
-        value_fn=lambda ct: 0 if ct.status_flags is None else len(ct.status_flags),
-        on_phase=None,
-        cttype=CtType.PRODUCTION,
-    ),
-)
-
-CT_PRODUCTION_PHASE_SENSORS = {
-    (on_phase := PHASENAMES[phase]): [
-        replace(
-            sensor,
-            key=f"{sensor.key}_l{phase + 1}",
-            translation_key=f"{sensor.translation_key}_phase",
-            entity_registry_enabled_default=False,
-            on_phase=on_phase,
-            translation_placeholders={"phase_name": f"l{phase + 1}"},
+    + [
+        EnvoyCTSensorEntityDescription(
+            key=key,
+            translation_key=key,
+            native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
+            state_class=SensorStateClass.TOTAL_INCREASING,
+            device_class=SensorDeviceClass.ENERGY,
+            suggested_unit_of_measurement=UnitOfEnergy.MEGA_WATT_HOUR,
+            suggested_display_precision=3,
+            value_fn=attrgetter("energy_received"),
+            on_phase=None,
+            cttype=cttype,
+        )
+        for cttype, key in (
+            (CtType.NET_CONSUMPTION, "lifetime_net_production"),
+            # Production CT energy_received is not used
+            (CtType.STORAGE, "lifetime_battery_charged"),
+        )
+    ]
+    + [
+        EnvoyCTSensorEntityDescription(
+            key=key,
+            translation_key=key,
+            native_unit_of_measurement=UnitOfPower.WATT,
+            state_class=SensorStateClass.MEASUREMENT,
+            device_class=SensorDeviceClass.POWER,
+            suggested_unit_of_measurement=UnitOfPower.KILO_WATT,
+            suggested_display_precision=3,
+            value_fn=attrgetter("active_power"),
+            on_phase=None,
+            cttype=cttype,
+        )
+        for cttype, key in (
+            (CtType.NET_CONSUMPTION, "net_consumption"),
+            # Production CT active_power is not used
+            (CtType.STORAGE, "battery_discharge"),
+        )
+    ]
+    + [
+        EnvoyCTSensorEntityDescription(
+            key=key,
+            translation_key=(translation_key if translation_key != "" else key),
+            native_unit_of_measurement=UnitOfFrequency.HERTZ,
+            state_class=SensorStateClass.MEASUREMENT,
+            device_class=SensorDeviceClass.FREQUENCY,
+            suggested_display_precision=1,
+            entity_registry_enabled_default=False,
+            value_fn=attrgetter("frequency"),
+            on_phase=None,
+            cttype=cttype,
+        )
+        for cttype, key, translation_key in (
+            (CtType.NET_CONSUMPTION, "frequency", "net_ct_frequency"),
+            (CtType.PRODUCTION, "production_ct_frequency", ""),
+            (CtType.STORAGE, "storage_ct_frequency", ""),
+        )
+    ]
+    + [
+        EnvoyCTSensorEntityDescription(
+            key=key,
+            translation_key=(translation_key if translation_key != "" else key),
+            native_unit_of_measurement=UnitOfElectricPotential.VOLT,
+            state_class=SensorStateClass.MEASUREMENT,
+            device_class=SensorDeviceClass.VOLTAGE,
+            suggested_unit_of_measurement=UnitOfElectricPotential.VOLT,
+            suggested_display_precision=1,
+            entity_registry_enabled_default=False,
+            value_fn=attrgetter("voltage"),
+            on_phase=None,
+            cttype=cttype,
+        )
+        for cttype, key, translation_key in (
+            (CtType.NET_CONSUMPTION, "voltage", "net_ct_voltage"),
+            (CtType.PRODUCTION, "production_ct_voltage", ""),
+            (CtType.STORAGE, "storage_voltage", "storage_ct_voltage"),
+        )
+    ]
+    + [
+        EnvoyCTSensorEntityDescription(
+            key=key,
+            translation_key=key,
+            native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
+            state_class=SensorStateClass.MEASUREMENT,
+            device_class=SensorDeviceClass.CURRENT,
+            suggested_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
+            suggested_display_precision=3,
+            entity_registry_enabled_default=False,
+            value_fn=attrgetter("current"),
+            on_phase=None,
+            cttype=cttype,
+        )
+        for cttype, key in (
+            (CtType.NET_CONSUMPTION, "net_ct_current"),
+            (CtType.PRODUCTION, "production_ct_current"),
+            (CtType.STORAGE, "storage_ct_current"),
+        )
+    ]
+    + [
+        EnvoyCTSensorEntityDescription(
+            key=key,
+            translation_key=key,
+            device_class=SensorDeviceClass.POWER_FACTOR,
+            state_class=SensorStateClass.MEASUREMENT,
+            suggested_display_precision=2,
+            entity_registry_enabled_default=False,
+            value_fn=attrgetter("power_factor"),
+            on_phase=None,
+            cttype=cttype,
+        )
+        for cttype, key in (
+            (CtType.NET_CONSUMPTION, "net_ct_powerfactor"),
+            (CtType.PRODUCTION, "production_ct_powerfactor"),
+            (CtType.STORAGE, "storage_ct_powerfactor"),
+        )
+    ]
+    + [
+        EnvoyCTSensorEntityDescription(
+            key=key,
+            translation_key=(translation_key if translation_key != "" else key),
+            device_class=SensorDeviceClass.ENUM,
+            entity_category=EntityCategory.DIAGNOSTIC,
+            options=list(CtMeterStatus),
+            entity_registry_enabled_default=False,
+            value_fn=attrgetter("metering_status"),
+            on_phase=None,
+            cttype=cttype,
+        )
+        for cttype, key, translation_key in (
+            (
+                CtType.NET_CONSUMPTION,
+                "net_consumption_ct_metering_status",
+                "net_ct_metering_status",
+            ),
+            (CtType.PRODUCTION, "production_ct_metering_status", ""),
+            (CtType.STORAGE, "storage_ct_metering_status", ""),
+        )
+    ]
+    + [
+        EnvoyCTSensorEntityDescription(
+            key=key,
+            translation_key=(translation_key if translation_key != "" else key),
+            state_class=None,
+            entity_category=EntityCategory.DIAGNOSTIC,
+            entity_registry_enabled_default=False,
+            value_fn=lambda ct: 0 if ct.status_flags is None else len(ct.status_flags),
+            on_phase=None,
+            cttype=cttype,
+        )
+        for cttype, key, translation_key in (
+            (
+                CtType.NET_CONSUMPTION,
+                "net_consumption_ct_status_flags",
+                "net_ct_status_flags",
+            ),
+            (CtType.PRODUCTION, "production_ct_status_flags", ""),
+            (CtType.STORAGE, "storage_ct_status_flags", ""),
         )
-        for sensor in list(CT_PRODUCTION_SENSORS)
     ]
-    for phase in range(3)
-}
-
-CT_STORAGE_SENSORS = (
-    EnvoyCTSensorEntityDescription(
-        key="lifetime_battery_discharged",
-        translation_key="lifetime_battery_discharged",
-        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
-        state_class=SensorStateClass.TOTAL_INCREASING,
-        device_class=SensorDeviceClass.ENERGY,
-        suggested_unit_of_measurement=UnitOfEnergy.MEGA_WATT_HOUR,
-        suggested_display_precision=3,
-        value_fn=attrgetter("energy_delivered"),
-        on_phase=None,
-        cttype=CtType.STORAGE,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="lifetime_battery_charged",
-        translation_key="lifetime_battery_charged",
-        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
-        state_class=SensorStateClass.TOTAL_INCREASING,
-        device_class=SensorDeviceClass.ENERGY,
-        suggested_unit_of_measurement=UnitOfEnergy.MEGA_WATT_HOUR,
-        suggested_display_precision=3,
-        value_fn=attrgetter("energy_received"),
-        on_phase=None,
-        cttype=CtType.STORAGE,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="battery_discharge",
-        translation_key="battery_discharge",
-        native_unit_of_measurement=UnitOfPower.WATT,
-        state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.POWER,
-        suggested_unit_of_measurement=UnitOfPower.KILO_WATT,
-        suggested_display_precision=3,
-        value_fn=attrgetter("active_power"),
-        on_phase=None,
-        cttype=CtType.STORAGE,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="storage_ct_frequency",
-        translation_key="storage_ct_frequency",
-        native_unit_of_measurement=UnitOfFrequency.HERTZ,
-        state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.FREQUENCY,
-        suggested_display_precision=1,
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("frequency"),
-        on_phase=None,
-        cttype=CtType.STORAGE,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="storage_voltage",
-        translation_key="storage_ct_voltage",
-        native_unit_of_measurement=UnitOfElectricPotential.VOLT,
-        state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.VOLTAGE,
-        suggested_unit_of_measurement=UnitOfElectricPotential.VOLT,
-        suggested_display_precision=1,
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("voltage"),
-        on_phase=None,
-        cttype=CtType.STORAGE,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="storage_ct_current",
-        translation_key="storage_ct_current",
-        native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
-        state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.CURRENT,
-        suggested_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
-        suggested_display_precision=3,
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("current"),
-        on_phase=None,
-        cttype=CtType.STORAGE,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="storage_ct_powerfactor",
-        translation_key="storage_ct_powerfactor",
-        device_class=SensorDeviceClass.POWER_FACTOR,
-        state_class=SensorStateClass.MEASUREMENT,
-        suggested_display_precision=2,
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("power_factor"),
-        on_phase=None,
-        cttype=CtType.STORAGE,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="storage_ct_metering_status",
-        translation_key="storage_ct_metering_status",
-        device_class=SensorDeviceClass.ENUM,
-        options=list(CtMeterStatus),
-        entity_category=EntityCategory.DIAGNOSTIC,
-        entity_registry_enabled_default=False,
-        value_fn=attrgetter("metering_status"),
-        on_phase=None,
-        cttype=CtType.STORAGE,
-    ),
-    EnvoyCTSensorEntityDescription(
-        key="storage_ct_status_flags",
-        translation_key="storage_ct_status_flags",
-        state_class=None,
-        entity_category=EntityCategory.DIAGNOSTIC,
-        entity_registry_enabled_default=False,
-        value_fn=lambda ct: 0 if ct.status_flags is None else len(ct.status_flags),
-        on_phase=None,
-        cttype=CtType.STORAGE,
-    ),
 )
 
 
-CT_STORAGE_PHASE_SENSORS = {
+CT_PHASE_SENSORS = {
     (on_phase := PHASENAMES[phase]): [
         replace(
             sensor,
@@ -732,7 +591,7 @@ CT_STORAGE_PHASE_SENSORS = {
             on_phase=on_phase,
             translation_placeholders={"phase_name": f"l{phase + 1}"},
         )
-        for sensor in list(CT_STORAGE_SENSORS)
+        for sensor in list(CT_SENSORS)
     ]
     for phase in range(3)
 }
@@ -1060,24 +919,14 @@ async def async_setup_entry(
     if envoy_data.ctmeters:
         entities.extend(
             EnvoyCTEntity(coordinator, description)
-            for sensors in (
-                CT_NET_CONSUMPTION_SENSORS,
-                CT_PRODUCTION_SENSORS,
-                CT_STORAGE_SENSORS,
-            )
-            for description in sensors
+            for description in CT_SENSORS
             if description.cttype in envoy_data.ctmeters
         )
     # Add Current Transformer phase entities
     if ctmeters_phases := envoy_data.ctmeters_phases:
         entities.extend(
             EnvoyCTPhaseEntity(coordinator, description)
-            for sensors in (
-                CT_NET_CONSUMPTION_PHASE_SENSORS,
-                CT_PRODUCTION_PHASE_SENSORS,
-                CT_STORAGE_PHASE_SENSORS,
-            )
-            for phase, descriptions in sensors.items()
+            for phase, descriptions in CT_PHASE_SENSORS.items()
             for description in descriptions
             if (cttype := description.cttype) in ctmeters_phases
             and phase in ctmeters_phases[cttype]

homeassistant/components/foscam/camera.py

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

homeassistant/components/frontend/__init__.py

@@ -481,6 +481,13 @@ 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")
 
@@ -770,7 +777,9 @@ class ManifestJSONView(HomeAssistantView):
 @websocket_api.websocket_command(
     {
         "type": "frontend/get_icons",
-        vol.Required("category"): vol.In({"entity", "entity_component", "services"}),
+        vol.Required("category"): vol.In(
+            {"entity", "entity_component", "services", "triggers", "conditions"}
+        ),
         vol.Optional("integration"): vol.All(cv.ensure_list, [str]),
     }
 )

homeassistant/components/goodwe/__init__.py

@@ -1,13 +1,14 @@
 """The Goodwe inverter component."""
 
-from goodwe import InverterError, connect
-from goodwe.const import GOODWE_TCP_PORT, GOODWE_UDP_PORT
+from goodwe import Inverter, InverterError, connect
+from goodwe.const import GOODWE_UDP_PORT
 
-from homeassistant.const import CONF_HOST
+from homeassistant.const import CONF_HOST, CONF_PORT
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers.device_registry import DeviceInfo
 
+from .config_flow import GoodweFlowHandler
 from .const import CONF_MODEL_FAMILY, DOMAIN, PLATFORMS
 from .coordinator import GoodweConfigEntry, GoodweRuntimeData, GoodweUpdateCoordinator
 
@@ -15,28 +16,22 @@ from .coordinator import GoodweConfigEntry, GoodweRuntimeData, GoodweUpdateCoord
 async def async_setup_entry(hass: HomeAssistant, entry: GoodweConfigEntry) -> bool:
     """Set up the Goodwe components from a config entry."""
     host = entry.data[CONF_HOST]
+    port = entry.data.get(CONF_PORT, GOODWE_UDP_PORT)
     model_family = entry.data[CONF_MODEL_FAMILY]
 
     # Connect to Goodwe inverter
     try:
         inverter = await connect(
             host=host,
-            port=GOODWE_UDP_PORT,
+            port=port,
             family=model_family,
             retries=10,
         )
-    except InverterError as err_udp:
-        # First try with UDP failed, trying with the TCP port
+    except InverterError as err:
         try:
-            inverter = await connect(
-                host=host,
-                port=GOODWE_TCP_PORT,
-                family=model_family,
-                retries=10,
-            )
+            inverter = await async_check_port(hass, entry, host)
         except InverterError:
-            # Both ports are unavailable
-            raise ConfigEntryNotReady from err_udp
+            raise ConfigEntryNotReady from err
 
     device_info = DeviceInfo(
         configuration_url="https://www.semsportal.com",
@@ -66,6 +61,23 @@ async def async_setup_entry(hass: HomeAssistant, entry: GoodweConfigEntry) -> bo
     return True
 
 
+async def async_check_port(
+    hass: HomeAssistant, entry: GoodweConfigEntry, host: str
+) -> Inverter:
+    """Check the communication port of the inverter, it may have changed after a firmware update."""
+    inverter, port = await GoodweFlowHandler.async_detect_inverter_port(host=host)
+    family = type(inverter).__name__
+    hass.config_entries.async_update_entry(
+        entry,
+        data={
+            CONF_HOST: host,
+            CONF_PORT: port,
+            CONF_MODEL_FAMILY: family,
+        },
+    )
+    return inverter
+
+
 async def async_unload_entry(
     hass: HomeAssistant, config_entry: GoodweConfigEntry
 ) -> bool:
@@ -76,3 +88,31 @@ async def async_unload_entry(
 async def update_listener(hass: HomeAssistant, config_entry: GoodweConfigEntry) -> None:
     """Handle options update."""
     await hass.config_entries.async_reload(config_entry.entry_id)
+
+
+async def async_migrate_entry(
+    hass: HomeAssistant, config_entry: GoodweConfigEntry
+) -> bool:
+    """Migrate old config entries."""
+
+    if config_entry.version > 2:
+        # This means the user has downgraded from a future version
+        return False
+
+    if config_entry.version == 1:
+        # Update from version 1 to version 2 adding the PROTOCOL to the config entry
+        host = config_entry.data[CONF_HOST]
+        try:
+            inverter, port = await GoodweFlowHandler.async_detect_inverter_port(
+                host=host
+            )
+        except InverterError as err:
+            raise ConfigEntryNotReady from err
+        new_data = {
+            CONF_HOST: host,
+            CONF_PORT: port,
+            CONF_MODEL_FAMILY: type(inverter).__name__,
+        }
+        hass.config_entries.async_update_entry(config_entry, data=new_data, version=2)
+
+    return True

homeassistant/components/goodwe/config_flow.py

@@ -5,12 +5,12 @@ from __future__ import annotations
 import logging
 from typing import Any
 
-from goodwe import InverterError, connect
+from goodwe import Inverter, InverterError, connect
 from goodwe.const import GOODWE_TCP_PORT, GOODWE_UDP_PORT
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_HOST
+from homeassistant.const import CONF_HOST, CONF_PORT
 
 from .const import CONF_MODEL_FAMILY, DEFAULT_NAME, DOMAIN
 
@@ -26,9 +26,15 @@ _LOGGER = logging.getLogger(__name__)
 class GoodweFlowHandler(ConfigFlow, domain=DOMAIN):
     """Handle a Goodwe config flow."""
 
-    VERSION = 1
+    MINOR_VERSION = 2
 
-    async def _handle_successful_connection(self, inverter, host):
+    async def async_handle_successful_connection(
+        self,
+        inverter: Inverter,
+        host: str,
+        port: int,
+    ) -> ConfigFlowResult:
+        """Handle a successful connection storing it's values on the entry data."""
         await self.async_set_unique_id(inverter.serial_number)
         self._abort_if_unique_id_configured()
 
@@ -36,6 +42,7 @@ class GoodweFlowHandler(ConfigFlow, domain=DOMAIN):
             title=DEFAULT_NAME,
             data={
                 CONF_HOST: host,
+                CONF_PORT: port,
                 CONF_MODEL_FAMILY: type(inverter).__name__,
             },
         )
@@ -48,19 +55,26 @@ class GoodweFlowHandler(ConfigFlow, domain=DOMAIN):
         if user_input is not None:
             host = user_input[CONF_HOST]
             try:
-                inverter = await connect(host=host, port=GOODWE_UDP_PORT, retries=10)
+                inverter, port = await self.async_detect_inverter_port(host=host)
             except InverterError:
-                try:
-                    inverter = await connect(
-                        host=host, port=GOODWE_TCP_PORT, retries=10
-                    )
-                except InverterError:
-                    errors[CONF_HOST] = "connection_error"
-                else:
-                    return await self._handle_successful_connection(inverter, host)
+                errors[CONF_HOST] = "connection_error"
             else:
-                return await self._handle_successful_connection(inverter, host)
-
+                return await self.async_handle_successful_connection(
+                    inverter, host, port
+                )
         return self.async_show_form(
             step_id="user", data_schema=CONFIG_SCHEMA, errors=errors
         )
+
+    @staticmethod
+    async def async_detect_inverter_port(
+        host: str,
+    ) -> tuple[Inverter, int]:
+        """Detects the port of the Inverter."""
+        port = GOODWE_UDP_PORT
+        try:
+            inverter = await connect(host=host, port=port, retries=10)
+        except InverterError:
+            port = GOODWE_TCP_PORT
+            inverter = await connect(host=host, port=port, retries=10)
+        return inverter, port

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.0.0"]
+  "requirements": ["gcal-sync==8.0.0", "oauth2client==4.1.3", "ical==11.1.0"]
 }

homeassistant/components/google_tasks/todo.py

@@ -53,6 +53,9 @@ def _convert_api_item(item: dict[str, str]) -> TodoItem:
         # Due dates are returned always in UTC so we only need to
         # parse the date portion which will be interpreted as a a local date.
         due = datetime.fromisoformat(due_str).date()
+    completed: datetime | None = None
+    if (completed_str := item.get("completed")) is not None:
+        completed = datetime.fromisoformat(completed_str)
     return TodoItem(
         summary=item["title"],
         uid=item["id"],
@@ -61,6 +64,7 @@ def _convert_api_item(item: dict[str, str]) -> TodoItem:
             TodoItemStatus.NEEDS_ACTION,
         ),
         due=due,
+        completed=completed,
         description=item.get("notes"),
     )
 

homeassistant/components/google_weather/__init__.py

@@ -0,0 +1,84 @@
+"""The Google Weather integration."""
+
+from __future__ import annotations
+
+import asyncio
+
+from google_weather_api import GoogleWeatherApi
+
+from homeassistant.const import CONF_API_KEY, Platform
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .const import CONF_REFERRER
+from .coordinator import (
+    GoogleWeatherConfigEntry,
+    GoogleWeatherCurrentConditionsCoordinator,
+    GoogleWeatherDailyForecastCoordinator,
+    GoogleWeatherHourlyForecastCoordinator,
+    GoogleWeatherRuntimeData,
+    GoogleWeatherSubEntryRuntimeData,
+)
+
+_PLATFORMS: list[Platform] = [Platform.WEATHER]
+
+
+async def async_setup_entry(
+    hass: HomeAssistant, entry: GoogleWeatherConfigEntry
+) -> bool:
+    """Set up Google Weather from a config entry."""
+
+    api = GoogleWeatherApi(
+        session=async_get_clientsession(hass),
+        api_key=entry.data[CONF_API_KEY],
+        referrer=entry.data.get(CONF_REFERRER),
+        language_code=hass.config.language,
+    )
+    subentries_runtime_data: dict[str, GoogleWeatherSubEntryRuntimeData] = {}
+    for subentry in entry.subentries.values():
+        subentry_runtime_data = GoogleWeatherSubEntryRuntimeData(
+            coordinator_observation=GoogleWeatherCurrentConditionsCoordinator(
+                hass, entry, subentry, api
+            ),
+            coordinator_daily_forecast=GoogleWeatherDailyForecastCoordinator(
+                hass, entry, subentry, api
+            ),
+            coordinator_hourly_forecast=GoogleWeatherHourlyForecastCoordinator(
+                hass, entry, subentry, api
+            ),
+        )
+        subentries_runtime_data[subentry.subentry_id] = subentry_runtime_data
+    tasks = [
+        coro
+        for subentry_runtime_data in subentries_runtime_data.values()
+        for coro in (
+            subentry_runtime_data.coordinator_observation.async_config_entry_first_refresh(),
+            subentry_runtime_data.coordinator_daily_forecast.async_config_entry_first_refresh(),
+            subentry_runtime_data.coordinator_hourly_forecast.async_config_entry_first_refresh(),
+        )
+    ]
+    await asyncio.gather(*tasks)
+    entry.runtime_data = GoogleWeatherRuntimeData(
+        api=api,
+        subentries_runtime_data=subentries_runtime_data,
+    )
+
+    await hass.config_entries.async_forward_entry_setups(entry, _PLATFORMS)
+
+    entry.async_on_unload(entry.add_update_listener(async_update_options))
+
+    return True
+
+
+async def async_unload_entry(
+    hass: HomeAssistant, entry: GoogleWeatherConfigEntry
+) -> bool:
+    """Unload a config entry."""
+    return await hass.config_entries.async_unload_platforms(entry, _PLATFORMS)
+
+
+async def async_update_options(
+    hass: HomeAssistant, entry: GoogleWeatherConfigEntry
+) -> None:
+    """Update options."""
+    await hass.config_entries.async_reload(entry.entry_id)

homeassistant/components/google_weather/config_flow.py

@@ -0,0 +1,198 @@
+"""Config flow for the Google Weather integration."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from google_weather_api import GoogleWeatherApi, GoogleWeatherApiError
+import voluptuous as vol
+
+from homeassistant.config_entries import (
+    ConfigEntry,
+    ConfigEntryState,
+    ConfigFlow,
+    ConfigFlowResult,
+    ConfigSubentryFlow,
+    SubentryFlowResult,
+)
+from homeassistant.const import (
+    CONF_API_KEY,
+    CONF_LATITUDE,
+    CONF_LOCATION,
+    CONF_LONGITUDE,
+    CONF_NAME,
+)
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.data_entry_flow import section
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.selector import LocationSelector, LocationSelectorConfig
+
+from .const import CONF_REFERRER, DOMAIN, SECTION_API_KEY_OPTIONS
+
+_LOGGER = logging.getLogger(__name__)
+
+STEP_USER_DATA_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_API_KEY): str,
+        vol.Optional(SECTION_API_KEY_OPTIONS): section(
+            vol.Schema({vol.Optional(CONF_REFERRER): str}), {"collapsed": True}
+        ),
+    }
+)
+
+
+async def _validate_input(
+    user_input: dict[str, Any],
+    api: GoogleWeatherApi,
+    errors: dict[str, str],
+    description_placeholders: dict[str, str],
+) -> bool:
+    try:
+        await api.async_get_current_conditions(
+            latitude=user_input[CONF_LOCATION][CONF_LATITUDE],
+            longitude=user_input[CONF_LOCATION][CONF_LONGITUDE],
+        )
+    except GoogleWeatherApiError as err:
+        errors["base"] = "cannot_connect"
+        description_placeholders["error_message"] = str(err)
+    except Exception:
+        _LOGGER.exception("Unexpected exception")
+        errors["base"] = "unknown"
+    else:
+        return True
+    return False
+
+
+def _get_location_schema(hass: HomeAssistant) -> vol.Schema:
+    """Return the schema for a location with default values from the hass config."""
+    return vol.Schema(
+        {
+            vol.Required(CONF_NAME, default=hass.config.location_name): str,
+            vol.Required(
+                CONF_LOCATION,
+                default={
+                    CONF_LATITUDE: hass.config.latitude,
+                    CONF_LONGITUDE: hass.config.longitude,
+                },
+            ): LocationSelector(LocationSelectorConfig(radius=False)),
+        }
+    )
+
+
+def _is_location_already_configured(
+    hass: HomeAssistant, new_data: dict[str, float], epsilon: float = 1e-4
+) -> bool:
+    """Check if the location is already configured."""
+    for entry in hass.config_entries.async_entries(DOMAIN):
+        for subentry in entry.subentries.values():
+            # A more accurate way is to use the haversine formula, but for simplicity
+            # we use a simple distance check. The epsilon value is small anyway.
+            # This is mostly to capture cases where the user has slightly moved the location pin.
+            if (
+                abs(subentry.data[CONF_LATITUDE] - new_data[CONF_LATITUDE]) <= epsilon
+                and abs(subentry.data[CONF_LONGITUDE] - new_data[CONF_LONGITUDE])
+                <= epsilon
+            ):
+                return True
+    return False
+
+
+class GoogleWeatherConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Google Weather."""
+
+    VERSION = 1
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial step."""
+        errors: dict[str, str] = {}
+        description_placeholders: dict[str, str] = {
+            "api_key_url": "https://developers.google.com/maps/documentation/weather/get-api-key",
+            "restricting_api_keys_url": "https://developers.google.com/maps/api-security-best-practices#restricting-api-keys",
+        }
+        if user_input is not None:
+            api_key = user_input[CONF_API_KEY]
+            referrer = user_input.get(SECTION_API_KEY_OPTIONS, {}).get(CONF_REFERRER)
+            self._async_abort_entries_match({CONF_API_KEY: api_key})
+            if _is_location_already_configured(self.hass, user_input[CONF_LOCATION]):
+                return self.async_abort(reason="already_configured")
+            api = GoogleWeatherApi(
+                session=async_get_clientsession(self.hass),
+                api_key=api_key,
+                referrer=referrer,
+                language_code=self.hass.config.language,
+            )
+            if await _validate_input(user_input, api, errors, description_placeholders):
+                return self.async_create_entry(
+                    title="Google Weather",
+                    data={
+                        CONF_API_KEY: api_key,
+                        CONF_REFERRER: referrer,
+                    },
+                    subentries=[
+                        {
+                            "subentry_type": "location",
+                            "data": user_input[CONF_LOCATION],
+                            "title": user_input[CONF_NAME],
+                            "unique_id": None,
+                        },
+                    ],
+                )
+        else:
+            user_input = {}
+        schema = STEP_USER_DATA_SCHEMA.schema.copy()
+        schema.update(_get_location_schema(self.hass).schema)
+        return self.async_show_form(
+            step_id="user",
+            data_schema=self.add_suggested_values_to_schema(
+                vol.Schema(schema), user_input
+            ),
+            errors=errors,
+            description_placeholders=description_placeholders,
+        )
+
+    @classmethod
+    @callback
+    def async_get_supported_subentry_types(
+        cls, config_entry: ConfigEntry
+    ) -> dict[str, type[ConfigSubentryFlow]]:
+        """Return subentries supported by this integration."""
+        return {"location": LocationSubentryFlowHandler}
+
+
+class LocationSubentryFlowHandler(ConfigSubentryFlow):
+    """Handle a subentry flow for location."""
+
+    async def async_step_location(
+        self,
+        user_input: dict[str, Any] | None = None,
+    ) -> SubentryFlowResult:
+        """Handle the location step."""
+        if self._get_entry().state != ConfigEntryState.LOADED:
+            return self.async_abort(reason="entry_not_loaded")
+
+        errors: dict[str, str] = {}
+        description_placeholders: dict[str, str] = {}
+        if user_input is not None:
+            if _is_location_already_configured(self.hass, user_input[CONF_LOCATION]):
+                return self.async_abort(reason="already_configured")
+            api: GoogleWeatherApi = self._get_entry().runtime_data.api
+            if await _validate_input(user_input, api, errors, description_placeholders):
+                return self.async_create_entry(
+                    title=user_input[CONF_NAME],
+                    data=user_input[CONF_LOCATION],
+                )
+        else:
+            user_input = {}
+        return self.async_show_form(
+            step_id="location",
+            data_schema=self.add_suggested_values_to_schema(
+                _get_location_schema(self.hass), user_input
+            ),
+            errors=errors,
+            description_placeholders=description_placeholders,
+        )
+
+    async_step_user = async_step_location

homeassistant/components/google_weather/const.py

@@ -0,0 +1,8 @@
+"""Constants for the Google Weather integration."""
+
+from typing import Final
+
+DOMAIN = "google_weather"
+
+SECTION_API_KEY_OPTIONS: Final = "api_key_options"
+CONF_REFERRER: Final = "referrer"

homeassistant/components/google_weather/coordinator.py

@@ -0,0 +1,169 @@
+"""The Google Weather coordinator."""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from datetime import timedelta
+import logging
+from typing import TypeVar
+
+from google_weather_api import (
+    CurrentConditionsResponse,
+    DailyForecastResponse,
+    GoogleWeatherApi,
+    GoogleWeatherApiError,
+    HourlyForecastResponse,
+)
+
+from homeassistant.config_entries import ConfigEntry, ConfigSubentry
+from homeassistant.const import CONF_LATITUDE, CONF_LONGITUDE
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.update_coordinator import (
+    TimestampDataUpdateCoordinator,
+    UpdateFailed,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+T = TypeVar(
+    "T",
+    bound=(
+        CurrentConditionsResponse
+        | DailyForecastResponse
+        | HourlyForecastResponse
+        | None
+    ),
+)
+
+
+@dataclass
+class GoogleWeatherSubEntryRuntimeData:
+    """Runtime data for a Google Weather sub-entry."""
+
+    coordinator_observation: GoogleWeatherCurrentConditionsCoordinator
+    coordinator_daily_forecast: GoogleWeatherDailyForecastCoordinator
+    coordinator_hourly_forecast: GoogleWeatherHourlyForecastCoordinator
+
+
+@dataclass
+class GoogleWeatherRuntimeData:
+    """Runtime data for the Google Weather integration."""
+
+    api: GoogleWeatherApi
+    subentries_runtime_data: dict[str, GoogleWeatherSubEntryRuntimeData]
+
+
+type GoogleWeatherConfigEntry = ConfigEntry[GoogleWeatherRuntimeData]
+
+
+class GoogleWeatherBaseCoordinator(TimestampDataUpdateCoordinator[T]):
+    """Base class for Google Weather coordinators."""
+
+    config_entry: GoogleWeatherConfigEntry
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        config_entry: GoogleWeatherConfigEntry,
+        subentry: ConfigSubentry,
+        data_type_name: str,
+        update_interval: timedelta,
+        api_method: Callable[..., Awaitable[T]],
+    ) -> None:
+        """Initialize the data updater."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            config_entry=config_entry,
+            name=f"Google Weather {data_type_name} coordinator for {subentry.title}",
+            update_interval=update_interval,
+        )
+        self.subentry = subentry
+        self._data_type_name = data_type_name
+        self._api_method = api_method
+
+    async def _async_update_data(self) -> T:
+        """Fetch data from API and handle errors."""
+        try:
+            return await self._api_method(
+                self.subentry.data[CONF_LATITUDE],
+                self.subentry.data[CONF_LONGITUDE],
+            )
+        except GoogleWeatherApiError as err:
+            _LOGGER.error(
+                "Error fetching %s for %s: %s",
+                self._data_type_name,
+                self.subentry.title,
+                err,
+            )
+            raise UpdateFailed(f"Error fetching {self._data_type_name}") from err
+
+
+class GoogleWeatherCurrentConditionsCoordinator(
+    GoogleWeatherBaseCoordinator[CurrentConditionsResponse]
+):
+    """Handle fetching current weather conditions."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        config_entry: GoogleWeatherConfigEntry,
+        subentry: ConfigSubentry,
+        api: GoogleWeatherApi,
+    ) -> None:
+        """Initialize the data updater."""
+        super().__init__(
+            hass,
+            config_entry,
+            subentry,
+            "current weather conditions",
+            timedelta(minutes=15),
+            api.async_get_current_conditions,
+        )
+
+
+class GoogleWeatherDailyForecastCoordinator(
+    GoogleWeatherBaseCoordinator[DailyForecastResponse]
+):
+    """Handle fetching daily weather forecast."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        config_entry: GoogleWeatherConfigEntry,
+        subentry: ConfigSubentry,
+        api: GoogleWeatherApi,
+    ) -> None:
+        """Initialize the data updater."""
+        super().__init__(
+            hass,
+            config_entry,
+            subentry,
+            "daily weather forecast",
+            timedelta(hours=1),
+            api.async_get_daily_forecast,
+        )
+
+
+class GoogleWeatherHourlyForecastCoordinator(
+    GoogleWeatherBaseCoordinator[HourlyForecastResponse]
+):
+    """Handle fetching hourly weather forecast."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        config_entry: GoogleWeatherConfigEntry,
+        subentry: ConfigSubentry,
+        api: GoogleWeatherApi,
+    ) -> None:
+        """Initialize the data updater."""
+        super().__init__(
+            hass,
+            config_entry,
+            subentry,
+            "hourly weather forecast",
+            timedelta(hours=1),
+            api.async_get_hourly_forecast,
+        )

homeassistant/components/google_weather/entity.py

@@ -0,0 +1,28 @@
+"""Base entity for Google Weather."""
+
+from __future__ import annotations
+
+from homeassistant.config_entries import ConfigSubentry
+from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
+from homeassistant.helpers.entity import Entity
+
+from .const import DOMAIN
+from .coordinator import GoogleWeatherConfigEntry
+
+
+class GoogleWeatherBaseEntity(Entity):
+    """Base entity for all Google Weather entities."""
+
+    _attr_has_entity_name = True
+
+    def __init__(
+        self, config_entry: GoogleWeatherConfigEntry, subentry: ConfigSubentry
+    ) -> None:
+        """Initialize base entity."""
+        self._attr_unique_id = subentry.subentry_id
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, subentry.subentry_id)},
+            name=subentry.title,
+            manufacturer="Google",
+            entry_type=DeviceEntryType.SERVICE,
+        )

homeassistant/components/google_weather/manifest.json

@@ -0,0 +1,12 @@
+{
+  "domain": "google_weather",
+  "name": "Google Weather",
+  "codeowners": ["@tronikos"],
+  "config_flow": true,
+  "documentation": "https://www.home-assistant.io/integrations/google_weather",
+  "integration_type": "service",
+  "iot_class": "cloud_polling",
+  "loggers": ["google_weather_api"],
+  "quality_scale": "bronze",
+  "requirements": ["python-google-weather-api==0.0.4"]
+}

homeassistant/components/google_weather/quality_scale.yaml

@@ -0,0 +1,82 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: No actions.
+  appropriate-polling: done
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: No actions.
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup:
+    status: exempt
+    comment: No events subscribed.
+  entity-unique-id: done
+  has-entity-name: done
+  runtime-data: done
+  test-before-configure: done
+  test-before-setup: done
+  unique-config-entry: done
+
+  # Silver
+  action-exceptions:
+    status: exempt
+    comment: No actions.
+  config-entry-unloading: done
+  docs-configuration-parameters:
+    status: exempt
+    comment: No configuration options.
+  docs-installation-parameters: done
+  entity-unavailable: done
+  integration-owner: done
+  log-when-unavailable: done
+  parallel-updates: done
+  reauthentication-flow: todo
+  test-coverage: done
+
+  # Gold
+  devices: done
+  diagnostics: todo
+  discovery-update-info:
+    status: exempt
+    comment: No discovery.
+  discovery:
+    status: exempt
+    comment: No discovery.
+  docs-data-update: done
+  docs-examples: done
+  docs-known-limitations: done
+  docs-supported-devices:
+    status: exempt
+    comment: No physical devices.
+  docs-supported-functions: done
+  docs-troubleshooting: done
+  docs-use-cases: done
+  dynamic-devices:
+    status: exempt
+    comment: N/A
+  entity-category: done
+  entity-device-class: done
+  entity-disabled-by-default: done
+  entity-translations: done
+  exception-translations: todo
+  icon-translations: done
+  reconfiguration-flow: todo
+  repair-issues:
+    status: exempt
+    comment: No repairs.
+  stale-devices:
+    status: exempt
+    comment: N/A
+
+  # Platinum
+  async-dependency: done
+  inject-websession: done
+  strict-typing: done

homeassistant/components/google_weather/strings.json

@@ -0,0 +1,65 @@
+{
+  "config": {
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_service%]"
+    },
+    "error": {
+      "cannot_connect": "Unable to connect to the Google Weather API:\n\n{error_message}",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
+    },
+    "step": {
+      "user": {
+        "data": {
+          "api_key": "[%key:common::config_flow::data::api_key%]",
+          "location": "[%key:common::config_flow::data::location%]",
+          "name": "[%key:common::config_flow::data::name%]"
+        },
+        "data_description": {
+          "api_key": "A unique alphanumeric string that associates your Google billing account with Google Weather API",
+          "location": "Location coordinates",
+          "name": "Location name"
+        },
+        "description": "Get your API key from [here]({api_key_url}).",
+        "sections": {
+          "api_key_options": {
+            "data": {
+              "referrer": "HTTP referrer"
+            },
+            "data_description": {
+              "referrer": "Specify this only if the API key has a [website application restriction]({restricting_api_keys_url})"
+            },
+            "name": "Optional API key options"
+          }
+        }
+      }
+    }
+  },
+  "config_subentries": {
+    "location": {
+      "abort": {
+        "already_configured": "[%key:common::config_flow::abort::already_configured_location%]",
+        "entry_not_loaded": "Cannot add things while the configuration is disabled."
+      },
+      "entry_type": "Location",
+      "error": {
+        "cannot_connect": "[%key:component::google_weather::config::error::cannot_connect%]",
+        "unknown": "[%key:common::config_flow::error::unknown%]"
+      },
+      "initiate_flow": {
+        "user": "Add location"
+      },
+      "step": {
+        "location": {
+          "data": {
+            "location": "[%key:common::config_flow::data::location%]",
+            "name": "[%key:common::config_flow::data::name%]"
+          },
+          "data_description": {
+            "location": "[%key:component::google_weather::config::step::user::data_description::location%]",
+            "name": "[%key:component::google_weather::config::step::user::data_description::name%]"
+          }
+        }
+      }
+    }
+  }
+}

homeassistant/components/google_weather/weather.py

@@ -0,0 +1,366 @@
+"""Weather entity."""
+
+from __future__ import annotations
+
+from google_weather_api import (
+    DailyForecastResponse,
+    HourlyForecastResponse,
+    WeatherCondition,
+)
+
+from homeassistant.components.weather import (
+    ATTR_CONDITION_CLEAR_NIGHT,
+    ATTR_CONDITION_CLOUDY,
+    ATTR_CONDITION_HAIL,
+    ATTR_CONDITION_LIGHTNING_RAINY,
+    ATTR_CONDITION_PARTLYCLOUDY,
+    ATTR_CONDITION_POURING,
+    ATTR_CONDITION_RAINY,
+    ATTR_CONDITION_SNOWY,
+    ATTR_CONDITION_SNOWY_RAINY,
+    ATTR_CONDITION_SUNNY,
+    ATTR_CONDITION_WINDY,
+    ATTR_FORECAST_CLOUD_COVERAGE,
+    ATTR_FORECAST_CONDITION,
+    ATTR_FORECAST_HUMIDITY,
+    ATTR_FORECAST_IS_DAYTIME,
+    ATTR_FORECAST_NATIVE_APPARENT_TEMP,
+    ATTR_FORECAST_NATIVE_DEW_POINT,
+    ATTR_FORECAST_NATIVE_PRECIPITATION,
+    ATTR_FORECAST_NATIVE_PRESSURE,
+    ATTR_FORECAST_NATIVE_TEMP,
+    ATTR_FORECAST_NATIVE_TEMP_LOW,
+    ATTR_FORECAST_NATIVE_WIND_GUST_SPEED,
+    ATTR_FORECAST_NATIVE_WIND_SPEED,
+    ATTR_FORECAST_PRECIPITATION_PROBABILITY,
+    ATTR_FORECAST_TIME,
+    ATTR_FORECAST_UV_INDEX,
+    ATTR_FORECAST_WIND_BEARING,
+    CoordinatorWeatherEntity,
+    Forecast,
+    WeatherEntityFeature,
+)
+from homeassistant.config_entries import ConfigSubentry
+from homeassistant.const import (
+    UnitOfLength,
+    UnitOfPrecipitationDepth,
+    UnitOfPressure,
+    UnitOfSpeed,
+    UnitOfTemperature,
+)
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .coordinator import (
+    GoogleWeatherConfigEntry,
+    GoogleWeatherCurrentConditionsCoordinator,
+    GoogleWeatherDailyForecastCoordinator,
+    GoogleWeatherHourlyForecastCoordinator,
+)
+from .entity import GoogleWeatherBaseEntity
+
+PARALLEL_UPDATES = 0
+
+# Maps https://developers.google.com/maps/documentation/weather/weather-condition-icons
+# to https://developers.home-assistant.io/docs/core/entity/weather/#recommended-values-for-state-and-condition
+_CONDITION_MAP: dict[WeatherCondition.Type, str | None] = {
+    WeatherCondition.Type.TYPE_UNSPECIFIED: None,
+    WeatherCondition.Type.CLEAR: ATTR_CONDITION_SUNNY,
+    WeatherCondition.Type.MOSTLY_CLEAR: ATTR_CONDITION_PARTLYCLOUDY,
+    WeatherCondition.Type.PARTLY_CLOUDY: ATTR_CONDITION_PARTLYCLOUDY,
+    WeatherCondition.Type.MOSTLY_CLOUDY: ATTR_CONDITION_CLOUDY,
+    WeatherCondition.Type.CLOUDY: ATTR_CONDITION_CLOUDY,
+    WeatherCondition.Type.WINDY: ATTR_CONDITION_WINDY,
+    WeatherCondition.Type.WIND_AND_RAIN: ATTR_CONDITION_RAINY,
+    WeatherCondition.Type.LIGHT_RAIN_SHOWERS: ATTR_CONDITION_RAINY,
+    WeatherCondition.Type.CHANCE_OF_SHOWERS: ATTR_CONDITION_RAINY,
+    WeatherCondition.Type.SCATTERED_SHOWERS: ATTR_CONDITION_RAINY,
+    WeatherCondition.Type.RAIN_SHOWERS: ATTR_CONDITION_RAINY,
+    WeatherCondition.Type.HEAVY_RAIN_SHOWERS: ATTR_CONDITION_POURING,
+    WeatherCondition.Type.LIGHT_TO_MODERATE_RAIN: ATTR_CONDITION_RAINY,
+    WeatherCondition.Type.MODERATE_TO_HEAVY_RAIN: ATTR_CONDITION_POURING,
+    WeatherCondition.Type.RAIN: ATTR_CONDITION_RAINY,
+    WeatherCondition.Type.LIGHT_RAIN: ATTR_CONDITION_RAINY,
+    WeatherCondition.Type.HEAVY_RAIN: ATTR_CONDITION_POURING,
+    WeatherCondition.Type.RAIN_PERIODICALLY_HEAVY: ATTR_CONDITION_POURING,
+    WeatherCondition.Type.LIGHT_SNOW_SHOWERS: ATTR_CONDITION_SNOWY,
+    WeatherCondition.Type.CHANCE_OF_SNOW_SHOWERS: ATTR_CONDITION_SNOWY,
+    WeatherCondition.Type.SCATTERED_SNOW_SHOWERS: ATTR_CONDITION_SNOWY,
+    WeatherCondition.Type.SNOW_SHOWERS: ATTR_CONDITION_SNOWY,
+    WeatherCondition.Type.HEAVY_SNOW_SHOWERS: ATTR_CONDITION_SNOWY,
+    WeatherCondition.Type.LIGHT_TO_MODERATE_SNOW: ATTR_CONDITION_SNOWY,
+    WeatherCondition.Type.MODERATE_TO_HEAVY_SNOW: ATTR_CONDITION_SNOWY,
+    WeatherCondition.Type.SNOW: ATTR_CONDITION_SNOWY,
+    WeatherCondition.Type.LIGHT_SNOW: ATTR_CONDITION_SNOWY,
+    WeatherCondition.Type.HEAVY_SNOW: ATTR_CONDITION_SNOWY,
+    WeatherCondition.Type.SNOWSTORM: ATTR_CONDITION_SNOWY,
+    WeatherCondition.Type.SNOW_PERIODICALLY_HEAVY: ATTR_CONDITION_SNOWY,
+    WeatherCondition.Type.HEAVY_SNOW_STORM: ATTR_CONDITION_SNOWY,
+    WeatherCondition.Type.BLOWING_SNOW: ATTR_CONDITION_SNOWY,
+    WeatherCondition.Type.RAIN_AND_SNOW: ATTR_CONDITION_SNOWY_RAINY,
+    WeatherCondition.Type.HAIL: ATTR_CONDITION_HAIL,
+    WeatherCondition.Type.HAIL_SHOWERS: ATTR_CONDITION_HAIL,
+    WeatherCondition.Type.THUNDERSTORM: ATTR_CONDITION_LIGHTNING_RAINY,
+    WeatherCondition.Type.THUNDERSHOWER: ATTR_CONDITION_LIGHTNING_RAINY,
+    WeatherCondition.Type.LIGHT_THUNDERSTORM_RAIN: ATTR_CONDITION_LIGHTNING_RAINY,
+    WeatherCondition.Type.SCATTERED_THUNDERSTORMS: ATTR_CONDITION_LIGHTNING_RAINY,
+    WeatherCondition.Type.HEAVY_THUNDERSTORM: ATTR_CONDITION_LIGHTNING_RAINY,
+}
+
+
+def _get_condition(
+    api_condition: WeatherCondition.Type, is_daytime: bool
+) -> str | None:
+    """Map Google Weather condition to Home Assistant condition."""
+    cond = _CONDITION_MAP[api_condition]
+    if cond == ATTR_CONDITION_SUNNY and not is_daytime:
+        return ATTR_CONDITION_CLEAR_NIGHT
+    return cond
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: GoogleWeatherConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Add a weather entity from a config_entry."""
+    for subentry in entry.subentries.values():
+        async_add_entities(
+            [GoogleWeatherEntity(entry, subentry)],
+            config_subentry_id=subentry.subentry_id,
+        )
+
+
+class GoogleWeatherEntity(
+    CoordinatorWeatherEntity[
+        GoogleWeatherCurrentConditionsCoordinator,
+        GoogleWeatherDailyForecastCoordinator,
+        GoogleWeatherHourlyForecastCoordinator,
+        GoogleWeatherDailyForecastCoordinator,
+    ],
+    GoogleWeatherBaseEntity,
+):
+    """Representation of a Google Weather entity."""
+
+    _attr_attribution = "Data from Google Weather"
+
+    _attr_native_temperature_unit = UnitOfTemperature.CELSIUS
+    _attr_native_pressure_unit = UnitOfPressure.MBAR
+    _attr_native_wind_speed_unit = UnitOfSpeed.KILOMETERS_PER_HOUR
+    _attr_native_visibility_unit = UnitOfLength.KILOMETERS
+    _attr_native_precipitation_unit = UnitOfPrecipitationDepth.MILLIMETERS
+
+    _attr_name = None
+
+    _attr_supported_features = (
+        WeatherEntityFeature.FORECAST_DAILY
+        | WeatherEntityFeature.FORECAST_HOURLY
+        | WeatherEntityFeature.FORECAST_TWICE_DAILY
+    )
+
+    def __init__(
+        self,
+        entry: GoogleWeatherConfigEntry,
+        subentry: ConfigSubentry,
+    ) -> None:
+        """Initialize the weather entity."""
+        subentry_runtime_data = entry.runtime_data.subentries_runtime_data[
+            subentry.subentry_id
+        ]
+        super().__init__(
+            observation_coordinator=subentry_runtime_data.coordinator_observation,
+            daily_coordinator=subentry_runtime_data.coordinator_daily_forecast,
+            hourly_coordinator=subentry_runtime_data.coordinator_hourly_forecast,
+            twice_daily_coordinator=subentry_runtime_data.coordinator_daily_forecast,
+        )
+        GoogleWeatherBaseEntity.__init__(self, entry, subentry)
+
+    @property
+    def condition(self) -> str | None:
+        """Return the current condition."""
+        return _get_condition(
+            self.coordinator.data.weather_condition.type,
+            self.coordinator.data.is_daytime,
+        )
+
+    @property
+    def native_temperature(self) -> float:
+        """Return the temperature."""
+        return self.coordinator.data.temperature.degrees
+
+    @property
+    def native_apparent_temperature(self) -> float:
+        """Return the apparent temperature."""
+        return self.coordinator.data.feels_like_temperature.degrees
+
+    @property
+    def native_dew_point(self) -> float:
+        """Return the dew point."""
+        return self.coordinator.data.dew_point.degrees
+
+    @property
+    def humidity(self) -> int:
+        """Return the humidity."""
+        return self.coordinator.data.relative_humidity
+
+    @property
+    def uv_index(self) -> float:
+        """Return the UV index."""
+        return float(self.coordinator.data.uv_index)
+
+    @property
+    def native_pressure(self) -> float:
+        """Return the pressure."""
+        return self.coordinator.data.air_pressure.mean_sea_level_millibars
+
+    @property
+    def native_wind_gust_speed(self) -> float:
+        """Return the wind gust speed."""
+        return self.coordinator.data.wind.gust.value
+
+    @property
+    def native_wind_speed(self) -> float:
+        """Return the wind speed."""
+        return self.coordinator.data.wind.speed.value
+
+    @property
+    def wind_bearing(self) -> int:
+        """Return the wind bearing."""
+        return self.coordinator.data.wind.direction.degrees
+
+    @property
+    def native_visibility(self) -> float:
+        """Return the visibility."""
+        return self.coordinator.data.visibility.distance
+
+    @property
+    def cloud_coverage(self) -> float:
+        """Return the Cloud coverage in %."""
+        return float(self.coordinator.data.cloud_cover)
+
+    @callback
+    def _async_forecast_daily(self) -> list[Forecast] | None:
+        """Return the daily forecast in native units."""
+        coordinator = self.forecast_coordinators["daily"]
+        assert coordinator
+        daily_data = coordinator.data
+        assert isinstance(daily_data, DailyForecastResponse)
+        return [
+            {
+                ATTR_FORECAST_CONDITION: _get_condition(
+                    item.daytime_forecast.weather_condition.type, is_daytime=True
+                ),
+                ATTR_FORECAST_TIME: item.interval.start_time,
+                ATTR_FORECAST_HUMIDITY: item.daytime_forecast.relative_humidity,
+                ATTR_FORECAST_PRECIPITATION_PROBABILITY: max(
+                    item.daytime_forecast.precipitation.probability.percent,
+                    item.nighttime_forecast.precipitation.probability.percent,
+                ),
+                ATTR_FORECAST_CLOUD_COVERAGE: item.daytime_forecast.cloud_cover,
+                ATTR_FORECAST_NATIVE_PRECIPITATION: (
+                    item.daytime_forecast.precipitation.qpf.quantity
+                    + item.nighttime_forecast.precipitation.qpf.quantity
+                ),
+                ATTR_FORECAST_NATIVE_TEMP: item.max_temperature.degrees,
+                ATTR_FORECAST_NATIVE_TEMP_LOW: item.min_temperature.degrees,
+                ATTR_FORECAST_NATIVE_APPARENT_TEMP: (
+                    item.feels_like_max_temperature.degrees
+                ),
+                ATTR_FORECAST_WIND_BEARING: item.daytime_forecast.wind.direction.degrees,
+                ATTR_FORECAST_NATIVE_WIND_GUST_SPEED: max(
+                    item.daytime_forecast.wind.gust.value,
+                    item.nighttime_forecast.wind.gust.value,
+                ),
+                ATTR_FORECAST_NATIVE_WIND_SPEED: max(
+                    item.daytime_forecast.wind.speed.value,
+                    item.nighttime_forecast.wind.speed.value,
+                ),
+                ATTR_FORECAST_UV_INDEX: item.daytime_forecast.uv_index,
+            }
+            for item in daily_data.forecast_days
+        ]
+
+    @callback
+    def _async_forecast_hourly(self) -> list[Forecast] | None:
+        """Return the hourly forecast in native units."""
+        coordinator = self.forecast_coordinators["hourly"]
+        assert coordinator
+        hourly_data = coordinator.data
+        assert isinstance(hourly_data, HourlyForecastResponse)
+        return [
+            {
+                ATTR_FORECAST_CONDITION: _get_condition(
+                    item.weather_condition.type, item.is_daytime
+                ),
+                ATTR_FORECAST_TIME: item.interval.start_time,
+                ATTR_FORECAST_HUMIDITY: item.relative_humidity,
+                ATTR_FORECAST_PRECIPITATION_PROBABILITY: item.precipitation.probability.percent,
+                ATTR_FORECAST_CLOUD_COVERAGE: item.cloud_cover,
+                ATTR_FORECAST_NATIVE_PRECIPITATION: item.precipitation.qpf.quantity,
+                ATTR_FORECAST_NATIVE_PRESSURE: item.air_pressure.mean_sea_level_millibars,
+                ATTR_FORECAST_NATIVE_TEMP: item.temperature.degrees,
+                ATTR_FORECAST_NATIVE_APPARENT_TEMP: item.feels_like_temperature.degrees,
+                ATTR_FORECAST_WIND_BEARING: item.wind.direction.degrees,
+                ATTR_FORECAST_NATIVE_WIND_GUST_SPEED: item.wind.gust.value,
+                ATTR_FORECAST_NATIVE_WIND_SPEED: item.wind.speed.value,
+                ATTR_FORECAST_NATIVE_DEW_POINT: item.dew_point.degrees,
+                ATTR_FORECAST_UV_INDEX: item.uv_index,
+                ATTR_FORECAST_IS_DAYTIME: item.is_daytime,
+            }
+            for item in hourly_data.forecast_hours
+        ]
+
+    @callback
+    def _async_forecast_twice_daily(self) -> list[Forecast] | None:
+        """Return the twice daily forecast in native units."""
+        coordinator = self.forecast_coordinators["twice_daily"]
+        assert coordinator
+        daily_data = coordinator.data
+        assert isinstance(daily_data, DailyForecastResponse)
+        forecasts: list[Forecast] = []
+        for item in daily_data.forecast_days:
+            # Process daytime forecast
+            day_forecast = item.daytime_forecast
+            forecasts.append(
+                {
+                    ATTR_FORECAST_CONDITION: _get_condition(
+                        day_forecast.weather_condition.type, is_daytime=True
+                    ),
+                    ATTR_FORECAST_TIME: day_forecast.interval.start_time,
+                    ATTR_FORECAST_HUMIDITY: day_forecast.relative_humidity,
+                    ATTR_FORECAST_PRECIPITATION_PROBABILITY: day_forecast.precipitation.probability.percent,
+                    ATTR_FORECAST_CLOUD_COVERAGE: day_forecast.cloud_cover,
+                    ATTR_FORECAST_NATIVE_PRECIPITATION: day_forecast.precipitation.qpf.quantity,
+                    ATTR_FORECAST_NATIVE_TEMP: item.max_temperature.degrees,
+                    ATTR_FORECAST_NATIVE_APPARENT_TEMP: item.feels_like_max_temperature.degrees,
+                    ATTR_FORECAST_WIND_BEARING: day_forecast.wind.direction.degrees,
+                    ATTR_FORECAST_NATIVE_WIND_GUST_SPEED: day_forecast.wind.gust.value,
+                    ATTR_FORECAST_NATIVE_WIND_SPEED: day_forecast.wind.speed.value,
+                    ATTR_FORECAST_UV_INDEX: day_forecast.uv_index,
+                    ATTR_FORECAST_IS_DAYTIME: True,
+                }
+            )
+
+            # Process nighttime forecast
+            night_forecast = item.nighttime_forecast
+            forecasts.append(
+                {
+                    ATTR_FORECAST_CONDITION: _get_condition(
+                        night_forecast.weather_condition.type, is_daytime=False
+                    ),
+                    ATTR_FORECAST_TIME: night_forecast.interval.start_time,
+                    ATTR_FORECAST_HUMIDITY: night_forecast.relative_humidity,
+                    ATTR_FORECAST_PRECIPITATION_PROBABILITY: night_forecast.precipitation.probability.percent,
+                    ATTR_FORECAST_CLOUD_COVERAGE: night_forecast.cloud_cover,
+                    ATTR_FORECAST_NATIVE_PRECIPITATION: night_forecast.precipitation.qpf.quantity,
+                    ATTR_FORECAST_NATIVE_TEMP: item.min_temperature.degrees,
+                    ATTR_FORECAST_NATIVE_APPARENT_TEMP: item.feels_like_min_temperature.degrees,
+                    ATTR_FORECAST_WIND_BEARING: night_forecast.wind.direction.degrees,
+                    ATTR_FORECAST_NATIVE_WIND_GUST_SPEED: night_forecast.wind.gust.value,
+                    ATTR_FORECAST_NATIVE_WIND_SPEED: night_forecast.wind.speed.value,
+                    ATTR_FORECAST_UV_INDEX: night_forecast.uv_index,
+                    ATTR_FORECAST_IS_DAYTIME: False,
+                }
+            )
+
+        return forecasts

homeassistant/components/home_connect/coordinator.py

@@ -7,7 +7,7 @@ from collections import defaultdict
 from collections.abc import Callable
 from dataclasses import dataclass
 import logging
-from typing import Any, cast
+from typing import Any
 
 from aiohomeconnect.client import Client as HomeConnectClient
 from aiohomeconnect.model import (
@@ -247,14 +247,15 @@ class HomeConnectCoordinator(
                                             value=event.value,
                                         )
                                 else:
+                                    event_value = event.value
                                     if event_key in (
                                         EventKey.BSH_COMMON_ROOT_ACTIVE_PROGRAM,
                                         EventKey.BSH_COMMON_ROOT_SELECTED_PROGRAM,
-                                    ):
+                                    ) and isinstance(event_value, str):
                                         await self.update_options(
                                             event_message_ha_id,
                                             event_key,
-                                            ProgramKey(cast(str, event.value)),
+                                            ProgramKey(event_value),
                                         )
                                     events[event_key] = event
                             self._call_event_listener(event_message)

homeassistant/components/home_connect/entity.py

@@ -14,7 +14,6 @@ from aiohomeconnect.model.error import (
     TooManyRequestsError,
 )
 
-from homeassistant.const import STATE_UNAVAILABLE
 from homeassistant.core import callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.device_registry import DeviceInfo
@@ -62,10 +61,8 @@ class HomeConnectEntity(CoordinatorEntity[HomeConnectCoordinator]):
     def _handle_coordinator_update(self) -> None:
         """Handle updated data from the coordinator."""
         self.update_native_value()
-        available = self._attr_available = self.appliance.info.connected
         self.async_write_ha_state()
-        state = STATE_UNAVAILABLE if not available else self.state
-        _LOGGER.debug("Updated %s, new state: %s", self.entity_id, state)
+        _LOGGER.debug("Updated %s", self)
 
     @property
     def bsh_key(self) -> str:
@@ -80,7 +77,7 @@ class HomeConnectEntity(CoordinatorEntity[HomeConnectCoordinator]):
         as event updates should take precedence over the coordinator
         refresh.
         """
-        return self._attr_available
+        return self.appliance.info.connected and self._attr_available
 
 
 class HomeConnectOptionEntity(HomeConnectEntity):

homeassistant/components/home_connect/manifest.json

@@ -22,6 +22,6 @@
   "iot_class": "cloud_push",
   "loggers": ["aiohomeconnect"],
   "quality_scale": "platinum",
-  "requirements": ["aiohomeconnect==0.23.0"],
+  "requirements": ["aiohomeconnect==0.23.1"],
   "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(cast(ProgramKey, event.value))
-            if event
+            PROGRAMS_TRANSLATION_KEYS_MAP.get(ProgramKey(event_value))
+            if event and isinstance(event_value := event.value, str)
             else None
         )
 

homeassistant/components/home_connect/sensor.py

@@ -556,8 +556,11 @@ 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:
+    def _update_native_value(self, status: str | float | None) -> 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,9 +76,18 @@ 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,6 +6,12 @@
   "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,7 +14,6 @@ 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
@@ -24,6 +23,7 @@ from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import HomeAssistantConnectZBT2ConfigEntry
+from .config_flow import ZBT2FirmwareMixin
 from .const import DOMAIN, FIRMWARE, FIRMWARE_VERSION, HARDWARE_NAME, SERIAL_NUMBER
 
 _LOGGER = logging.getLogger(__name__)
@@ -134,7 +134,8 @@ async def async_setup_entry(
 class FirmwareUpdateEntity(BaseFirmwareUpdateEntity):
     """Connect ZBT-2 firmware update entity."""
 
-    bootloader_reset_methods = [ResetTarget.RTS_DTR]
+    BOOTLOADER_RESET_METHODS = ZBT2FirmwareMixin.BOOTLOADER_RESET_METHODS
+    APPLICATION_PROBE_METHODS = ZBT2FirmwareMixin.APPLICATION_PROBE_METHODS
 
     def __init__(
         self,

homeassistant/components/homeassistant_hardware/firmware_config_flow.py

@@ -81,6 +81,7 @@ 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
@@ -230,7 +231,11 @@ 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)
+        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,
+        )
 
         firmware_install_required = self._probed_firmware_info is None or (
             self._probed_firmware_info.firmware_type != expected_installed_firmware_type
@@ -295,6 +300,7 @@ 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.0.37",
+    "universal-silabs-flasher==0.1.0",
     "ha-silabs-firmware-client==0.3.0"
   ]
 }

homeassistant/components/homeassistant_hardware/update.py

@@ -86,7 +86,8 @@ class BaseFirmwareUpdateEntity(
 
     # Subclasses provide the mapping between firmware types and entity descriptions
     entity_description: FirmwareUpdateEntityDescription
-    bootloader_reset_methods: list[ResetTarget] = []
+    BOOTLOADER_RESET_METHODS: list[ResetTarget]
+    APPLICATION_PROBE_METHODS: list[tuple[ApplicationType, int]]
 
     _attr_supported_features = (
         UpdateEntityFeature.INSTALL | UpdateEntityFeature.PROGRESS
@@ -278,7 +279,8 @@ 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,
+                bootloader_reset_methods=self.BOOTLOADER_RESET_METHODS,
+                application_probe_methods=self.APPLICATION_PROBE_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, Iterable, Sequence
+from collections.abc import AsyncIterator, Callable, Sequence
 from contextlib import AsyncExitStack, asynccontextmanager
 from dataclasses import dataclass
 from enum import StrEnum
@@ -309,15 +309,20 @@ async def guess_firmware_info(hass: HomeAssistant, device_path: str) -> Firmware
 
 
 async def probe_silabs_firmware_info(
-    device: str, *, probe_methods: Iterable[ApplicationType] | None = None
+    device: str,
+    *,
+    bootloader_reset_methods: Sequence[ResetTarget],
+    application_probe_methods: Sequence[tuple[ApplicationType, int]],
 ) -> FirmwareInfo | None:
     """Probe the running firmware on a SiLabs device."""
     flasher = Flasher(
         device=device,
-        **(
-            {"probe_methods": [m.as_flasher_application_type() for m in probe_methods]}
-            if probe_methods
-            else {}
+        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
         ),
     )
 
@@ -343,11 +348,18 @@ async def probe_silabs_firmware_info(
 
 
 async def probe_silabs_firmware_type(
-    device: str, *, probe_methods: Iterable[ApplicationType] | None = None
+    device: str,
+    *,
+    bootloader_reset_methods: Sequence[ResetTarget],
+    application_probe_methods: Sequence[tuple[ApplicationType, int]],
 ) -> ApplicationType | None:
     """Probe the running firmware type on a SiLabs device."""
 
-    fw_info = await probe_silabs_firmware_info(device, probe_methods=probe_methods)
+    fw_info = await probe_silabs_firmware_info(
+        device,
+        bootloader_reset_methods=bootloader_reset_methods,
+        application_probe_methods=application_probe_methods,
+    )
     if fw_info is None:
         return None
 
@@ -359,12 +371,22 @@ async def async_flash_silabs_firmware(
     device: str,
     fw_data: bytes,
     expected_installed_firmware_type: ApplicationType,
-    bootloader_reset_methods: Sequence[ResetTarget] = (),
+    bootloader_reset_methods: Sequence[ResetTarget],
+    application_probe_methods: Sequence[tuple[ApplicationType, int]],
     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)
@@ -373,11 +395,9 @@ async def async_flash_silabs_firmware(
 
         flasher = Flasher(
             device=device,
-            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(),
+            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
@@ -401,7 +421,13 @@ async def async_flash_silabs_firmware(
 
             probed_firmware_info = await probe_silabs_firmware_info(
                 device,
-                probe_methods=(expected_installed_firmware_type,),
+                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
+                ],
             )
 
         if probed_firmware_info is None:

homeassistant/components/homeassistant_sky_connect/config_flow.py

@@ -16,6 +16,7 @@ from homeassistant.components.homeassistant_hardware.helpers import (
 from homeassistant.components.homeassistant_hardware.util import (
     ApplicationType,
     FirmwareInfo,
+    ResetTarget,
 )
 from homeassistant.components.usb import (
     usb_service_info_from_device,
@@ -79,6 +80,20 @@ 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,6 +6,12 @@
   "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,6 +23,7 @@ from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import HomeAssistantSkyConnectConfigEntry
+from .config_flow import SkyConnectFirmwareMixin
 from .const import (
     DOMAIN,
     FIRMWARE,
@@ -151,8 +152,8 @@ async def async_setup_entry(
 class FirmwareUpdateEntity(BaseFirmwareUpdateEntity):
     """SkyConnect firmware update entity."""
 
-    # The ZBT-1 does not have a hardware bootloader trigger
-    bootloader_reset_methods = []
+    BOOTLOADER_RESET_METHODS = SkyConnectFirmwareMixin.BOOTLOADER_RESET_METHODS
+    APPLICATION_PROBE_METHODS = SkyConnectFirmwareMixin.APPLICATION_PROBE_METHODS
 
     def __init__(
         self,

homeassistant/components/homeassistant_yellow/config_flow.py

@@ -82,7 +82,18 @@ 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
@@ -146,7 +157,11 @@ 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)
+        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,
+        )
 
         # Kick off ZHA hardware discovery automatically if Zigbee firmware is running
         if (

homeassistant/components/homeassistant_yellow/manifest.json

@@ -7,5 +7,11 @@
   "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,7 +14,6 @@ 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
@@ -24,6 +23,7 @@ from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import HomeAssistantYellowConfigEntry
+from .config_flow import YellowFirmwareMixin
 from .const import DOMAIN, FIRMWARE, FIRMWARE_VERSION, MANUFACTURER, MODEL, RADIO_DEVICE
 
 _LOGGER = logging.getLogger(__name__)
@@ -150,7 +150,8 @@ async def async_setup_entry(
 class FirmwareUpdateEntity(BaseFirmwareUpdateEntity):
     """Yellow firmware update entity."""
 
-    bootloader_reset_methods = [ResetTarget.YELLOW]  # Triggers a GPIO reset
+    BOOTLOADER_RESET_METHODS = YellowFirmwareMixin.BOOTLOADER_RESET_METHODS
+    APPLICATION_PROBE_METHODS = YellowFirmwareMixin.APPLICATION_PROBE_METHODS
 
     def __init__(
         self,

homeassistant/components/husqvarna_automower/entity.py

@@ -121,12 +121,15 @@ class AutomowerBaseEntity(CoordinatorEntity[AutomowerDataUpdateCoordinator]):
         """Initialize AutomowerEntity."""
         super().__init__(coordinator)
         self.mower_id = mower_id
-        parts = self.mower_attributes.system.model.split(maxsplit=2)
+        model_witout_manufacturer = self.mower_attributes.system.model.removeprefix(
+            "Husqvarna "
+        ).removeprefix("HUSQVARNA ")
+        parts = model_witout_manufacturer.split(maxsplit=1)
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, mower_id)},
-            manufacturer=parts[0],
-            model=parts[1],
-            model_id=parts[2],
+            manufacturer="Husqvarna",
+            model=parts[0].capitalize().removesuffix("®"),
+            model_id=parts[1],
             name=self.mower_attributes.system.name,
             serial_number=self.mower_attributes.system.serial_number,
             suggested_area="Garden",

homeassistant/components/lamarzocco/manifest.json

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

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 UpdateStatus.IN_PROGRESS:
+            ).command_status is not UpdateStatus.UPDATED:
                 if counter >= MAX_UPDATE_WAIT:
                     _raise_timeout_error()
                 self._attr_update_percentage = update_progress.progress_percentage

homeassistant/components/light/strings.json

@@ -462,40 +462,5 @@
       }
     }
   },
-  "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"
-    }
-  }
+  "title": "Light"
 }

homeassistant/components/light/trigger.py

@@ -1,288 +0,0 @@
-"""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

@@ -1,43 +0,0 @@
-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.0.0"]
+  "requirements": ["ical==11.1.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.0.0"]
+  "requirements": ["ical==11.1.0"]
 }

homeassistant/components/local_todo/todo.py

@@ -154,6 +154,7 @@ class LocalTodoListEntity(TodoListEntity):
                     ),
                     due=due,
                     description=item.description,
+                    completed=item.completed,
                 )
             )
         self._attr_todo_items = todo_items

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.3"]
+  "requirements": ["lunatone-rest-api-client==0.5.7"]
 }

homeassistant/components/matter/strings.json

@@ -194,7 +194,7 @@
         "name": "Altitude above sea level"
       },
       "auto_relock_timer": {
-        "name": "Autorelock time"
+        "name": "Auto-relock time"
       },
       "cook_time": {
         "name": "Cooking time"

homeassistant/components/media_player/strings.json

@@ -367,63 +367,5 @@
       "name": "Turn up volume"
     }
   },
-  "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"
-    }
-  }
+  "title": "Media player"
 }

homeassistant/components/media_player/trigger.py

@@ -1,676 +0,0 @@
-"""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

@@ -1,65 +0,0 @@
-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/meteo_lt/weather.py

@@ -139,7 +139,7 @@ class MeteoLtWeatherEntity(CoordinatorEntity[MeteoLtUpdateCoordinator], WeatherE
             forecasts_by_date[date].append(timestamp)
 
         daily_forecasts = []
-        for date in sorted(forecasts_by_date.keys())[:5]:
+        for date in sorted(forecasts_by_date.keys()):
             day_forecasts = forecasts_by_date[date]
             if not day_forecasts:
                 continue
@@ -186,5 +186,5 @@ class MeteoLtWeatherEntity(CoordinatorEntity[MeteoLtUpdateCoordinator], WeatherE
             return None
         return [
             self._convert_forecast_data(forecast_data)
-            for forecast_data in self.coordinator.data.forecast_timestamps[:24]
+            for forecast_data in self.coordinator.data.forecast_timestamps
         ]

homeassistant/components/miele/button.py

@@ -6,7 +6,7 @@ from dataclasses import dataclass
 import logging
 from typing import Final
 
-import aiohttp
+from aiohttp import ClientResponseError
 
 from homeassistant.components.button import ButtonEntity, ButtonEntityDescription
 from homeassistant.core import HomeAssistant
@@ -153,11 +153,12 @@ class MieleButton(MieleEntity, ButtonEntity):
                 self._device_id,
                 {PROCESS_ACTION: self.entity_description.press_data},
             )
-        except aiohttp.ClientResponseError as ex:
+        except ClientResponseError as err:
+            _LOGGER.debug("Error setting button state for %s: %s", self.entity_id, err)
             raise HomeAssistantError(
                 translation_domain=DOMAIN,
                 translation_key="set_state_error",
                 translation_placeholders={
                     "entity": self.entity_id,
                 },
-            ) from ex
+            ) from err

homeassistant/components/miele/climate.py

@@ -7,7 +7,7 @@ from dataclasses import dataclass
 import logging
 from typing import Any, Final, cast
 
-import aiohttp
+from aiohttp import ClientResponseError
 from pymiele import MieleDevice, MieleTemperature
 
 from homeassistant.components.climate import (
@@ -250,7 +250,8 @@ class MieleClimate(MieleEntity, ClimateEntity):
                 cast(float, kwargs.get(ATTR_TEMPERATURE)),
                 self.entity_description.zone,
             )
-        except aiohttp.ClientError as err:
+        except ClientResponseError as err:
+            _LOGGER.debug("Error setting climate state for %s: %s", self.entity_id, err)
             raise HomeAssistantError(
                 translation_domain=DOMAIN,
                 translation_key="set_state_error",

homeassistant/components/miele/coordinator.py

@@ -73,7 +73,7 @@ class MieleDataUpdateCoordinator(DataUpdateCoordinator[MieleCoordinatorData]):
                     _LOGGER.debug(
                         "Error fetching actions for device %s: Status: %s, Message: %s",
                         device_id,
-                        err.status,
+                        str(err.status),
                         err.message,
                     )
                     actions_json = {}

homeassistant/components/miele/fan.py

@@ -142,14 +142,15 @@ class MieleFan(MieleEntity, FanEntity):
                 await self.api.send_action(
                     self._device_id, {VENTILATION_STEP: ventilation_step}
                 )
-            except ClientResponseError as ex:
+            except ClientResponseError as err:
+                _LOGGER.debug("Error setting fan state for %s: %s", self.entity_id, err)
                 raise HomeAssistantError(
                     translation_domain=DOMAIN,
                     translation_key="set_state_error",
                     translation_placeholders={
                         "entity": self.entity_id,
                     },
-                ) from ex
+                ) from err
             self.device.state_ventilation_step = ventilation_step
             self.async_write_ha_state()
 
@@ -171,6 +172,7 @@ class MieleFan(MieleEntity, FanEntity):
                 translation_key="set_state_error",
                 translation_placeholders={
                     "entity": self.entity_id,
+                    "err_status": str(ex.status),
                 },
             ) from ex
 
@@ -188,6 +190,7 @@ class MieleFan(MieleEntity, FanEntity):
                 translation_key="set_state_error",
                 translation_placeholders={
                     "entity": self.entity_id,
+                    "err_status": str(ex.status),
                 },
             ) from ex
 

homeassistant/components/miele/light.py

@@ -7,7 +7,7 @@ from dataclasses import dataclass
 import logging
 from typing import Any, Final
 
-import aiohttp
+from aiohttp import ClientResponseError
 
 from homeassistant.components.light import (
     ColorMode,
@@ -131,7 +131,8 @@ class MieleLight(MieleEntity, LightEntity):
             await self.api.send_action(
                 self._device_id, {self.entity_description.light_type: mode}
             )
-        except aiohttp.ClientError as err:
+        except ClientResponseError as err:
+            _LOGGER.debug("Error setting light state for %s: %s", self.entity_id, err)
             raise HomeAssistantError(
                 translation_domain=DOMAIN,
                 translation_key="set_state_error",

homeassistant/components/miele/services.py

@@ -4,7 +4,7 @@ from datetime import timedelta
 import logging
 from typing import cast
 
-import aiohttp
+from aiohttp import ClientResponseError
 import voluptuous as vol
 
 from homeassistant.const import ATTR_DEVICE_ID, ATTR_TEMPERATURE
@@ -107,7 +107,7 @@ async def set_program(call: ServiceCall) -> None:
     data = {"programId": call.data[ATTR_PROGRAM_ID]}
     try:
         await api.set_program(serial_number, data)
-    except aiohttp.ClientResponseError as ex:
+    except ClientResponseError as ex:
         raise HomeAssistantError(
             translation_domain=DOMAIN,
             translation_key="set_program_error",
@@ -137,7 +137,7 @@ async def set_program_oven(call: ServiceCall) -> None:
         data["temperature"] = call.data[ATTR_TEMPERATURE]
     try:
         await api.set_program(serial_number, data)
-    except aiohttp.ClientResponseError as ex:
+    except ClientResponseError as ex:
         raise HomeAssistantError(
             translation_domain=DOMAIN,
             translation_key="set_program_oven_error",
@@ -157,7 +157,7 @@ async def get_programs(call: ServiceCall) -> ServiceResponse:
 
     try:
         programs = await api.get_programs(serial_number)
-    except aiohttp.ClientResponseError as ex:
+    except ClientResponseError as ex:
         raise HomeAssistantError(
             translation_domain=DOMAIN,
             translation_key="get_programs_error",

homeassistant/components/miele/switch.py

@@ -7,7 +7,7 @@ from dataclasses import dataclass
 import logging
 from typing import Any, Final, cast
 
-import aiohttp
+from aiohttp import ClientResponseError
 from pymiele import MieleDevice
 
 from homeassistant.components.switch import SwitchEntity, SwitchEntityDescription
@@ -165,7 +165,8 @@ class MieleSwitch(MieleEntity, SwitchEntity):
         """Set switch to mode."""
         try:
             await self.api.send_action(self._device_id, mode)
-        except aiohttp.ClientError as err:
+        except ClientResponseError as err:
+            _LOGGER.debug("Error setting switch state for %s: %s", self.entity_id, err)
             raise HomeAssistantError(
                 translation_domain=DOMAIN,
                 translation_key="set_state_error",
@@ -197,7 +198,8 @@ class MielePowerSwitch(MieleSwitch):
         """Set switch to mode."""
         try:
             await self.api.send_action(self._device_id, mode)
-        except aiohttp.ClientError as err:
+        except ClientResponseError as err:
+            _LOGGER.debug("Error setting switch state for %s: %s", self.entity_id, err)
             raise HomeAssistantError(
                 translation_domain=DOMAIN,
                 translation_key="set_state_error",

homeassistant/components/miele/vacuum.py

@@ -189,14 +189,15 @@ class MieleVacuum(MieleEntity, StateVacuumEntity):
         """Send action to the device."""
         try:
             await self.api.send_action(device_id, action)
-        except ClientResponseError as ex:
+        except ClientResponseError as err:
+            _LOGGER.debug("Error setting vacuum state for %s: %s", self.entity_id, err)
             raise HomeAssistantError(
                 translation_domain=DOMAIN,
                 translation_key="set_state_error",
                 translation_placeholders={
                     "entity": self.entity_id,
                 },
-            ) from ex
+            ) from err
 
     async def async_clean_spot(self, **kwargs: Any) -> None:
         """Clean spot."""

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.0", "mill-local==0.3.0"]
+  "requirements": ["millheater==0.14.1", "mill-local==0.3.0"]
 }

homeassistant/components/mobile_app/binary_sensor.py

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

homeassistant/components/mobile_app/sensor.py

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

homeassistant/components/modbus/sensor.py

@@ -88,6 +88,8 @@ class ModbusRegisterSensor(ModbusStructEntity, RestoreSensor, SensorEntity):
         self._attr_device_class = entry.get(CONF_DEVICE_CLASS)
         if self._precision > 0 or self._scale != int(self._scale):
             self._value_is_int = False
+        if self._precision > 0 and self._data_type not in ["string", "custom"]:
+            self._attr_suggested_display_precision = self._precision
 
     async def async_setup_slaves(
         self, hass: HomeAssistant, slave_count: int, entry: dict[str, Any]

homeassistant/components/mvglive/manifest.json

@@ -5,5 +5,6 @@
   "documentation": "https://www.home-assistant.io/integrations/mvglive",
   "iot_class": "cloud_polling",
   "loggers": ["MVG"],
+  "quality_scale": "legacy",
   "requirements": ["mvg==1.4.0"]
 }

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": "OAuth2 implementation unavailable, will retry"
+      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
     },
     "update_failed": {
       "message": "Failed to update drive state"

homeassistant/components/open_router/manifest.json

@@ -9,5 +9,5 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "quality_scale": "bronze",
-  "requirements": ["openai==2.2.0", "python-open-router==0.3.2"]
+  "requirements": ["openai==2.8.0", "python-open-router==0.3.3"]
 }

homeassistant/components/openai_conversation/manifest.json

@@ -8,5 +8,5 @@
   "documentation": "https://www.home-assistant.io/integrations/openai_conversation",
   "integration_type": "service",
   "iot_class": "cloud_polling",
-  "requirements": ["openai==2.2.0"]
+  "requirements": ["openai==2.8.0"]
 }

homeassistant/components/point/strings.json

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

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
+from ..db_schema import DOUBLE_PRECISION_TYPE_SQL, DOUBLE_TYPE, MYSQL_COLLATE
 from ..util import session_scope
 
 if TYPE_CHECKING:
@@ -105,12 +105,13 @@ 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 != "utf8mb4_unicode_ci":
+        if collate and collate != MYSQL_COLLATE:
             _LOGGER.debug(
-                "Database %s collation is not utf8mb4_unicode_ci",
+                "Database %s collation is not %s",
                 table,
+                MYSQL_COLLATE,
             )
-            schema_errors.add(f"{table}.utf8mb4_unicode_ci")
+            schema_errors.add(f"{table}.{MYSQL_COLLATE}")
     return schema_errors
 
 
@@ -240,7 +241,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}.utf8mb4_unicode_ci" in schema_errors
+        or f"{table_name}.{MYSQL_COLLATE}" 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 = 52
+SCHEMA_VERSION = 53
 
 _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_unicode_ci"
+MYSQL_COLLATE = "utf8mb4_bin"
 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 the statistic_meta table
+        # Try to change the character set of events, states and statistics_meta tables
         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,6 +2125,23 @@ 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,
@@ -2167,8 +2184,10 @@ def _correct_table_character_set_and_collation(
     """Correct issues detected by validate_db_schema."""
     # Attempt to convert the table to utf8mb4
     _LOGGER.warning(
-        "Updating character set and collation of table %s to utf8mb4. %s",
+        "Updating table %s to character set %s and collation %s. %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.0.0"]
+  "requirements": ["ical==11.1.0"]
 }

homeassistant/components/reolink/__init__.py

@@ -58,7 +58,8 @@ PLATFORMS = [
     Platform.SWITCH,
     Platform.UPDATE,
 ]
-DEVICE_UPDATE_INTERVAL = timedelta(seconds=60)
+DEVICE_UPDATE_INTERVAL_MIN = timedelta(seconds=60)
+DEVICE_UPDATE_INTERVAL_PER_CAM = timedelta(seconds=10)
 FIRMWARE_UPDATE_INTERVAL = timedelta(hours=24)
 NUM_CRED_ERRORS = 3
 
@@ -137,9 +138,12 @@ async def async_setup_entry(
         }
         hass.config_entries.async_update_entry(config_entry, data=data)
 
+    min_timeout = host.api.timeout * (RETRY_ATTEMPTS + 2)
+    update_timeout = max(min_timeout, min_timeout * host.api.num_cameras / 10)
+
     async def async_device_config_update() -> None:
         """Update the host state cache and renew the ONVIF-subscription."""
-        async with asyncio.timeout(host.api.timeout * (RETRY_ATTEMPTS + 2)):
+        async with asyncio.timeout(update_timeout):
             try:
                 await host.update_states()
             except CredentialsInvalidError as err:
@@ -156,7 +160,7 @@ async def async_setup_entry(
 
         host.credential_errors = 0
 
-        async with asyncio.timeout(host.api.timeout * (RETRY_ATTEMPTS + 2)):
+        async with asyncio.timeout(min_timeout):
             await host.renew()
 
         if host.api.new_devices and config_entry.state == ConfigEntryState.LOADED:
@@ -171,7 +175,7 @@ async def async_setup_entry(
 
     async def async_check_firmware_update() -> None:
         """Check for firmware updates."""
-        async with asyncio.timeout(host.api.timeout * (RETRY_ATTEMPTS + 2)):
+        async with asyncio.timeout(min_timeout):
             try:
                 await host.api.check_new_firmware(host.firmware_ch_list)
             except ReolinkError as err:
@@ -197,7 +201,10 @@ async def async_setup_entry(
         config_entry=config_entry,
         name=f"reolink.{host.api.nvr_name}",
         update_method=async_device_config_update,
-        update_interval=DEVICE_UPDATE_INTERVAL,
+        update_interval=max(
+            DEVICE_UPDATE_INTERVAL_MIN,
+            DEVICE_UPDATE_INTERVAL_PER_CAM * host.api.num_cameras,
+        ),
     )
     firmware_coordinator = DataUpdateCoordinator(
         hass,