Add assist_satellite triggers (#156819)

Co-authored-by: Martin Hjelmare <marhje52@gmail.com>

.github/workflows/ci.yaml

@@ -37,7 +37,7 @@ on:
         type: boolean
 
 env:
-  CACHE_VERSION: 2
+  CACHE_VERSION: 1
   UV_CACHE_VERSION: 1
   MYPY_CACHE_VERSION: 1
   HA_SHORT_VERSION: "2025.12"
@@ -622,7 +622,7 @@ jobs:
     steps:
       - *checkout
       - name: Dependency review
-        uses: actions/dependency-review-action@3c4e3dcb1aa7874d2c16be7d79418e9b7efd6261 # v4.8.2
+        uses: actions/dependency-review-action@40c09b7dc99638e5ddb0bfd91c1673effc064d8a # v4.8.1
         with:
           license-check: false # We use our own license audit checks
 

CODEOWNERS

@@ -516,8 +516,6 @@ build.json @home-assistant/supervisor
 /tests/components/flo/ @dmulcahey
 /homeassistant/components/flume/ @ChrisMandich @bdraco @jeeftor
 /tests/components/flume/ @ChrisMandich @bdraco @jeeftor
-/homeassistant/components/fluss/ @fluss
-/tests/components/fluss/ @fluss
 /homeassistant/components/flux_led/ @icemanch
 /tests/components/flux_led/ @icemanch
 /homeassistant/components/forecast_solar/ @klaasnicolaas @frenck
@@ -1019,8 +1017,8 @@ build.json @home-assistant/supervisor
 /homeassistant/components/msteams/ @peroyvind
 /homeassistant/components/mullvad/ @meichthys
 /tests/components/mullvad/ @meichthys
-/homeassistant/components/music_assistant/ @music-assistant @arturpragacz
-/tests/components/music_assistant/ @music-assistant @arturpragacz
+/homeassistant/components/music_assistant/ @music-assistant
+/tests/components/music_assistant/ @music-assistant
 /homeassistant/components/mutesync/ @currentoor
 /tests/components/mutesync/ @currentoor
 /homeassistant/components/my/ @home-assistant/core

homeassistant/components/alarm_control_panel/icons.json

@@ -36,5 +36,13 @@
     "alarm_trigger": {
       "service": "mdi:bell-ring"
     }
+  },
+  "triggers": {
+    "disarmed": {
+      "trigger": "mdi:shield-off"
+    },
+    "triggered": {
+      "trigger": "mdi:bell-ring"
+    }
   }
 }

homeassistant/components/alarm_control_panel/strings.json

@@ -71,6 +71,15 @@
       "message": "Arming requires a code but none was given for {entity_id}."
     }
   },
+  "selector": {
+    "trigger_behavior": {
+      "options": {
+        "any": "Any",
+        "first": "First",
+        "last": "Last"
+      }
+    }
+  },
   "services": {
     "alarm_arm_away": {
       "description": "Arms the alarm in the away mode.",
@@ -143,5 +152,29 @@
       "name": "Trigger"
     }
   },
-  "title": "Alarm control panel"
+  "title": "Alarm control panel",
+  "triggers": {
+    "disarmed": {
+      "description": "Triggers when an alarm is disarmed.",
+      "description_configured": "[%key:component::alarm_control_panel::triggers::disarmed::description%]",
+      "fields": {
+        "behavior": {
+          "description": "The behavior of the targeted alarms to trigger on.",
+          "name": "Behavior"
+        }
+      },
+      "name": "When an alarm is disarmed"
+    },
+    "triggered": {
+      "description": "Triggers when an alarm is triggered.",
+      "description_configured": "[%key:component::alarm_control_panel::triggers::triggered::description%]",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::alarm_control_panel::triggers::disarmed::fields::behavior::description%]",
+          "name": "[%key:component::alarm_control_panel::triggers::disarmed::fields::behavior::name%]"
+        }
+      },
+      "name": "When an alarm is triggered"
+    }
+  }
 }

homeassistant/components/alarm_control_panel/trigger.py

@@ -0,0 +1,16 @@
+"""Provides triggers for alarm control panels."""
+
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.trigger import Trigger, make_entity_state_trigger
+
+from .const import DOMAIN, AlarmControlPanelState
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "disarmed": make_entity_state_trigger(DOMAIN, AlarmControlPanelState.DISARMED),
+    "triggered": make_entity_state_trigger(DOMAIN, AlarmControlPanelState.TRIGGERED),
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for alarm control panels."""
+    return TRIGGERS

homeassistant/components/alarm_control_panel/triggers.yaml

@@ -0,0 +1,19 @@
+.trigger_common: &trigger_common
+  target:
+    entity:
+      domain: alarm_control_panel
+  fields:
+    behavior:
+      required: true
+      default: any
+      selector:
+        select:
+          options:
+            - first
+            - last
+            - any
+          translation_key: trigger_behavior
+
+disarmed: *trigger_common
+
+triggered: *trigger_common

homeassistant/components/assist_satellite/icons.json

@@ -14,5 +14,19 @@
     "start_conversation": {
       "service": "mdi:forum"
     }
+  },
+  "triggers": {
+    "idle": {
+      "trigger": "mdi:chat-sleep"
+    },
+    "listening": {
+      "trigger": "mdi:chat-question"
+    },
+    "processing": {
+      "trigger": "mdi:chat-processing"
+    },
+    "responding": {
+      "trigger": "mdi:chat-alert"
+    }
   }
 }

homeassistant/components/assist_satellite/strings.json

@@ -16,6 +16,13 @@
         "id": "Answer ID",
         "sentences": "Sentences"
       }
+    },
+    "trigger_behavior": {
+      "options": {
+        "any": "Any",
+        "first": "First",
+        "last": "Last"
+      }
     }
   },
   "services": {
@@ -98,5 +105,51 @@
       "name": "Start conversation"
     }
   },
-  "title": "Assist satellite"
+  "title": "Assist satellite",
+  "triggers": {
+    "idle": {
+      "description": "Triggers when an assist satellite becomes idle.",
+      "description_configured": "[%key:component::assist_satellite::triggers::idle::description%]",
+      "fields": {
+        "behavior": {
+          "description": "The behavior of the targeted assist satellites to trigger on.",
+          "name": "Behavior"
+        }
+      },
+      "name": "When an assist satellite becomes idle"
+    },
+    "listening": {
+      "description": "Triggers when an assist satellite starts listening.",
+      "description_configured": "[%key:component::assist_satellite::triggers::listening::description%]",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::assist_satellite::triggers::idle::fields::behavior::description%]",
+          "name": "[%key:component::assist_satellite::triggers::idle::fields::behavior::name%]"
+        }
+      },
+      "name": "When an assist satellite starts listening"
+    },
+    "processing": {
+      "description": "Triggers when an assist satellite is processing.",
+      "description_configured": "[%key:component::assist_satellite::triggers::processing::description%]",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::assist_satellite::triggers::idle::fields::behavior::description%]",
+          "name": "[%key:component::assist_satellite::triggers::idle::fields::behavior::name%]"
+        }
+      },
+      "name": "When an assist satellite is processing"
+    },
+    "responding": {
+      "description": "Triggers when an assist satellite is responding.",
+      "description_configured": "[%key:component::assist_satellite::triggers::responding::description%]",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::assist_satellite::triggers::idle::fields::behavior::description%]",
+          "name": "[%key:component::assist_satellite::triggers::idle::fields::behavior::name%]"
+        }
+      },
+      "name": "When an assist satellite is responding"
+    }
+  }
 }

homeassistant/components/assist_satellite/trigger.py

@@ -0,0 +1,19 @@
+"""Provides triggers for assist satellites."""
+
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.trigger import Trigger, make_entity_state_trigger
+
+from .const import DOMAIN
+from .entity import AssistSatelliteState
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "idle": make_entity_state_trigger(DOMAIN, AssistSatelliteState.IDLE),
+    "listening": make_entity_state_trigger(DOMAIN, AssistSatelliteState.LISTENING),
+    "processing": make_entity_state_trigger(DOMAIN, AssistSatelliteState.PROCESSING),
+    "responding": make_entity_state_trigger(DOMAIN, AssistSatelliteState.RESPONDING),
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for assist satellites."""
+    return TRIGGERS

homeassistant/components/assist_satellite/triggers.yaml

@@ -0,0 +1,20 @@
+.trigger_common: &trigger_common
+  target:
+    entity:
+      domain: assist_satellite
+  fields:
+    behavior:
+      required: true
+      default: any
+      selector:
+        select:
+          options:
+            - first
+            - last
+            - any
+          translation_key: trigger_behavior
+
+idle: *trigger_common
+listening: *trigger_common
+processing: *trigger_common
+responding: *trigger_common

homeassistant/components/climate/icons.json

@@ -96,5 +96,13 @@
     "turn_on": {
       "service": "mdi:power-on"
     }
+  },
+  "triggers": {
+    "started_heating": {
+      "trigger": "mdi:fire"
+    },
+    "turned_off": {
+      "trigger": "mdi:power-off"
+    }
   }
 }

homeassistant/components/climate/strings.json

@@ -187,6 +187,13 @@
         "heat_cool": "Heat/cool",
         "off": "[%key:common::state::off%]"
       }
+    },
+    "trigger_behavior": {
+      "options": {
+        "any": "Any",
+        "first": "First",
+        "last": "Last"
+      }
     }
   },
   "services": {
@@ -285,5 +292,29 @@
       "name": "[%key:common::action::turn_on%]"
     }
   },
-  "title": "Climate"
+  "title": "Climate",
+  "triggers": {
+    "started_heating": {
+      "description": "Triggers when a climate starts to heat.",
+      "description_configured": "[%key:component::climate::triggers::started_heating::description%]",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::climate::triggers::turned_off::fields::behavior::description%]",
+          "name": "[%key:component::climate::triggers::turned_off::fields::behavior::name%]"
+        }
+      },
+      "name": "When a climate starts to heat"
+    },
+    "turned_off": {
+      "description": "Triggers when a climate is turned off.",
+      "description_configured": "[%key:component::climate::triggers::turned_off::description%]",
+      "fields": {
+        "behavior": {
+          "description": "The behavior of the targeted climates to trigger on.",
+          "name": "Behavior"
+        }
+      },
+      "name": "When a climate is turned off"
+    }
+  }
 }

homeassistant/components/climate/trigger.py

@@ -0,0 +1,23 @@
+"""Provides triggers for climates."""
+
+from homeassistant.const import STATE_OFF
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.trigger import (
+    Trigger,
+    make_entity_state_attribute_trigger,
+    make_entity_state_trigger,
+)
+
+from .const import ATTR_HVAC_ACTION, DOMAIN, HVACAction
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "turned_off": make_entity_state_trigger(DOMAIN, STATE_OFF),
+    "started_heating": make_entity_state_attribute_trigger(
+        DOMAIN, ATTR_HVAC_ACTION, HVACAction.HEATING
+    ),
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for climates."""
+    return TRIGGERS

homeassistant/components/climate/triggers.yaml

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

homeassistant/components/comelit/config_flow.py

@@ -37,6 +37,13 @@ USER_SCHEMA = vol.Schema(
     }
 )
 STEP_REAUTH_DATA_SCHEMA = vol.Schema({vol.Required(CONF_PIN): cv.string})
+STEP_RECONFIGURE = vol.Schema(
+    {
+        vol.Required(CONF_HOST): cv.string,
+        vol.Required(CONF_PORT): cv.port,
+        vol.Optional(CONF_PIN, default=DEFAULT_PIN): cv.string,
+    }
+)
 
 
 async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> dict[str, str]:
@@ -168,55 +175,36 @@ class ComelitConfigFlow(ConfigFlow, domain=DOMAIN):
     ) -> ConfigFlowResult:
         """Handle reconfiguration of the device."""
         reconfigure_entry = self._get_reconfigure_entry()
+        if not user_input:
+            return self.async_show_form(
+                step_id="reconfigure", data_schema=STEP_RECONFIGURE
+            )
+
+        updated_host = user_input[CONF_HOST]
+
+        self._async_abort_entries_match({CONF_HOST: updated_host})
+
         errors: dict[str, str] = {}
 
-        if user_input is not None:
-            updated_host = user_input[CONF_HOST]
-
-            self._async_abort_entries_match({CONF_HOST: updated_host})
-
-            try:
-                data_to_validate = {
-                    CONF_HOST: updated_host,
-                    CONF_PORT: user_input[CONF_PORT],
-                    CONF_PIN: user_input[CONF_PIN],
-                    CONF_TYPE: reconfigure_entry.data.get(CONF_TYPE, BRIDGE),
-                }
-                await validate_input(self.hass, data_to_validate)
-            except CannotConnect:
-                errors["base"] = "cannot_connect"
-            except InvalidAuth:
-                errors["base"] = "invalid_auth"
-            except InvalidPin:
-                errors["base"] = "invalid_pin"
-            except Exception:  # noqa: BLE001
-                _LOGGER.exception("Unexpected exception")
-                errors["base"] = "unknown"
-            else:
-                data_updates = {
-                    CONF_HOST: updated_host,
-                    CONF_PORT: user_input[CONF_PORT],
-                    CONF_PIN: user_input[CONF_PIN],
-                }
-                return self.async_update_reload_and_abort(
-                    reconfigure_entry, data_updates=data_updates
-                )
-
-        schema = vol.Schema(
-            {
-                vol.Required(
-                    CONF_HOST, default=reconfigure_entry.data[CONF_HOST]
-                ): cv.string,
-                vol.Required(
-                    CONF_PORT, default=reconfigure_entry.data[CONF_PORT]
-                ): cv.port,
-                vol.Optional(CONF_PIN): cv.string,
-            }
-        )
+        try:
+            await validate_input(self.hass, user_input)
+        except CannotConnect:
+            errors["base"] = "cannot_connect"
+        except InvalidAuth:
+            errors["base"] = "invalid_auth"
+        except InvalidPin:
+            errors["base"] = "invalid_pin"
+        except Exception:  # noqa: BLE001
+            _LOGGER.exception("Unexpected exception")
+            errors["base"] = "unknown"
+        else:
+            return self.async_update_reload_and_abort(
+                reconfigure_entry, data_updates={CONF_HOST: updated_host}
+            )
 
         return self.async_show_form(
             step_id="reconfigure",
-            data_schema=schema,
+            data_schema=STEP_RECONFIGURE,
             errors=errors,
         )
 

homeassistant/components/conversation/__init__.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from collections.abc import Callable
 import logging
-from typing import Any, Literal
+from typing import Literal
 
 from hassil.recognize import RecognizeResult
 import voluptuous as vol
@@ -21,7 +21,6 @@ from homeassistant.core import (
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv, intent
 from homeassistant.helpers.entity_component import EntityComponent
-from homeassistant.helpers.reload import async_integration_yaml_config
 from homeassistant.helpers.typing import ConfigType
 from homeassistant.loader import bind_hass
 
@@ -53,8 +52,6 @@ from .const import (
     DATA_COMPONENT,
     DOMAIN,
     HOME_ASSISTANT_AGENT,
-    METADATA_CUSTOM_FILE,
-    METADATA_CUSTOM_SENTENCE,
     SERVICE_PROCESS,
     SERVICE_RELOAD,
     ConversationEntityFeature,
@@ -269,13 +266,10 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     entity_component = EntityComponent[ConversationEntity](_LOGGER, DOMAIN, hass)
     hass.data[DATA_COMPONENT] = entity_component
 
-    manager = get_agent_manager(hass)
-
-    hass_config_path = hass.config.path()
-    config_intents = _get_config_intents(config, hass_config_path)
-    manager.update_config_intents(config_intents)
-
-    await async_setup_default_agent(hass, entity_component)
+    agent_config = config.get(DOMAIN, {})
+    await async_setup_default_agent(
+        hass, entity_component, config_intents=agent_config.get("intents", {})
+    )
 
     async def handle_process(service: ServiceCall) -> ServiceResponse:
         """Parse text into commands."""
@@ -300,16 +294,9 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 
     async def handle_reload(service: ServiceCall) -> None:
         """Reload intents."""
-        language = service.data.get(ATTR_LANGUAGE)
-        if language is None:
-            conf = await async_integration_yaml_config(hass, DOMAIN)
-            if conf is not None:
-                config_intents = _get_config_intents(conf, hass_config_path)
-                manager.update_config_intents(config_intents)
-
-        agent = manager.default_agent
+        agent = get_agent_manager(hass).default_agent
         if agent is not None:
-            await agent.async_reload(language=language)
+            await agent.async_reload(language=service.data.get(ATTR_LANGUAGE))
 
     hass.services.async_register(
         DOMAIN,
@@ -326,27 +313,6 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     return True
 
 
-def _get_config_intents(config: ConfigType, hass_config_path: str) -> dict[str, Any]:
-    """Return config intents."""
-    intents = config.get(DOMAIN, {}).get("intents", {})
-    return {
-        "intents": {
-            intent_name: {
-                "data": [
-                    {
-                        "sentences": sentences,
-                        "metadata": {
-                            METADATA_CUSTOM_SENTENCE: True,
-                            METADATA_CUSTOM_FILE: hass_config_path,
-                        },
-                    }
-                ]
-            }
-            for intent_name, sentences in intents.items()
-        }
-    }
-
-
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up a config entry."""
     return await hass.data[DATA_COMPONENT].async_setup_entry(entry)

homeassistant/components/conversation/agent_manager.py

@@ -147,7 +147,6 @@ class AgentManager:
         self.hass = hass
         self._agents: dict[str, AbstractConversationAgent] = {}
         self.default_agent: DefaultAgent | None = None
-        self.config_intents: dict[str, Any] = {}
         self.triggers_details: list[TriggerDetails] = []
 
     @callback
@@ -200,16 +199,9 @@ class AgentManager:
 
     async def async_setup_default_agent(self, agent: DefaultAgent) -> None:
         """Set up the default agent."""
-        agent.update_config_intents(self.config_intents)
         agent.update_triggers(self.triggers_details)
         self.default_agent = agent
 
-    def update_config_intents(self, intents: dict[str, Any]) -> None:
-        """Update config intents."""
-        self.config_intents = intents
-        if self.default_agent is not None:
-            self.default_agent.update_config_intents(intents)
-
     def register_trigger(self, trigger_details: TriggerDetails) -> CALLBACK_TYPE:
         """Register a trigger."""
         self.triggers_details.append(trigger_details)

homeassistant/components/conversation/const.py

@@ -30,7 +30,3 @@ class ConversationEntityFeature(IntFlag):
     """Supported features of the conversation entity."""
 
     CONTROL = 1
-
-
-METADATA_CUSTOM_SENTENCE = "hass_custom_sentence"
-METADATA_CUSTOM_FILE = "hass_custom_file"

homeassistant/components/conversation/default_agent.py

@@ -77,12 +77,7 @@ from homeassistant.util.json import JsonObjectType, json_loads_object
 
 from .agent_manager import get_agent_manager
 from .chat_log import AssistantContent, ChatLog
-from .const import (
-    DOMAIN,
-    METADATA_CUSTOM_FILE,
-    METADATA_CUSTOM_SENTENCE,
-    ConversationEntityFeature,
-)
+from .const import DOMAIN, ConversationEntityFeature
 from .entity import ConversationEntity
 from .models import ConversationInput, ConversationResult
 from .trace import ConversationTraceEventType, async_conversation_trace_append
@@ -96,6 +91,8 @@ _ENTITY_REGISTRY_UPDATE_FIELDS = ["aliases", "name", "original_name"]
 
 _DEFAULT_EXPOSED_ATTRIBUTES = {"device_class"}
 
+METADATA_CUSTOM_SENTENCE = "hass_custom_sentence"
+METADATA_CUSTOM_FILE = "hass_custom_file"
 METADATA_FUZZY_MATCH = "hass_fuzzy_match"
 
 ERROR_SENTINEL = object()
@@ -205,9 +202,10 @@ class IntentCache:
 async def async_setup_default_agent(
     hass: HomeAssistant,
     entity_component: EntityComponent[ConversationEntity],
+    config_intents: dict[str, Any],
 ) -> None:
     """Set up entity registry listener for the default agent."""
-    agent = DefaultAgent(hass)
+    agent = DefaultAgent(hass, config_intents)
     await entity_component.async_add_entities([agent])
     await get_agent_manager(hass).async_setup_default_agent(agent)
 
@@ -232,14 +230,14 @@ class DefaultAgent(ConversationEntity):
     _attr_name = "Home Assistant"
     _attr_supported_features = ConversationEntityFeature.CONTROL
 
-    def __init__(self, hass: HomeAssistant) -> None:
+    def __init__(self, hass: HomeAssistant, config_intents: dict[str, Any]) -> None:
         """Initialize the default agent."""
         self.hass = hass
         self._lang_intents: dict[str, LanguageIntents | object] = {}
         self._load_intents_lock = asyncio.Lock()
 
-        # Intents from common conversation config
-        self._config_intents: dict[str, Any] = {}
+        # intent -> [sentences]
+        self._config_intents: dict[str, Any] = config_intents
 
         # Sentences that will trigger a callback (skipping intent recognition)
         self._triggers_details: list[TriggerDetails] = []
@@ -1037,14 +1035,6 @@ class DefaultAgent(ConversationEntity):
         # Intents have changed, so we must clear the cache
         self._intent_cache.clear()
 
-    @callback
-    def update_config_intents(self, intents: dict[str, Any]) -> None:
-        """Update config intents."""
-        self._config_intents = intents
-
-        # Intents have changed, so we must clear the cache
-        self._intent_cache.clear()
-
     async def async_prepare(self, language: str | None = None) -> None:
         """Load intents for a language."""
         if language is None:
@@ -1169,10 +1159,33 @@ class DefaultAgent(ConversationEntity):
                     custom_sentences_path,
                 )
 
-        merge_dict(
-            intents_dict,
-            self._config_intents,
-        )
+        # Load sentences from HA config for default language only
+        if self._config_intents and (
+            self.hass.config.language in (language, language_variant)
+        ):
+            hass_config_path = self.hass.config.path()
+            merge_dict(
+                intents_dict,
+                {
+                    "intents": {
+                        intent_name: {
+                            "data": [
+                                {
+                                    "sentences": sentences,
+                                    "metadata": {
+                                        METADATA_CUSTOM_SENTENCE: True,
+                                        METADATA_CUSTOM_FILE: hass_config_path,
+                                    },
+                                }
+                            ]
+                        }
+                        for intent_name, sentences in self._config_intents.items()
+                    }
+                },
+            )
+            _LOGGER.debug(
+                "Loaded intents from configuration.yaml",
+            )
 
         if not intents_dict:
             return None

homeassistant/components/cover/icons.json

@@ -108,5 +108,10 @@
     "toggle_cover_tilt": {
       "service": "mdi:arrow-top-right-bottom-left"
     }
+  },
+  "triggers": {
+    "garage_opened": {
+      "trigger": "mdi:garage-open"
+    }
   }
 }

homeassistant/components/cover/strings.json

@@ -82,6 +82,15 @@
       "name": "Window"
     }
   },
+  "selector": {
+    "trigger_behavior": {
+      "options": {
+        "any": "Any",
+        "first": "First",
+        "last": "Last"
+      }
+    }
+  },
   "services": {
     "close_cover": {
       "description": "Closes a cover.",
@@ -136,5 +145,22 @@
       "name": "Toggle tilt"
     }
   },
-  "title": "Cover"
+  "title": "Cover",
+  "triggers": {
+    "garage_opened": {
+      "description": "Triggers when a garage door opens.",
+      "description_configured": "[%key:component::cover::triggers::garage_opened::description%]",
+      "fields": {
+        "behavior": {
+          "description": "The behavior of the targeted garage doors to trigger on.",
+          "name": "Behavior"
+        },
+        "fully_opened": {
+          "description": "Require the garage doors to be fully opened before triggering.",
+          "name": "Fully opened"
+        }
+      },
+      "name": "When a garage door opens"
+    }
+  }
 }

homeassistant/components/cover/trigger.py

@@ -0,0 +1,108 @@
+"""Provides triggers for covers."""
+
+from typing import Final
+
+import voluptuous as vol
+
+from homeassistant.const import CONF_OPTIONS
+from homeassistant.core import HomeAssistant, State
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.entity import get_device_class
+from homeassistant.helpers.trigger import (
+    ENTITY_STATE_TRIGGER_SCHEMA,
+    EntityTriggerBase,
+    Trigger,
+    TriggerConfig,
+)
+from homeassistant.helpers.typing import UNDEFINED, UndefinedType
+
+from . import ATTR_CURRENT_POSITION, CoverDeviceClass, CoverState
+from .const import DOMAIN
+
+ATTR_FULLY_OPENED: Final = "fully_opened"
+
+COVER_OPENED_TRIGGER_SCHEMA = ENTITY_STATE_TRIGGER_SCHEMA.extend(
+    {
+        vol.Required(CONF_OPTIONS): {
+            vol.Required(ATTR_FULLY_OPENED, default=False): bool,
+        },
+    }
+)
+
+
+def get_device_class_or_undefined(
+    hass: HomeAssistant, entity_id: str
+) -> str | None | UndefinedType:
+    """Get the device class of an entity or UNDEFINED if not found."""
+    try:
+        return get_device_class(hass, entity_id)
+    except HomeAssistantError:
+        return UNDEFINED
+
+
+class CoverOpenedClosedTrigger(EntityTriggerBase):
+    """Class for cover opened and closed triggers."""
+
+    _attribute: str = ATTR_CURRENT_POSITION
+    _attribute_value: int | None = None
+    _device_class: CoverDeviceClass | None
+    _domain: str = DOMAIN
+    _to_states: set[str]
+
+    def is_to_state(self, state: State) -> bool:
+        """Check if the state matches the target state."""
+        if state.state not in self._to_states:
+            return False
+        if (
+            self._attribute_value is not None
+            and (value := state.attributes.get(self._attribute)) is not None
+            and value != self._attribute_value
+        ):
+            return False
+        return True
+
+    def entity_filter(self, entities: set[str]) -> set[str]:
+        """Filter entities of this domain."""
+        entities = super().entity_filter(entities)
+        return {
+            entity_id
+            for entity_id in entities
+            if get_device_class_or_undefined(self._hass, entity_id)
+            == self._device_class
+        }
+
+
+class CoverOpenedTrigger(CoverOpenedClosedTrigger):
+    """Class for cover opened triggers."""
+
+    _schema = COVER_OPENED_TRIGGER_SCHEMA
+    _to_states = {CoverState.OPEN, CoverState.OPENING}
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the state trigger."""
+        super().__init__(hass, config)
+        if self._options.get(ATTR_FULLY_OPENED):
+            self._attribute_value = 100
+
+
+def make_cover_opened_trigger(
+    device_class: CoverDeviceClass | None,
+) -> type[CoverOpenedTrigger]:
+    """Create an entity state attribute trigger class."""
+
+    class CustomTrigger(CoverOpenedTrigger):
+        """Trigger for entity state changes."""
+
+        _device_class = device_class
+
+    return CustomTrigger
+
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "garage_opened": make_cover_opened_trigger(CoverDeviceClass.GARAGE),
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for covers."""
+    return TRIGGERS

homeassistant/components/cover/triggers.yaml

@@ -0,0 +1,21 @@
+garage_opened:
+  target:
+    entity:
+      domain: cover
+      device_class: garage
+  fields:
+    behavior:
+      required: true
+      default: any
+      selector:
+        select:
+          translation_key: trigger_behavior
+          options:
+            - first
+            - last
+            - any
+    fully_opened:
+      required: true
+      default: false
+      selector:
+        boolean:

homeassistant/components/ecobee/manifest.json

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

homeassistant/components/emoncms/quality_scale.yaml

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

homeassistant/components/energy/validate.py

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

homeassistant/components/enphase_envoy/diagnostics.py

@@ -147,8 +147,6 @@ 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,
@@ -181,7 +179,6 @@ 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,189 +399,117 @@ class EnvoyCTSensorEntityDescription(SensorEntityDescription):
     cttype: str | None = None
 
 
-# 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"),
-        )
-    ]
-    + [
-        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", ""),
-        )
-    ]
+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_PHASE_SENSORS = {
+CT_NET_CONSUMPTION_PHASE_SENSORS = {
     (on_phase := PHASENAMES[phase]): [
         replace(
             sensor,
@@ -591,7 +519,220 @@ CT_PHASE_SENSORS = {
             on_phase=on_phase,
             translation_placeholders={"phase_name": f"l{phase + 1}"},
         )
-        for sensor in list(CT_SENSORS)
+        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}"},
+        )
+        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 = {
+    (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}"},
+        )
+        for sensor in list(CT_STORAGE_SENSORS)
     ]
     for phase in range(3)
 }
@@ -919,14 +1060,24 @@ async def async_setup_entry(
     if envoy_data.ctmeters:
         entities.extend(
             EnvoyCTEntity(coordinator, description)
-            for description in CT_SENSORS
+            for sensors in (
+                CT_NET_CONSUMPTION_SENSORS,
+                CT_PRODUCTION_SENSORS,
+                CT_STORAGE_SENSORS,
+            )
+            for description in 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 phase, descriptions in CT_PHASE_SENSORS.items()
+            for sensors in (
+                CT_NET_CONSUMPTION_PHASE_SENSORS,
+                CT_PRODUCTION_PHASE_SENSORS,
+                CT_STORAGE_PHASE_SENSORS,
+            )
+            for phase, descriptions in sensors.items()
             for description in descriptions
             if (cttype := description.cttype) in ctmeters_phases
             and phase in ctmeters_phases[cttype]

homeassistant/components/fluss/__init__.py

@@ -1,31 +0,0 @@
-"""The Fluss+ integration."""
-
-from __future__ import annotations
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_API_KEY, Platform
-from homeassistant.core import HomeAssistant
-
-from .coordinator import FlussDataUpdateCoordinator
-
-PLATFORMS: list[Platform] = [Platform.BUTTON]
-
-
-type FlussConfigEntry = ConfigEntry[FlussDataUpdateCoordinator]
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: FlussConfigEntry,
-) -> bool:
-    """Set up Fluss+ from a config entry."""
-    coordinator = FlussDataUpdateCoordinator(hass, entry, entry.data[CONF_API_KEY])
-    await coordinator.async_config_entry_first_refresh()
-    entry.runtime_data = coordinator
-    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
-    return True
-
-
-async def async_unload_entry(hass: HomeAssistant, entry: FlussConfigEntry) -> bool:
-    """Unload a config entry."""
-    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/fluss/button.py

@@ -1,38 +0,0 @@
-"""Support for Fluss Devices."""
-
-from homeassistant.components.button import ButtonEntity
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .coordinator import FlussApiClientError, FlussDataUpdateCoordinator
-from .entity import FlussEntity
-
-type FlussConfigEntry = ConfigEntry[FlussDataUpdateCoordinator]
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: FlussConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up the Fluss Devices, filtering out any invalid payloads."""
-    coordinator = entry.runtime_data
-    devices = coordinator.data
-
-    async_add_entities(
-        FlussButton(coordinator, device_id, device)
-        for device_id, device in devices.items()
-    )
-
-
-class FlussButton(FlussEntity, ButtonEntity):
-    """Representation of a Fluss button device."""
-
-    async def async_press(self) -> None:
-        """Handle the button press."""
-        try:
-            await self.coordinator.api.async_trigger_device(self.device_id)
-        except FlussApiClientError as err:
-            raise HomeAssistantError(f"Failed to trigger device: {err}") from err

homeassistant/components/fluss/config_flow.py

@@ -1,54 +0,0 @@
-"""Config flow for Fluss+ integration."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from fluss_api import (
-    FlussApiClient,
-    FlussApiClientAuthenticationError,
-    FlussApiClientCommunicationError,
-)
-import voluptuous as vol
-
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_API_KEY
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-
-from .const import DOMAIN, LOGGER
-
-STEP_USER_DATA_SCHEMA = vol.Schema({vol.Required(CONF_API_KEY): cv.string})
-
-
-class FlussConfigFlow(ConfigFlow, domain=DOMAIN):
-    """Handle a config flow for Fluss+."""
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the initial step."""
-
-        errors: dict[str, str] = {}
-        if user_input is not None:
-            api_key = user_input[CONF_API_KEY]
-            self._async_abort_entries_match({CONF_API_KEY: api_key})
-            try:
-                FlussApiClient(
-                    user_input[CONF_API_KEY], session=async_get_clientsession(self.hass)
-                )
-            except FlussApiClientCommunicationError:
-                errors["base"] = "cannot_connect"
-            except FlussApiClientAuthenticationError:
-                errors["base"] = "invalid_auth"
-            except Exception:  # noqa: BLE001
-                LOGGER.exception("Unexpected exception occurred")
-                errors["base"] = "unknown"
-            if not errors:
-                return self.async_create_entry(
-                    title="My Fluss+ Devices", data=user_input
-                )
-
-        return self.async_show_form(
-            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
-        )

homeassistant/components/fluss/const.py

@@ -1,9 +0,0 @@
-"""Constants for the Fluss+ integration."""
-
-from datetime import timedelta
-import logging
-
-DOMAIN = "fluss"
-LOGGER = logging.getLogger(__name__)
-UPDATE_INTERVAL = 60  # seconds
-UPDATE_INTERVAL_TIMEDELTA = timedelta(seconds=UPDATE_INTERVAL)

homeassistant/components/fluss/coordinator.py

@@ -1,50 +0,0 @@
-"""DataUpdateCoordinator for Fluss+ integration."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from fluss_api import (
-    FlussApiClient,
-    FlussApiClientAuthenticationError,
-    FlussApiClientError,
-)
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
-from homeassistant.util import slugify
-
-from .const import LOGGER, UPDATE_INTERVAL_TIMEDELTA
-
-type FlussConfigEntry = ConfigEntry[FlussDataUpdateCoordinator]
-
-
-class FlussDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
-    """Manages fetching Fluss device data on a schedule."""
-
-    def __init__(
-        self, hass: HomeAssistant, config_entry: FlussConfigEntry, api_key: str
-    ) -> None:
-        """Initialize the coordinator."""
-        self.api = FlussApiClient(api_key, session=async_get_clientsession(hass))
-        super().__init__(
-            hass,
-            LOGGER,
-            name=f"Fluss+ ({slugify(api_key[:8])})",
-            config_entry=config_entry,
-            update_interval=UPDATE_INTERVAL_TIMEDELTA,
-        )
-
-    async def _async_update_data(self) -> dict[str, dict[str, Any]]:
-        """Fetch data from the Fluss API and return as a dictionary keyed by deviceId."""
-        try:
-            devices = await self.api.async_get_devices()
-        except FlussApiClientAuthenticationError as err:
-            raise ConfigEntryAuthFailed(f"Authentication failed: {err}") from err
-        except FlussApiClientError as err:
-            raise UpdateFailed(f"Error fetching Fluss devices: {err}") from err
-
-        return {device["deviceId"]: device for device in devices.get("devices", [])}

homeassistant/components/fluss/entity.py

@@ -1,36 +0,0 @@
-"""Base entities for the Fluss+ integration."""
-
-from homeassistant.helpers.entity import DeviceInfo
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from .coordinator import FlussDataUpdateCoordinator
-
-
-class FlussEntity(CoordinatorEntity[FlussDataUpdateCoordinator]):
-    """Base class for Fluss entities."""
-
-    _attr_has_entity_name = True
-    _attr_name = None
-
-    def __init__(
-        self,
-        coordinator: FlussDataUpdateCoordinator,
-        device_id: str,
-        device: dict,
-    ) -> None:
-        """Initialize the entity with a device ID and device data."""
-        super().__init__(coordinator)
-        self.device_id = device_id
-        self._device = device
-        self._attr_unique_id = f"{device_id}"
-        self._attr_device_info = DeviceInfo(
-            identifiers={("fluss", device_id)},
-            name=device.get("deviceName"),
-            manufacturer="Fluss",
-            model="Fluss+ Device",
-        )
-
-    @property
-    def device(self) -> dict:
-        """Return the stored device data."""
-        return self._device

homeassistant/components/fluss/manifest.json

@@ -1,11 +0,0 @@
-{
-  "domain": "fluss",
-  "name": "Fluss+",
-  "codeowners": ["@fluss"],
-  "config_flow": true,
-  "documentation": "https://www.home-assistant.io/integrations/fluss",
-  "iot_class": "cloud_polling",
-  "loggers": ["fluss-api"],
-  "quality_scale": "bronze",
-  "requirements": ["fluss-api==0.1.9.17"]
-}

homeassistant/components/fluss/quality_scale.yaml

@@ -1,69 +0,0 @@
-rules:
-  # Bronze
-  action-setup:
-    status: exempt
-    comment: |
-      No actions present
-  appropriate-polling: done
-  brands: done
-  common-modules: done
-  config-flow-test-coverage: done
-  config-flow: done
-  dependency-transparency: done
-  docs-actions: done
-  docs-high-level-description: done
-  docs-installation-instructions: done
-  docs-removal-instructions: done
-  entity-event-setup: done
-  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: todo
-  config-entry-unloading: done
-  docs-configuration-parameters: done
-  docs-installation-parameters: done
-  integration-owner: done
-  log-when-unavailable: done
-  parallel-updates: todo
-  reauthentication-flow: todo
-  test-coverage: todo
-  # Gold
-  entity-translations: done
-  entity-device-class: done
-  devices: done
-  entity-category: done
-  entity-disabled-by-default:
-    status: exempt
-    comment: |
-      Not needed
-  discovery: todo
-  stale-devices: todo
-  diagnostics: todo
-  exception-translations: todo
-  icon-translations:
-    status: exempt
-    comment: |
-      No icons used
-  reconfiguration-flow: todo
-  dynamic-devices: todo
-  discovery-update-info: todo
-  repair-issues:
-    status: exempt
-    comment: |
-      No issues to repair
-  docs-use-cases: done
-  docs-supported-devices: todo
-  docs-supported-functions: done
-  docs-data-update: todo
-  docs-known-limitations: done
-  docs-troubleshooting: todo
-  docs-examples: todo
-
-  # Platinum
-  async-dependency: done
-  inject-websession: done
-  strict-typing: todo

homeassistant/components/fluss/strings.json

@@ -1,20 +0,0 @@
-{
-  "config": {
-    "step": {
-      "user": {
-        "description": "Your Fluss API key, available in the profile page of the Fluss+ app",
-        "data": {
-          "api_key": "[%key:common::config_flow::data::api_key%]"
-        },
-        "data_description": {
-          "api_key": "The API key found in the profile page of the Fluss+ app."
-        }
-      }
-    },
-    "error": {
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
-      "unknown": "[%key:common::config_flow::error::unknown%]"
-    }
-  }
-}

homeassistant/components/foscam/camera.py

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

homeassistant/components/foscam/coordinator.py

@@ -116,28 +116,20 @@ class FoscamCoordinator(DataUpdateCoordinator[FoscamDeviceInfo]):
         is_open_wdr = None
         is_open_hdr = None
         reserve3 = product_info.get("reserve4")
-        model = product_info.get("model")
-        model_int = int(model) if model is not None else 7002
-        if model_int > 7001:
-            reserve3_int = int(reserve3) if reserve3 is not None else 0
-            supports_wdr_adjustment_val = bool(int(reserve3_int & 256))
-            supports_hdr_adjustment_val = bool(int(reserve3_int & 128))
-            if supports_wdr_adjustment_val:
-                ret_wdr, is_open_wdr_data = self.session.getWdrMode()
-                mode = (
-                    is_open_wdr_data["mode"] if ret_wdr == 0 and is_open_wdr_data else 0
-                )
-                is_open_wdr = bool(int(mode))
-            elif supports_hdr_adjustment_val:
-                ret_hdr, is_open_hdr_data = self.session.getHdrMode()
-                mode = (
-                    is_open_hdr_data["mode"] if ret_hdr == 0 and is_open_hdr_data else 0
-                )
-                is_open_hdr = bool(int(mode))
-        else:
-            supports_wdr_adjustment_val = False
-            supports_hdr_adjustment_val = False
+        reserve3_int = int(reserve3) if reserve3 is not None else 0
+        supports_wdr_adjustment_val = bool(int(reserve3_int & 256))
+        supports_hdr_adjustment_val = bool(int(reserve3_int & 128))
+        if supports_wdr_adjustment_val:
+            ret_wdr, is_open_wdr_data = self.session.getWdrMode()
+            mode = is_open_wdr_data["mode"] if ret_wdr == 0 and is_open_wdr_data else 0
+            is_open_wdr = bool(int(mode))
+        elif supports_hdr_adjustment_val:
+            ret_hdr, is_open_hdr_data = self.session.getHdrMode()
+            mode = is_open_hdr_data["mode"] if ret_hdr == 0 and is_open_hdr_data else 0
+            is_open_hdr = bool(int(mode))
+
         ret_sw, software_capabilities = self.session.getSWCapabilities()
+
         supports_speak_volume_adjustment_val = (
             bool(int(software_capabilities.get("swCapabilities1")) & 32)
             if ret_sw == 0

homeassistant/components/frontend/__init__.py

@@ -481,13 +481,6 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
         sidebar_title="climate",
         sidebar_default_visible=False,
     )
-    async_register_built_in_panel(
-        hass,
-        "home",
-        sidebar_icon="mdi:home",
-        sidebar_title="home",
-        sidebar_default_visible=False,
-    )
 
     async_register_built_in_panel(hass, "profile")
 
@@ -777,7 +770,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"}
+        ),
         vol.Optional("integration"): vol.All(cv.ensure_list, [str]),
     }
 )

homeassistant/components/google/manifest.json

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

homeassistant/components/hive/alarm_control_panel.py

@@ -0,0 +1,77 @@
+"""Support for the Hive alarm."""
+
+from __future__ import annotations
+
+from datetime import timedelta
+
+from homeassistant.components.alarm_control_panel import (
+    AlarmControlPanelEntity,
+    AlarmControlPanelEntityFeature,
+    AlarmControlPanelState,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import HiveConfigEntry
+from .entity import HiveEntity
+
+PARALLEL_UPDATES = 0
+SCAN_INTERVAL = timedelta(seconds=15)
+HIVETOHA = {
+    "home": AlarmControlPanelState.DISARMED,
+    "asleep": AlarmControlPanelState.ARMED_NIGHT,
+    "away": AlarmControlPanelState.ARMED_AWAY,
+    "sos": AlarmControlPanelState.TRIGGERED,
+}
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: HiveConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Hive thermostat based on a config entry."""
+
+    hive = entry.runtime_data
+    if devices := hive.session.deviceList.get("alarm_control_panel"):
+        async_add_entities(
+            [HiveAlarmControlPanelEntity(hive, dev) for dev in devices], True
+        )
+
+
+class HiveAlarmControlPanelEntity(HiveEntity, AlarmControlPanelEntity):
+    """Representation of a Hive alarm."""
+
+    _attr_supported_features = (
+        AlarmControlPanelEntityFeature.ARM_NIGHT
+        | AlarmControlPanelEntityFeature.ARM_AWAY
+        | AlarmControlPanelEntityFeature.TRIGGER
+    )
+    _attr_code_arm_required = False
+
+    async def async_alarm_disarm(self, code: str | None = None) -> None:
+        """Send disarm command."""
+        await self.hive.alarm.setMode(self.device, "home")
+
+    async def async_alarm_arm_night(self, code: str | None = None) -> None:
+        """Send arm night command."""
+        await self.hive.alarm.setMode(self.device, "asleep")
+
+    async def async_alarm_arm_away(self, code: str | None = None) -> None:
+        """Send arm away command."""
+        await self.hive.alarm.setMode(self.device, "away")
+
+    async def async_alarm_trigger(self, code: str | None = None) -> None:
+        """Send alarm trigger command."""
+        await self.hive.alarm.setMode(self.device, "sos")
+
+    async def async_update(self) -> None:
+        """Update all Node data from Hive."""
+        await self.hive.session.updateData(self.device)
+        self.device = await self.hive.alarm.getAlarm(self.device)
+        self._attr_available = self.device["deviceData"].get("online")
+        if self._attr_available:
+            if self.device["status"]["state"]:
+                self._attr_alarm_state = AlarmControlPanelState.TRIGGERED
+            else:
+                self._attr_alarm_state = HIVETOHA[self.device["status"]["mode"]]

homeassistant/components/hive/const.py

@@ -11,6 +11,7 @@ CONFIG_ENTRY_VERSION = 1
 DEFAULT_NAME = "Hive"
 DOMAIN = "hive"
 PLATFORMS = [
+    Platform.ALARM_CONTROL_PANEL,
     Platform.BINARY_SENSOR,
     Platform.CLIMATE,
     Platform.LIGHT,
@@ -19,6 +20,7 @@ PLATFORMS = [
     Platform.WATER_HEATER,
 ]
 PLATFORM_LOOKUP = {
+    Platform.ALARM_CONTROL_PANEL: "alarm_control_panel",
     Platform.BINARY_SENSOR: "binary_sensor",
     Platform.CLIMATE: "climate",
     Platform.LIGHT: "light",

homeassistant/components/hive/manifest.json

@@ -9,5 +9,5 @@
   },
   "iot_class": "cloud_polling",
   "loggers": ["apyhiveapi"],
-  "requirements": ["pyhive-integration==1.0.7"]
+  "requirements": ["pyhive-integration==1.0.6"]
 }

homeassistant/components/home_connect/manifest.json

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

homeassistant/components/home_connect/select.py

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

homeassistant/components/home_connect/sensor.py

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

homeassistant/components/home_connect/strings.json

@@ -1237,7 +1237,7 @@
       "message": "Error obtaining data from the API: {error}"
     },
     "oauth2_implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
+      "message": "OAuth2 implementation temporarily unavailable, will retry"
     },
     "pause_program": {
       "message": "Error pausing program: {error}"

homeassistant/components/homeassistant_connect_zbt2/config_flow.py

@@ -76,18 +76,9 @@ class ZBT2FirmwareMixin(ConfigEntryBaseFlow, FirmwareInstallFlowProtocol):
     """Mixin for Home Assistant Connect ZBT-2 firmware methods."""
 
     context: ConfigFlowContext
-
+    BOOTLOADER_RESET_METHODS = [ResetTarget.RTS_DTR]
     ZIGBEE_BAUDRATE = 460800
 
-    # Early ZBT-2 samples used RTS/DTR to trigger the bootloader, later ones use the
-    # baudrate method. Since the two are mutually exclusive we just use both.
-    BOOTLOADER_RESET_METHODS = [ResetTarget.RTS_DTR, ResetTarget.BAUDRATE]
-    APPLICATION_PROBE_METHODS = [
-        (ApplicationType.GECKO_BOOTLOADER, 115200),
-        (ApplicationType.EZSP, ZIGBEE_BAUDRATE),
-        (ApplicationType.SPINEL, 460800),
-    ]
-
     async def async_step_install_zigbee_firmware(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:

homeassistant/components/homeassistant_connect_zbt2/manifest.json

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

homeassistant/components/homeassistant_connect_zbt2/update.py

@@ -14,6 +14,7 @@ from homeassistant.components.homeassistant_hardware.update import (
 from homeassistant.components.homeassistant_hardware.util import (
     ApplicationType,
     FirmwareInfo,
+    ResetTarget,
 )
 from homeassistant.components.update import UpdateDeviceClass
 from homeassistant.const import EntityCategory
@@ -23,7 +24,6 @@ from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import HomeAssistantConnectZBT2ConfigEntry
-from .config_flow import ZBT2FirmwareMixin
 from .const import DOMAIN, FIRMWARE, FIRMWARE_VERSION, HARDWARE_NAME, SERIAL_NUMBER
 
 _LOGGER = logging.getLogger(__name__)
@@ -134,8 +134,7 @@ async def async_setup_entry(
 class FirmwareUpdateEntity(BaseFirmwareUpdateEntity):
     """Connect ZBT-2 firmware update entity."""
 
-    BOOTLOADER_RESET_METHODS = ZBT2FirmwareMixin.BOOTLOADER_RESET_METHODS
-    APPLICATION_PROBE_METHODS = ZBT2FirmwareMixin.APPLICATION_PROBE_METHODS
+    bootloader_reset_methods = [ResetTarget.RTS_DTR]
 
     def __init__(
         self,

homeassistant/components/homeassistant_hardware/firmware_config_flow.py

@@ -81,7 +81,6 @@ class BaseFirmwareInstallFlow(ConfigEntryBaseFlow, ABC):
 
     ZIGBEE_BAUDRATE = 115200  # Default, subclasses may override
     BOOTLOADER_RESET_METHODS: list[ResetTarget] = []  # Default, subclasses may override
-    APPLICATION_PROBE_METHODS: list[tuple[ApplicationType, int]] = []
 
     _picked_firmware_type: PickedFirmwareType
     _zigbee_flow_strategy: ZigbeeFlowStrategy = ZigbeeFlowStrategy.RECOMMENDED
@@ -231,11 +230,7 @@ class BaseFirmwareInstallFlow(ConfigEntryBaseFlow, ABC):
         # Installing new firmware is only truly required if the wrong type is
         # installed: upgrading to the latest release of the current firmware type
         # isn't strictly necessary for functionality.
-        self._probed_firmware_info = await probe_silabs_firmware_info(
-            self._device,
-            bootloader_reset_methods=self.BOOTLOADER_RESET_METHODS,
-            application_probe_methods=self.APPLICATION_PROBE_METHODS,
-        )
+        self._probed_firmware_info = await probe_silabs_firmware_info(self._device)
 
         firmware_install_required = self._probed_firmware_info is None or (
             self._probed_firmware_info.firmware_type != expected_installed_firmware_type
@@ -300,7 +295,6 @@ class BaseFirmwareInstallFlow(ConfigEntryBaseFlow, ABC):
             fw_data=fw_data,
             expected_installed_firmware_type=expected_installed_firmware_type,
             bootloader_reset_methods=self.BOOTLOADER_RESET_METHODS,
-            application_probe_methods=self.APPLICATION_PROBE_METHODS,
             progress_callback=lambda offset, total: self.async_update_progress(
                 offset / total
             ),

homeassistant/components/homeassistant_hardware/manifest.json

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

homeassistant/components/homeassistant_hardware/update.py

@@ -86,8 +86,7 @@ class BaseFirmwareUpdateEntity(
 
     # Subclasses provide the mapping between firmware types and entity descriptions
     entity_description: FirmwareUpdateEntityDescription
-    BOOTLOADER_RESET_METHODS: list[ResetTarget]
-    APPLICATION_PROBE_METHODS: list[tuple[ApplicationType, int]]
+    bootloader_reset_methods: list[ResetTarget] = []
 
     _attr_supported_features = (
         UpdateEntityFeature.INSTALL | UpdateEntityFeature.PROGRESS
@@ -279,8 +278,7 @@ class BaseFirmwareUpdateEntity(
                 device=self._current_device,
                 fw_data=fw_data,
                 expected_installed_firmware_type=self.entity_description.expected_firmware_type,
-                bootloader_reset_methods=self.BOOTLOADER_RESET_METHODS,
-                application_probe_methods=self.APPLICATION_PROBE_METHODS,
+                bootloader_reset_methods=self.bootloader_reset_methods,
                 progress_callback=self._update_progress,
                 domain=self._config_entry.domain,
             )

homeassistant/components/homeassistant_hardware/util.py

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

homeassistant/components/homeassistant_sky_connect/config_flow.py

@@ -16,7 +16,6 @@ from homeassistant.components.homeassistant_hardware.helpers import (
 from homeassistant.components.homeassistant_hardware.util import (
     ApplicationType,
     FirmwareInfo,
-    ResetTarget,
 )
 from homeassistant.components.usb import (
     usb_service_info_from_device,
@@ -80,20 +79,6 @@ class SkyConnectFirmwareMixin(ConfigEntryBaseFlow, FirmwareInstallFlowProtocol):
 
     context: ConfigFlowContext
 
-    ZIGBEE_BAUDRATE = 115200
-    # There is no hardware bootloader trigger
-    BOOTLOADER_RESET_METHODS: list[ResetTarget] = []
-    APPLICATION_PROBE_METHODS = [
-        (ApplicationType.GECKO_BOOTLOADER, 115200),
-        (ApplicationType.EZSP, ZIGBEE_BAUDRATE),
-        (ApplicationType.SPINEL, 460800),
-        # CPC baudrates can be removed once multiprotocol is removed
-        (ApplicationType.CPC, 115200),
-        (ApplicationType.CPC, 230400),
-        (ApplicationType.CPC, 460800),
-        (ApplicationType.ROUTER, 115200),
-    ]
-
     def _get_translation_placeholders(self) -> dict[str, str]:
         """Shared translation placeholders."""
         placeholders = {

homeassistant/components/homeassistant_sky_connect/manifest.json

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

homeassistant/components/homeassistant_sky_connect/update.py

@@ -23,7 +23,6 @@ from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import HomeAssistantSkyConnectConfigEntry
-from .config_flow import SkyConnectFirmwareMixin
 from .const import (
     DOMAIN,
     FIRMWARE,
@@ -152,8 +151,8 @@ async def async_setup_entry(
 class FirmwareUpdateEntity(BaseFirmwareUpdateEntity):
     """SkyConnect firmware update entity."""
 
-    BOOTLOADER_RESET_METHODS = SkyConnectFirmwareMixin.BOOTLOADER_RESET_METHODS
-    APPLICATION_PROBE_METHODS = SkyConnectFirmwareMixin.APPLICATION_PROBE_METHODS
+    # The ZBT-1 does not have a hardware bootloader trigger
+    bootloader_reset_methods = []
 
     def __init__(
         self,

homeassistant/components/homeassistant_yellow/config_flow.py

@@ -82,18 +82,7 @@ else:
 class YellowFirmwareMixin(ConfigEntryBaseFlow, FirmwareInstallFlowProtocol):
     """Mixin for Home Assistant Yellow firmware methods."""
 
-    ZIGBEE_BAUDRATE = 115200
     BOOTLOADER_RESET_METHODS = [ResetTarget.YELLOW]
-    APPLICATION_PROBE_METHODS = [
-        (ApplicationType.GECKO_BOOTLOADER, 115200),
-        (ApplicationType.EZSP, ZIGBEE_BAUDRATE),
-        (ApplicationType.SPINEL, 460800),
-        # CPC baudrates can be removed once multiprotocol is removed
-        (ApplicationType.CPC, 115200),
-        (ApplicationType.CPC, 230400),
-        (ApplicationType.CPC, 460800),
-        (ApplicationType.ROUTER, 115200),
-    ]
 
     async def async_step_install_zigbee_firmware(
         self, user_input: dict[str, Any] | None = None
@@ -157,11 +146,7 @@ class HomeAssistantYellowConfigFlow(
         assert self._device is not None
 
         # We do not actually use any portion of `BaseFirmwareConfigFlow` beyond this
-        self._probed_firmware_info = await probe_silabs_firmware_info(
-            self._device,
-            bootloader_reset_methods=self.BOOTLOADER_RESET_METHODS,
-            application_probe_methods=self.APPLICATION_PROBE_METHODS,
-        )
+        self._probed_firmware_info = await probe_silabs_firmware_info(self._device)
 
         # Kick off ZHA hardware discovery automatically if Zigbee firmware is running
         if (

homeassistant/components/homeassistant_yellow/manifest.json

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

homeassistant/components/homeassistant_yellow/update.py

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

homeassistant/components/hunterdouglas_powerview/__init__.py

@@ -4,7 +4,6 @@ import logging
 from typing import TYPE_CHECKING
 
 from aiopvapi.resources.model import PowerviewData
-from aiopvapi.resources.shade_data import PowerviewShadeData
 from aiopvapi.rooms import Rooms
 from aiopvapi.scenes import Scenes
 from aiopvapi.shades import Shades
@@ -17,6 +16,7 @@ from homeassistant.helpers import device_registry as dr, entity_registry as er
 from .const import DOMAIN, HUB_EXCEPTIONS, MANUFACTURER
 from .coordinator import PowerviewShadeUpdateCoordinator
 from .model import PowerviewConfigEntry, PowerviewEntryData
+from .shade_data import PowerviewShadeData
 from .util import async_connect_hub
 
 PARALLEL_UPDATES = 1

homeassistant/components/hunterdouglas_powerview/coordinator.py

@@ -8,7 +8,6 @@ import logging
 
 from aiopvapi.helpers.aiorequest import PvApiMaintenance
 from aiopvapi.hub import Hub
-from aiopvapi.resources.shade_data import PowerviewShadeData
 from aiopvapi.shades import Shades
 
 from homeassistant.config_entries import ConfigEntry
@@ -16,6 +15,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
 from .const import HUB_EXCEPTIONS
+from .shade_data import PowerviewShadeData
 
 _LOGGER = logging.getLogger(__name__)
 

homeassistant/components/hunterdouglas_powerview/cover.py

@@ -208,13 +208,13 @@ class PowerViewShadeBase(ShadeEntity, CoverEntity):
     async def _async_execute_move(self, move: ShadePosition) -> None:
         """Execute a move that can affect multiple positions."""
         _LOGGER.debug("Move request %s: %s", self.name, move)
-        # Store the requested positions so subsequent move
-        # requests contain the secondary shade positions
-        self.data.update_shade_position(self._shade.id, move)
         async with self.coordinator.radio_operation_lock:
             response = await self._shade.move(move)
         _LOGGER.debug("Move response %s: %s", self.name, response)
 
+        # Process the response from the hub (including new positions)
+        self.data.update_shade_position(self._shade.id, response)
+
     async def _async_set_cover_position(self, target_hass_position: int) -> None:
         """Move the shade to a position."""
         target_hass_position = self._clamp_cover_limit(target_hass_position)

homeassistant/components/hunterdouglas_powerview/entity.py

@@ -3,7 +3,6 @@
 import logging
 
 from aiopvapi.resources.shade import BaseShade, ShadePosition
-from aiopvapi.resources.shade_data import PowerviewShadeData
 
 from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.device_registry import DeviceInfo
@@ -12,6 +11,7 @@ from homeassistant.helpers.update_coordinator import CoordinatorEntity
 from .const import DOMAIN, MANUFACTURER
 from .coordinator import PowerviewShadeUpdateCoordinator
 from .model import PowerviewDeviceInfo
+from .shade_data import PowerviewShadeData
 
 _LOGGER = logging.getLogger(__name__)
 

homeassistant/components/hunterdouglas_powerview/manifest.json

@@ -18,6 +18,6 @@
   },
   "iot_class": "local_polling",
   "loggers": ["aiopvapi"],
-  "requirements": ["aiopvapi==3.3.0"],
+  "requirements": ["aiopvapi==3.2.1"],
   "zeroconf": ["_powerview._tcp.local.", "_PowerView-G3._tcp.local."]
 }

homeassistant/components/hunterdouglas_powerview/shade_data.py

@@ -0,0 +1,80 @@
+"""Shade data for the Hunter Douglas PowerView integration."""
+
+from __future__ import annotations
+
+from dataclasses import fields
+from typing import Any
+
+from aiopvapi.resources.model import PowerviewData
+from aiopvapi.resources.shade import BaseShade, ShadePosition
+
+from .util import async_map_data_by_id
+
+POSITION_FIELDS = [field for field in fields(ShadePosition) if field.name != "velocity"]
+
+
+def copy_position_data(source: ShadePosition, target: ShadePosition) -> ShadePosition:
+    """Copy position data from source to target for None values only."""
+    for field in POSITION_FIELDS:
+        if (value := getattr(source, field.name)) is not None:
+            setattr(target, field.name, value)
+
+
+class PowerviewShadeData:
+    """Coordinate shade data between multiple api calls."""
+
+    def __init__(self) -> None:
+        """Init the shade data."""
+        self._raw_data_by_id: dict[int, dict[str | int, Any]] = {}
+        self._shade_group_data_by_id: dict[int, BaseShade] = {}
+        self.positions: dict[int, ShadePosition] = {}
+
+    def get_raw_data(self, shade_id: int) -> dict[str | int, Any]:
+        """Get data for the shade."""
+        return self._raw_data_by_id[shade_id]
+
+    def get_all_raw_data(self) -> dict[int, dict[str | int, Any]]:
+        """Get data for all shades."""
+        return self._raw_data_by_id
+
+    def get_shade(self, shade_id: int) -> BaseShade:
+        """Get specific shade from the coordinator."""
+        return self._shade_group_data_by_id[shade_id]
+
+    def get_shade_position(self, shade_id: int) -> ShadePosition:
+        """Get positions for a shade."""
+        if shade_id not in self.positions:
+            shade_position = ShadePosition()
+            # If we have the group data, use it to populate the initial position
+            if shade := self._shade_group_data_by_id.get(shade_id):
+                copy_position_data(shade.current_position, shade_position)
+            self.positions[shade_id] = shade_position
+        return self.positions[shade_id]
+
+    def update_from_group_data(self, shade_id: int) -> None:
+        """Process an update from the group data."""
+        data = self._shade_group_data_by_id[shade_id]
+        copy_position_data(data.current_position, self.get_shade_position(data.id))
+
+    def store_group_data(self, shade_data: PowerviewData) -> None:
+        """Store data from the all shades endpoint.
+
+        This does not update the shades or positions (self.positions)
+        as the data may be stale. update_from_group_data
+        with a shade_id will update a specific shade
+        from the group data.
+        """
+        self._shade_group_data_by_id = shade_data.processed
+        self._raw_data_by_id = async_map_data_by_id(shade_data.raw)
+
+    def update_shade_position(self, shade_id: int, new_position: ShadePosition) -> None:
+        """Update a single shades position."""
+        copy_position_data(new_position, self.get_shade_position(shade_id))
+
+    def update_shade_velocity(self, shade_id: int, shade_data: ShadePosition) -> None:
+        """Update a single shades velocity."""
+        # the hub will always return a velocity of 0 on initial connect,
+        # separate definition to store consistent value in HA
+        # this value is purely driven from HA
+        if shade_data.velocity is not None:
+            self.get_shade_position(shade_id).velocity = shade_data.velocity

homeassistant/components/hunterdouglas_powerview/util.py

@@ -2,15 +2,25 @@
 
 from __future__ import annotations
 
+from collections.abc import Iterable
+from typing import Any
+
 from aiopvapi.helpers.aiorequest import AioRequest
+from aiopvapi.helpers.constants import ATTR_ID
 from aiopvapi.hub import Hub
 
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
 from .model import PowerviewAPI, PowerviewDeviceInfo
 
 
+@callback
+def async_map_data_by_id(data: Iterable[dict[str | int, Any]]):
+    """Return a dict with the key being the id for a list of entries."""
+    return {entry[ATTR_ID]: entry for entry in data}
+
+
 async def async_connect_hub(
     hass: HomeAssistant, address: str, api_version: int | None = None
 ) -> PowerviewAPI:

homeassistant/components/hyperion/camera.py

@@ -13,7 +13,6 @@ from typing import Any
 from aiohttp import web
 from hyperion import client
 from hyperion.const import (
-    KEY_DATA,
     KEY_IMAGE,
     KEY_IMAGE_STREAM,
     KEY_LEDCOLORS,
@@ -156,8 +155,7 @@ class HyperionCamera(Camera):
         """Update Hyperion components."""
         if not img:
             return
-        # Prefer KEY_DATA (Hyperion server >= 2.1.1); fall back to KEY_RESULT for older server versions
-        img_data = img.get(KEY_DATA, img.get(KEY_RESULT, {})).get(KEY_IMAGE)
+        img_data = img.get(KEY_RESULT, {}).get(KEY_IMAGE)
         if not img_data or not img_data.startswith(IMAGE_STREAM_JPG_SENTINEL):
             return
         async with self._image_cond:

homeassistant/components/ituran/binary_sensor.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from collections.abc import Callable
 from dataclasses import dataclass
 
+from propcache.api import cached_property
 from pyituran import Vehicle
 
 from homeassistant.components.binary_sensor import (
@@ -68,7 +69,7 @@ class IturanBinarySensor(IturanBaseEntity, BinarySensorEntity):
         super().__init__(coordinator, license_plate, description.key)
         self.entity_description = description
 
-    @property
+    @cached_property
     def is_on(self) -> bool:
         """Return true if the binary sensor is on."""
         return self.entity_description.value_fn(self.vehicle)

homeassistant/components/ituran/device_tracker.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+from propcache.api import cached_property
+
 from homeassistant.components.device_tracker import TrackerEntity
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
@@ -38,12 +40,12 @@ class IturanDeviceTracker(IturanBaseEntity, TrackerEntity):
         """Initialize the device tracker."""
         super().__init__(coordinator, license_plate, "device_tracker")
 
-    @property
+    @cached_property
     def latitude(self) -> float | None:
         """Return latitude value of the device."""
         return self.vehicle.gps_coordinates[0]
 
-    @property
+    @cached_property
     def longitude(self) -> float | None:
         """Return longitude value of the device."""
         return self.vehicle.gps_coordinates[1]

homeassistant/components/ituran/sensor.py

@@ -6,6 +6,7 @@ from collections.abc import Callable
 from dataclasses import dataclass
 from datetime import datetime
 
+from propcache.api import cached_property
 from pyituran import Vehicle
 
 from homeassistant.components.sensor import (
@@ -132,7 +133,7 @@ class IturanSensor(IturanBaseEntity, SensorEntity):
         super().__init__(coordinator, license_plate, description.key)
         self.entity_description = description
 
-    @property
+    @cached_property
     def native_value(self) -> StateType | datetime:
         """Return the state of the device."""
         return self.entity_description.value_fn(self.vehicle)

homeassistant/components/lamarzocco/manifest.json

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

homeassistant/components/lamarzocco/update.py

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

homeassistant/components/lcn/strings.json

@@ -94,6 +94,28 @@
     }
   },
   "services": {
+    "address_to_device_id": {
+      "description": "Converts an LCN address into a device ID.",
+      "fields": {
+        "host": {
+          "description": "Host name as given in the integration panel.",
+          "name": "Host name"
+        },
+        "id": {
+          "description": "Module or group number of the target.",
+          "name": "Module or group ID"
+        },
+        "segment_id": {
+          "description": "Segment number of the target.",
+          "name": "Segment ID"
+        },
+        "type": {
+          "description": "Module type of the target.",
+          "name": "Type"
+        }
+      },
+      "name": "Address to device ID"
+    },
     "dyn_text": {
       "description": "Sends dynamic text to LCN-GTxD displays.",
       "fields": {

homeassistant/components/light/condition.py

@@ -0,0 +1,131 @@
+"""Provides conditions for lights."""
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, Final, override
+
+import voluptuous as vol
+
+from homeassistant.const import CONF_OPTIONS, CONF_TARGET, STATE_OFF, STATE_ON
+from homeassistant.core import HomeAssistant, split_entity_id
+from homeassistant.helpers import config_validation as cv, target
+from homeassistant.helpers.condition import (
+    Condition,
+    ConditionCheckerType,
+    ConditionConfig,
+    trace_condition_function,
+)
+from homeassistant.helpers.typing import ConfigType, TemplateVarsType
+
+from .const import DOMAIN
+
+ATTR_BEHAVIOR: Final = "behavior"
+BEHAVIOR_ANY: Final = "any"
+BEHAVIOR_ALL: Final = "all"
+
+
+STATE_CONDITION_VALID_STATES: Final = [STATE_ON, STATE_OFF]
+STATE_CONDITION_OPTIONS_SCHEMA: dict[vol.Marker, Any] = {
+    vol.Required(ATTR_BEHAVIOR, default=BEHAVIOR_ANY): vol.In(
+        [BEHAVIOR_ANY, BEHAVIOR_ALL]
+    ),
+}
+STATE_CONDITION_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_TARGET): cv.TARGET_FIELDS,
+        vol.Required(CONF_OPTIONS): STATE_CONDITION_OPTIONS_SCHEMA,
+    }
+)
+
+
+class StateConditionBase(Condition):
+    """State condition."""
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return STATE_CONDITION_SCHEMA(config)  # type: ignore[no-any-return]
+
+    def __init__(
+        self, hass: HomeAssistant, config: ConditionConfig, state: str
+    ) -> None:
+        """Initialize condition."""
+        self._hass = hass
+        if TYPE_CHECKING:
+            assert config.target
+            assert config.options
+        self._target = config.target
+        self._behavior = config.options[ATTR_BEHAVIOR]
+        self._state = state
+
+    @override
+    async def async_get_checker(self) -> ConditionCheckerType:
+        """Get the condition checker."""
+
+        def check_any_match_state(states: list[str]) -> bool:
+            """Test if any entity match the state."""
+            return any(state == self._state for state in states)
+
+        def check_all_match_state(states: list[str]) -> bool:
+            """Test if all entities match the state."""
+            return all(state == self._state for state in states)
+
+        matcher: Callable[[list[str]], bool]
+        if self._behavior == BEHAVIOR_ANY:
+            matcher = check_any_match_state
+        elif self._behavior == BEHAVIOR_ALL:
+            matcher = check_all_match_state
+
+        @trace_condition_function
+        def test_state(hass: HomeAssistant, variables: TemplateVarsType = None) -> bool:
+            """Test state condition."""
+            selector_data = target.TargetSelectorData(self._target)
+            targeted_entities = target.async_extract_referenced_entity_ids(
+                hass, selector_data, expand_group=False
+            )
+            referenced_entity_ids = targeted_entities.referenced.union(
+                targeted_entities.indirectly_referenced
+            )
+            light_entity_ids = {
+                entity_id
+                for entity_id in referenced_entity_ids
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+            light_entity_states = [
+                state.state
+                for entity_id in light_entity_ids
+                if (state := hass.states.get(entity_id))
+                and state.state in STATE_CONDITION_VALID_STATES
+            ]
+            return matcher(light_entity_states)
+
+        return test_state
+
+
+class IsOnCondition(StateConditionBase):
+    """Is on condition."""
+
+    def __init__(self, hass: HomeAssistant, config: ConditionConfig) -> None:
+        """Initialize condition."""
+        super().__init__(hass, config, STATE_ON)
+
+
+class IsOffCondition(StateConditionBase):
+    """Is off condition."""
+
+    def __init__(self, hass: HomeAssistant, config: ConditionConfig) -> None:
+        """Initialize condition."""
+        super().__init__(hass, config, STATE_OFF)
+
+
+CONDITIONS: dict[str, type[Condition]] = {
+    "is_off": IsOffCondition,
+    "is_on": IsOnCondition,
+}
+
+
+async def async_get_conditions(hass: HomeAssistant) -> dict[str, type[Condition]]:
+    """Return the light conditions."""
+    return CONDITIONS

homeassistant/components/light/conditions.yaml

@@ -0,0 +1,28 @@
+is_off:
+  target:
+    entity:
+      domain: light
+  fields:
+    behavior:
+      required: true
+      default: any
+      selector:
+        select:
+          translation_key: condition_behavior
+          options:
+            - all
+            - any
+is_on:
+  target:
+    entity:
+      domain: light
+  fields:
+    behavior:
+      required: true
+      default: any
+      selector:
+        select:
+          translation_key: condition_behavior
+          options:
+            - all
+            - any

homeassistant/components/light/icons.json

@@ -1,4 +1,12 @@
 {
+  "conditions": {
+    "is_off": {
+      "condition": "mdi:lightbulb-off"
+    },
+    "is_on": {
+      "condition": "mdi:lightbulb-on"
+    }
+  },
   "entity_component": {
     "_": {
       "default": "mdi:lightbulb",
@@ -25,5 +33,13 @@
     "turn_on": {
       "service": "mdi:lightbulb-on"
     }
+  },
+  "triggers": {
+    "turned_off": {
+      "trigger": "mdi:lightbulb-off"
+    },
+    "turned_on": {
+      "trigger": "mdi:lightbulb-on"
+    }
   }
 }

homeassistant/components/light/strings.json

@@ -36,6 +36,30 @@
     "field_xy_color_name": "XY-color",
     "section_advanced_fields_name": "Advanced options"
   },
+  "conditions": {
+    "is_off": {
+      "description": "Test if a light is off.",
+      "description_configured": "[%key:component::light::conditions::is_off::description%]",
+      "fields": {
+        "behavior": {
+          "description": "How the state should match on the targeted lights.",
+          "name": "Behavior"
+        }
+      },
+      "name": "If a light is off"
+    },
+    "is_on": {
+      "description": "Test if a light is on.",
+      "description_configured": "[%key:component::light::conditions::is_on::description%]",
+      "fields": {
+        "behavior": {
+          "description": "How the state should match on the targeted lights.",
+          "name": "Behavior"
+        }
+      },
+      "name": "If a light is on"
+    }
+  },
   "device_automation": {
     "action_type": {
       "brightness_decrease": "Decrease {entity_name} brightness",
@@ -284,11 +308,30 @@
         "yellowgreen": "Yellow green"
       }
     },
+    "condition_behavior": {
+      "options": {
+        "all": "All",
+        "any": "Any"
+      }
+    },
     "flash": {
       "options": {
         "long": "Long",
         "short": "Short"
       }
+    },
+    "state": {
+      "options": {
+        "off": "[%key:common::state::off%]",
+        "on": "[%key:common::state::on%]"
+      }
+    },
+    "trigger_behavior": {
+      "options": {
+        "any": "Any",
+        "first": "First",
+        "last": "Last"
+      }
     }
   },
   "services": {
@@ -462,5 +505,29 @@
       }
     }
   },
-  "title": "Light"
+  "title": "Light",
+  "triggers": {
+    "turned_off": {
+      "description": "Triggers when a light is turned off.",
+      "description_configured": "[%key:component::light::triggers::turned_off::description%]",
+      "fields": {
+        "behavior": {
+          "description": "The behavior of the targeted lights to trigger on.",
+          "name": "Behavior"
+        }
+      },
+      "name": "When a light is turned off"
+    },
+    "turned_on": {
+      "description": "Triggers when a light is turned on.",
+      "description_configured": "[%key:component::light::triggers::turned_on::description%]",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::light::triggers::turned_off::fields::behavior::description%]",
+          "name": "[%key:component::light::triggers::turned_off::fields::behavior::name%]"
+        }
+      },
+      "name": "When a light is turned on"
+    }
+  }
 }

homeassistant/components/light/trigger.py

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

homeassistant/components/light/triggers.yaml

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

homeassistant/components/local_calendar/manifest.json

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

homeassistant/components/local_todo/manifest.json

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

homeassistant/components/lunatone/manifest.json

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

homeassistant/components/matter/binary_sensor.py

@@ -353,13 +353,17 @@ DISCOVERY_SCHEMAS = [
             device_class=BinarySensorDeviceClass.PROBLEM,
             entity_category=EntityCategory.DIAGNOSTIC,
             # DeviceFault or SupplyFault bit enabled
-            device_to_ha=lambda x: bool(
-                x
-                & (
-                    clusters.PumpConfigurationAndControl.Bitmaps.PumpStatusBitmap.kDeviceFault
-                    | clusters.PumpConfigurationAndControl.Bitmaps.PumpStatusBitmap.kSupplyFault
-                )
-            ),
+            device_to_ha={
+                clusters.PumpConfigurationAndControl.Bitmaps.PumpStatusBitmap.kDeviceFault: True,
+                clusters.PumpConfigurationAndControl.Bitmaps.PumpStatusBitmap.kSupplyFault: True,
+                clusters.PumpConfigurationAndControl.Bitmaps.PumpStatusBitmap.kSpeedLow: False,
+                clusters.PumpConfigurationAndControl.Bitmaps.PumpStatusBitmap.kSpeedHigh: False,
+                clusters.PumpConfigurationAndControl.Bitmaps.PumpStatusBitmap.kLocalOverride: False,
+                clusters.PumpConfigurationAndControl.Bitmaps.PumpStatusBitmap.kRunning: False,
+                clusters.PumpConfigurationAndControl.Bitmaps.PumpStatusBitmap.kRemotePressure: False,
+                clusters.PumpConfigurationAndControl.Bitmaps.PumpStatusBitmap.kRemoteFlow: False,
+                clusters.PumpConfigurationAndControl.Bitmaps.PumpStatusBitmap.kRemoteTemperature: False,
+            }.get,
         ),
         entity_class=MatterBinarySensor,
         required_attributes=(
@@ -373,9 +377,9 @@ DISCOVERY_SCHEMAS = [
             key="PumpStatusRunning",
             translation_key="pump_running",
             device_class=BinarySensorDeviceClass.RUNNING,
-            device_to_ha=lambda x: bool(
+            device_to_ha=lambda x: (
                 x
-                & clusters.PumpConfigurationAndControl.Bitmaps.PumpStatusBitmap.kRunning
+                == clusters.PumpConfigurationAndControl.Bitmaps.PumpStatusBitmap.kRunning
             ),
         ),
         entity_class=MatterBinarySensor,
@@ -391,8 +395,8 @@ DISCOVERY_SCHEMAS = [
             translation_key="dishwasher_alarm_inflow",
             device_class=BinarySensorDeviceClass.PROBLEM,
             entity_category=EntityCategory.DIAGNOSTIC,
-            device_to_ha=lambda x: bool(
-                x & clusters.DishwasherAlarm.Bitmaps.AlarmBitmap.kInflowError
+            device_to_ha=lambda x: (
+                x == clusters.DishwasherAlarm.Bitmaps.AlarmBitmap.kInflowError
             ),
         ),
         entity_class=MatterBinarySensor,
@@ -406,8 +410,8 @@ DISCOVERY_SCHEMAS = [
             translation_key="alarm_door",
             device_class=BinarySensorDeviceClass.PROBLEM,
             entity_category=EntityCategory.DIAGNOSTIC,
-            device_to_ha=lambda x: bool(
-                x & clusters.DishwasherAlarm.Bitmaps.AlarmBitmap.kDoorError
+            device_to_ha=lambda x: (
+                x == clusters.DishwasherAlarm.Bitmaps.AlarmBitmap.kDoorError
             ),
         ),
         entity_class=MatterBinarySensor,
@@ -477,8 +481,8 @@ DISCOVERY_SCHEMAS = [
             translation_key="alarm_door",
             device_class=BinarySensorDeviceClass.PROBLEM,
             entity_category=EntityCategory.DIAGNOSTIC,
-            device_to_ha=lambda x: bool(
-                x & clusters.RefrigeratorAlarm.Bitmaps.AlarmBitmap.kDoorOpen
+            device_to_ha=lambda x: (
+                x == clusters.RefrigeratorAlarm.Bitmaps.AlarmBitmap.kDoorOpen
             ),
         ),
         entity_class=MatterBinarySensor,

homeassistant/components/mealie/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "local_polling",
   "quality_scale": "platinum",
-  "requirements": ["aiomealie==1.1.0"]
+  "requirements": ["aiomealie==1.0.1"]
 }

homeassistant/components/media_player/icons.json

@@ -104,5 +104,10 @@
     "volume_up": {
       "service": "mdi:volume-plus"
     }
+  },
+  "triggers": {
+    "stopped_playing": {
+      "trigger": "mdi:stop"
+    }
   }
 }

homeassistant/components/media_player/strings.json

@@ -177,6 +177,13 @@
         "off": "[%key:common::state::off%]",
         "one": "Repeat one"
       }
+    },
+    "trigger_behavior": {
+      "options": {
+        "any": "Any",
+        "first": "First",
+        "last": "Last"
+      }
     }
   },
   "services": {
@@ -367,5 +374,18 @@
       "name": "Turn up volume"
     }
   },
-  "title": "Media player"
+  "title": "Media player",
+  "triggers": {
+    "stopped_playing": {
+      "description": "Triggers when a media player stops playing.",
+      "description_configured": "[%key:component::media_player::triggers::stopped_playing::description%]",
+      "fields": {
+        "behavior": {
+          "description": "The behavior of the targeted media players to trigger on.",
+          "name": "Behavior"
+        }
+      },
+      "name": "When a media player stops playing"
+    }
+  }
 }

homeassistant/components/media_player/trigger.py

@@ -0,0 +1,41 @@
+"""Provides triggers for media players."""
+
+from homeassistant.core import HomeAssistant, State
+from homeassistant.helpers.trigger import EntityTriggerBase, Trigger
+
+from . import MediaPlayerState
+from .const import DOMAIN
+
+
+class MediaPlayerStoppedPlayingTrigger(EntityTriggerBase):
+    """Class for media player stopped playing trigger."""
+
+    _domain: str = DOMAIN
+    _from_states = {
+        MediaPlayerState.BUFFERING,
+        MediaPlayerState.PAUSED,
+        MediaPlayerState.PLAYING,
+    }
+    _to_states = {
+        MediaPlayerState.IDLE,
+        MediaPlayerState.OFF,
+        MediaPlayerState.ON,
+    }
+
+    def is_from_state(self, state: State) -> bool:
+        """Check if the state matches the origin state."""
+        return state.state in self._from_states
+
+    def is_to_state(self, state: State) -> bool:
+        """Check if the state matches the target state."""
+        return state.state in self._to_states
+
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "stopped_playing": MediaPlayerStoppedPlayingTrigger,
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for media players."""
+    return TRIGGERS

homeassistant/components/media_player/triggers.yaml

@@ -0,0 +1,15 @@
+stopped_playing:
+  target:
+    entity:
+      domain: media_player
+  fields:
+    behavior:
+      required: true
+      default: any
+      selector:
+        select:
+          translation_key: trigger_behavior
+          options:
+            - first
+            - last
+            - any

homeassistant/components/miele/strings.json

@@ -1009,7 +1009,7 @@
           "cleaning_care_program": "Cleaning/care program",
           "maintenance_program": "Maintenance program",
           "normal_operation_mode": "Normal operation mode",
-          "own_program": "Program"
+          "own_program": "Own program"
         }
       },
       "remaining_time": {
@@ -1089,7 +1089,7 @@
       "message": "Invalid device targeted."
     },
     "oauth2_implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
+      "message": "OAuth2 implementation unavailable, will retry"
     },
     "set_program_error": {
       "message": "'Set program' action failed: {status} / {message}"

homeassistant/components/mill/manifest.json

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

homeassistant/components/mobile_app/binary_sensor.py

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

homeassistant/components/mobile_app/sensor.py

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

homeassistant/components/music_assistant/config_flow.py

@@ -13,7 +13,7 @@ from music_assistant_client.exceptions import (
 from music_assistant_models.api import ServerInfoMessage
 import voluptuous as vol
 
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.config_entries import SOURCE_IGNORE, ConfigFlow, ConfigFlowResult
 from homeassistant.const import CONF_URL
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import aiohttp_client
@@ -21,14 +21,21 @@ from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo
 
 from .const import DOMAIN, LOGGER
 
-DEFAULT_TITLE = "Music Assistant"
 DEFAULT_URL = "http://mass.local:8095"
+DEFAULT_TITLE = "Music Assistant"
 
 
-STEP_USER_SCHEMA = vol.Schema({vol.Required(CONF_URL): str})
+def get_manual_schema(user_input: dict[str, Any]) -> vol.Schema:
+    """Return a schema for the manual step."""
+    default_url = user_input.get(CONF_URL, DEFAULT_URL)
+    return vol.Schema(
+        {
+            vol.Required(CONF_URL, default=default_url): str,
+        }
+    )
 
 
-async def _get_server_info(hass: HomeAssistant, url: str) -> ServerInfoMessage:
+async def get_server_info(hass: HomeAssistant, url: str) -> ServerInfoMessage:
     """Validate the user input allows us to connect."""
     async with MusicAssistantClient(
         url, aiohttp_client.async_get_clientsession(hass)
@@ -45,17 +52,25 @@ class MusicAssistantConfigFlow(ConfigFlow, domain=DOMAIN):
 
     def __init__(self) -> None:
         """Set up flow instance."""
-        self.url: str | None = None
+        self.server_info: ServerInfoMessage | None = None
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Handle a manual configuration."""
         errors: dict[str, str] = {}
-
         if user_input is not None:
             try:
-                server_info = await _get_server_info(self.hass, user_input[CONF_URL])
+                self.server_info = await get_server_info(
+                    self.hass, user_input[CONF_URL]
+                )
+                await self.async_set_unique_id(
+                    self.server_info.server_id, raise_on_progress=False
+                )
+                self._abort_if_unique_id_configured(
+                    updates={CONF_URL: user_input[CONF_URL]},
+                    reload_on_update=True,
+                )
             except CannotConnect:
                 errors["base"] = "cannot_connect"
             except InvalidServerVersion:
@@ -64,49 +79,68 @@ class MusicAssistantConfigFlow(ConfigFlow, domain=DOMAIN):
                 LOGGER.exception("Unexpected exception")
                 errors["base"] = "unknown"
             else:
-                await self.async_set_unique_id(
-                    server_info.server_id, raise_on_progress=False
-                )
-                self._abort_if_unique_id_configured(
-                    updates={CONF_URL: user_input[CONF_URL]}
-                )
-
                 return self.async_create_entry(
                     title=DEFAULT_TITLE,
-                    data={CONF_URL: user_input[CONF_URL]},
+                    data={
+                        CONF_URL: user_input[CONF_URL],
+                    },
                 )
 
-        suggested_values = user_input
-        if suggested_values is None:
-            suggested_values = {CONF_URL: DEFAULT_URL}
+            return self.async_show_form(
+                step_id="user", data_schema=get_manual_schema(user_input), errors=errors
+            )
 
-        return self.async_show_form(
-            step_id="user",
-            data_schema=self.add_suggested_values_to_schema(
-                STEP_USER_SCHEMA, suggested_values
-            ),
-            errors=errors,
-        )
+        return self.async_show_form(step_id="user", data_schema=get_manual_schema({}))
 
     async def async_step_zeroconf(
         self, discovery_info: ZeroconfServiceInfo
     ) -> ConfigFlowResult:
-        """Handle a zeroconf discovery for a Music Assistant server."""
+        """Handle a discovered Mass server.
+
+        This flow is triggered by the Zeroconf component. It will check if the
+        host is already configured and delegate to the import step if not.
+        """
+        # abort if discovery info is not what we expect
+        if "server_id" not in discovery_info.properties:
+            return self.async_abort(reason="missing_server_id")
+
+        self.server_info = ServerInfoMessage.from_dict(discovery_info.properties)
+        await self.async_set_unique_id(self.server_info.server_id)
+
+        # Check if we already have a config entry for this server_id
+        existing_entry = self.hass.config_entries.async_entry_for_domain_unique_id(
+            DOMAIN, self.server_info.server_id
+        )
+
+        if existing_entry:
+            # If the entry was ignored or disabled, don't make any changes
+            if existing_entry.source == SOURCE_IGNORE or existing_entry.disabled_by:
+                return self.async_abort(reason="already_configured")
+
+            # Test connectivity to the current URL first
+            current_url = existing_entry.data[CONF_URL]
+            try:
+                await get_server_info(self.hass, current_url)
+                # Current URL is working, no need to update
+                return self.async_abort(reason="already_configured")
+            except CannotConnect:
+                # Current URL is not working, update to the discovered URL
+                # and continue to discovery confirm
+                self.hass.config_entries.async_update_entry(
+                    existing_entry,
+                    data={**existing_entry.data, CONF_URL: self.server_info.base_url},
+                )
+                # Schedule reload since URL changed
+                self.hass.config_entries.async_schedule_reload(existing_entry.entry_id)
+        else:
+            # No existing entry, proceed with normal flow
+            self._abort_if_unique_id_configured()
+
+        # Test connectivity to the discovered URL
         try:
-            server_info = ServerInfoMessage.from_dict(discovery_info.properties)
-        except LookupError:
-            return self.async_abort(reason="invalid_discovery_info")
-
-        self.url = server_info.base_url
-
-        await self.async_set_unique_id(server_info.server_id)
-        self._abort_if_unique_id_configured(updates={CONF_URL: self.url})
-
-        try:
-            await _get_server_info(self.hass, self.url)
+            await get_server_info(self.hass, self.server_info.base_url)
         except CannotConnect:
             return self.async_abort(reason="cannot_connect")
-
         return await self.async_step_discovery_confirm()
 
     async def async_step_discovery_confirm(
@@ -114,16 +148,16 @@ class MusicAssistantConfigFlow(ConfigFlow, domain=DOMAIN):
     ) -> ConfigFlowResult:
         """Handle user-confirmation of discovered server."""
         if TYPE_CHECKING:
-            assert self.url is not None
-
+            assert self.server_info is not None
         if user_input is not None:
             return self.async_create_entry(
                 title=DEFAULT_TITLE,
-                data={CONF_URL: self.url},
+                data={
+                    CONF_URL: self.server_info.base_url,
+                },
             )
-
         self._set_confirm_only()
         return self.async_show_form(
             step_id="discovery_confirm",
-            description_placeholders={"url": self.url},
+            description_placeholders={"url": self.server_info.base_url},
         )

homeassistant/components/music_assistant/manifest.json

@@ -2,7 +2,7 @@
   "domain": "music_assistant",
   "name": "Music Assistant",
   "after_dependencies": ["media_source", "media_player"],
-  "codeowners": ["@music-assistant", "@arturpragacz"],
+  "codeowners": ["@music-assistant"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/music_assistant",
   "iot_class": "local_push",

homeassistant/components/myuplink/strings.json

@@ -57,7 +57,7 @@
       "message": "Error while loading the integration."
     },
     "implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
+      "message": "OAuth2 implementation is not available, will retry."
     },
     "incorrect_oauth2_scope": {
       "message": "Stored permissions are invalid. Please login again to update permissions."

homeassistant/components/netatmo/__init__.py

@@ -20,11 +20,10 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_WEBHOOK_ID, EVENT_HOMEASSISTANT_STOP
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
-from homeassistant.helpers import aiohttp_client, config_validation as cv
-from homeassistant.helpers.config_entry_oauth2_flow import (
-    ImplementationUnavailableError,
-    OAuth2Session,
-    async_get_config_entry_implementation,
+from homeassistant.helpers import (
+    aiohttp_client,
+    config_entry_oauth2_flow,
+    config_validation as cv,
 )
 from homeassistant.helpers.device_registry import DeviceEntry
 from homeassistant.helpers.dispatcher import async_dispatcher_send
@@ -74,19 +73,17 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up Netatmo from a config entry."""
-    try:
-        implementation = await async_get_config_entry_implementation(hass, entry)
-    except ImplementationUnavailableError as err:
-        raise ConfigEntryNotReady(
-            translation_domain=DOMAIN,
-            translation_key="oauth2_implementation_unavailable",
-        ) from err
+    implementation = (
+        await config_entry_oauth2_flow.async_get_config_entry_implementation(
+            hass, entry
+        )
+    )
 
     # Set unique id if non was set (migration)
     if not entry.unique_id:
         hass.config_entries.async_update_entry(entry, unique_id=DOMAIN)
 
-    session = OAuth2Session(hass, entry, implementation)
+    session = config_entry_oauth2_flow.OAuth2Session(hass, entry, implementation)
     try:
         await session.async_ensure_token_valid()
     except aiohttp.ClientResponseError as ex:

homeassistant/components/netatmo/strings.json

@@ -143,11 +143,6 @@
       }
     }
   },
-  "exceptions": {
-    "oauth2_implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
-    }
-  },
   "options": {
     "step": {
       "public_weather": {