Allow to set translation_domain for SelectSelector and create helpers for sensor/switch device_class and sensor state_class

* Fix template entity variables in blueprints

* add picture and icon tests

* add variable test for all platforms

* apply comments

* Update all test names

.github/workflows/builder.yml

@@ -94,7 +94,7 @@ jobs:
 
       - name: Download nightly wheels of frontend
         if: needs.init.outputs.channel == 'dev'
-        uses: dawidd6/action-download-artifact@v10
+        uses: dawidd6/action-download-artifact@v11
         with:
           github_token: ${{secrets.GITHUB_TOKEN}}
           repo: home-assistant/frontend
@@ -105,7 +105,7 @@ jobs:
 
       - name: Download nightly wheels of intents
         if: needs.init.outputs.channel == 'dev'
-        uses: dawidd6/action-download-artifact@v10
+        uses: dawidd6/action-download-artifact@v11
         with:
           github_token: ${{secrets.GITHUB_TOKEN}}
           repo: home-assistant/intents-package

CODEOWNERS

@@ -57,8 +57,6 @@ build.json @home-assistant/supervisor
 /tests/components/aemet/ @Noltari
 /homeassistant/components/agent_dvr/ @ispysoftware
 /tests/components/agent_dvr/ @ispysoftware
-/homeassistant/components/ai_task/ @home-assistant/core
-/tests/components/ai_task/ @home-assistant/core
 /homeassistant/components/air_quality/ @home-assistant/core
 /tests/components/air_quality/ @home-assistant/core
 /homeassistant/components/airgradient/ @airgradienthq @joostlek

homeassistant/components/ai_task/__init__.py

@@ -1,99 +0,0 @@
-"""Integration to offer AI tasks to Home Assistant."""
-
-import logging
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import config_validation as cv, storage
-from homeassistant.helpers.entity_component import EntityComponent
-from homeassistant.helpers.typing import UNDEFINED, ConfigType, UndefinedType
-
-from .const import DATA_COMPONENT, DATA_PREFERENCES, DOMAIN
-from .entity import AITaskEntity
-from .http import async_setup as async_setup_conversation_http
-from .task import GenTextTask, GenTextTaskResult, async_generate_text
-
-__all__ = [
-    "DOMAIN",
-    "AITaskEntity",
-    "GenTextTask",
-    "GenTextTaskResult",
-    "async_generate_text",
-    "async_setup",
-    "async_setup_entry",
-    "async_unload_entry",
-]
-
-_LOGGER = logging.getLogger(__name__)
-
-CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
-
-
-async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Register the process service."""
-    entity_component = EntityComponent[AITaskEntity](_LOGGER, DOMAIN, hass)
-    hass.data[DATA_COMPONENT] = entity_component
-    hass.data[DATA_PREFERENCES] = AITaskPreferences(hass)
-    await hass.data[DATA_PREFERENCES].async_load()
-    async_setup_conversation_http(hass)
-    return True
-
-
-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)
-
-
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
-    """Unload a config entry."""
-    return await hass.data[DATA_COMPONENT].async_unload_entry(entry)
-
-
-class AITaskPreferences:
-    """AI Task preferences."""
-
-    gen_text_entity_id: str | None = None
-
-    def __init__(self, hass: HomeAssistant) -> None:
-        """Initialize the preferences."""
-        self._store: storage.Store[dict[str, str | None]] = storage.Store(
-            hass, 1, DOMAIN
-        )
-
-    async def async_load(self) -> None:
-        """Load the data from the store."""
-        data = await self._store.async_load()
-        if data is None:
-            return
-        self.gen_text_entity_id = data.get("gen_text_entity_id")
-
-    @callback
-    def async_set_preferences(
-        self,
-        *,
-        gen_text_entity_id: str | None | UndefinedType = UNDEFINED,
-    ) -> None:
-        """Set the preferences."""
-        changed = False
-        for key, value in (("gen_text_entity_id", gen_text_entity_id),):
-            if value is not UNDEFINED:
-                if getattr(self, key) != value:
-                    setattr(self, key, value)
-                    changed = True
-
-        if not changed:
-            return
-
-        self._store.async_delay_save(
-            lambda: {
-                "gen_text_entity_id": self.gen_text_entity_id,
-            },
-            10,
-        )
-
-    @callback
-    def as_dict(self) -> dict[str, str | None]:
-        """Get the current preferences."""
-        return {
-            "gen_text_entity_id": self.gen_text_entity_id,
-        }

homeassistant/components/ai_task/const.py

@@ -1,21 +0,0 @@
-"""Constants for the AI Task integration."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from homeassistant.util.hass_dict import HassKey
-
-if TYPE_CHECKING:
-    from homeassistant.helpers.entity_component import EntityComponent
-
-    from . import AITaskPreferences
-    from .entity import AITaskEntity
-
-DOMAIN = "ai_task"
-DATA_COMPONENT: HassKey[EntityComponent[AITaskEntity]] = HassKey(DOMAIN)
-DATA_PREFERENCES: HassKey[AITaskPreferences] = HassKey(f"{DOMAIN}_preferences")
-
-DEFAULT_SYSTEM_PROMPT = (
-    "You are a Home Assistant expert and help users with their tasks."
-)

homeassistant/components/ai_task/entity.py

@@ -1,95 +0,0 @@
-"""Entity for the AI Task integration."""
-
-from collections.abc import AsyncGenerator
-import contextlib
-from typing import final
-
-from homeassistant.components.conversation import (
-    ChatLog,
-    UserContent,
-    async_get_chat_log,
-)
-from homeassistant.const import STATE_UNAVAILABLE, STATE_UNKNOWN
-from homeassistant.helpers import llm
-from homeassistant.helpers.chat_session import async_get_chat_session
-from homeassistant.helpers.restore_state import RestoreEntity
-from homeassistant.util import dt as dt_util
-
-from .const import DEFAULT_SYSTEM_PROMPT, DOMAIN
-from .task import GenTextTask, GenTextTaskResult
-
-
-class AITaskEntity(RestoreEntity):
-    """Entity that supports conversations."""
-
-    _attr_should_poll = False
-    __last_activity: str | None = None
-
-    @property
-    @final
-    def state(self) -> str | None:
-        """Return the state of the entity."""
-        if self.__last_activity is None:
-            return None
-        return self.__last_activity
-
-    async def async_internal_added_to_hass(self) -> None:
-        """Call when the entity is added to hass."""
-        await super().async_internal_added_to_hass()
-        state = await self.async_get_last_state()
-        if (
-            state is not None
-            and state.state is not None
-            and state.state not in (STATE_UNAVAILABLE, STATE_UNKNOWN)
-        ):
-            self.__last_activity = state.state
-
-    @final
-    @contextlib.asynccontextmanager
-    async def _async_get_ai_task_chat_log(
-        self,
-        task: GenTextTask,
-    ) -> AsyncGenerator[ChatLog]:
-        """Context manager used to manage the ChatLog used during an AI Task."""
-        # pylint: disable-next=contextmanager-generator-missing-cleanup
-        with (
-            async_get_chat_session(self.hass) as session,
-            async_get_chat_log(
-                self.hass,
-                session,
-                None,
-            ) as chat_log,
-        ):
-            await chat_log.async_provide_llm_data(
-                llm.LLMContext(
-                    platform=self.platform.domain,
-                    context=None,
-                    language=None,
-                    assistant=DOMAIN,
-                    device_id=None,
-                ),
-                user_llm_prompt=DEFAULT_SYSTEM_PROMPT,
-            )
-
-            chat_log.async_add_user_content(UserContent(task.instructions))
-
-            yield chat_log
-
-    @final
-    async def internal_async_generate_text(
-        self,
-        task: GenTextTask,
-    ) -> GenTextTaskResult:
-        """Run a gen text task."""
-        self.__last_activity = dt_util.utcnow().isoformat()
-        self.async_write_ha_state()
-        async with self._async_get_ai_task_chat_log(task) as chat_log:
-            return await self._async_generate_text(task, chat_log)
-
-    async def _async_generate_text(
-        self,
-        task: GenTextTask,
-        chat_log: ChatLog,
-    ) -> GenTextTaskResult:
-        """Handle a gen text task."""
-        raise NotImplementedError

homeassistant/components/ai_task/http.py

@@ -1,82 +0,0 @@
-"""HTTP endpoint for AI Task integration."""
-
-from typing import Any
-
-import voluptuous as vol
-
-from homeassistant.components import websocket_api
-from homeassistant.core import HomeAssistant, callback
-
-from .const import DATA_PREFERENCES
-from .task import async_generate_text
-
-
-@callback
-def async_setup(hass: HomeAssistant) -> None:
-    """Set up the HTTP API for the conversation integration."""
-    websocket_api.async_register_command(hass, websocket_generate_text)
-    websocket_api.async_register_command(hass, websocket_get_preferences)
-    websocket_api.async_register_command(hass, websocket_set_preferences)
-
-
-@websocket_api.websocket_command(
-    {
-        vol.Required("type"): "ai_task/generate_text",
-        vol.Required("task_name"): str,
-        vol.Optional("entity_id"): str,
-        vol.Required("instructions"): str,
-    }
-)
-@websocket_api.require_admin
-@websocket_api.async_response
-async def websocket_generate_text(
-    hass: HomeAssistant,
-    connection: websocket_api.ActiveConnection,
-    msg: dict[str, Any],
-) -> None:
-    """Run a generate text task."""
-    msg.pop("type")
-    msg_id = msg.pop("id")
-    try:
-        result = await async_generate_text(hass=hass, **msg)
-    except ValueError as err:
-        connection.send_error(msg_id, websocket_api.const.ERR_UNKNOWN_ERROR, str(err))
-        return
-    connection.send_result(msg_id, result.as_dict())
-
-
-@websocket_api.websocket_command(
-    {
-        vol.Required("type"): "ai_task/preferences/get",
-    }
-)
-@callback
-def websocket_get_preferences(
-    hass: HomeAssistant,
-    connection: websocket_api.ActiveConnection,
-    msg: dict[str, Any],
-) -> None:
-    """Get AI task preferences."""
-    preferences = hass.data[DATA_PREFERENCES]
-    connection.send_result(msg["id"], preferences.as_dict())
-
-
-@websocket_api.websocket_command(
-    {
-        vol.Required("type"): "ai_task/preferences/set",
-        vol.Optional("gen_text_entity_id"): vol.Any(str, None),
-    }
-)
-@websocket_api.require_admin
-@callback
-def websocket_set_preferences(
-    hass: HomeAssistant,
-    connection: websocket_api.ActiveConnection,
-    msg: dict[str, Any],
-) -> None:
-    """Set AI task preferences."""
-    preferences = hass.data[DATA_PREFERENCES]
-    msg.pop("type")
-    msg_id = msg.pop("id")
-    preferences.async_set_preferences(**msg)
-    connection.send_result(msg_id, preferences.as_dict())

homeassistant/components/ai_task/manifest.json

@@ -1,9 +0,0 @@
-{
-  "domain": "ai_task",
-  "name": "AI Task",
-  "codeowners": ["@home-assistant/core"],
-  "dependencies": ["conversation"],
-  "documentation": "https://www.home-assistant.io/integrations/ai_task",
-  "integration_type": "system",
-  "quality_scale": "internal"
-}

homeassistant/components/ai_task/task.py

@@ -1,68 +0,0 @@
-"""AI tasks to be handled by agents."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-from homeassistant.core import HomeAssistant
-
-from .const import DATA_COMPONENT, DATA_PREFERENCES
-
-
-async def async_generate_text(
-    hass: HomeAssistant,
-    *,
-    task_name: str,
-    entity_id: str | None = None,
-    instructions: str,
-) -> GenTextTaskResult:
-    """Run a task in the AI Task integration."""
-    if entity_id is None:
-        entity_id = hass.data[DATA_PREFERENCES].gen_text_entity_id
-
-    if entity_id is None:
-        raise ValueError("No entity_id provided and no preferred entity set")
-
-    entity = hass.data[DATA_COMPONENT].get_entity(entity_id)
-    if entity is None:
-        raise ValueError(f"AI Task entity {entity_id} not found")
-
-    return await entity.internal_async_generate_text(
-        GenTextTask(
-            name=task_name,
-            instructions=instructions,
-        )
-    )
-
-
-@dataclass(slots=True)
-class GenTextTask:
-    """Gen text task to be processed."""
-
-    name: str
-    """Name of the task."""
-
-    instructions: str
-    """Instructions on what needs to be done."""
-
-    def __str__(self) -> str:
-        """Return task as a string."""
-        return f"<GenTextTask {self.name}: {id(self)}>"
-
-
-@dataclass(slots=True)
-class GenTextTaskResult:
-    """Result of gen text task."""
-
-    conversation_id: str
-    """Unique identifier for the conversation."""
-
-    result: str
-    """Result of the task."""
-
-    def as_dict(self) -> dict[str, str]:
-        """Return result as a dict."""
-        return {
-            "conversation_id": self.conversation_id,
-            "result": self.result,
-        }

homeassistant/components/alexa_devices/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["aioamazondevices"],
   "quality_scale": "bronze",
-  "requirements": ["aioamazondevices==3.1.4"]
+  "requirements": ["aioamazondevices==3.1.12"]
 }

homeassistant/components/apcupsd/sensor.py

@@ -12,6 +12,7 @@ from homeassistant.components.sensor import (
 )
 from homeassistant.const import (
     PERCENTAGE,
+    EntityCategory,
     UnitOfApparentPower,
     UnitOfElectricCurrent,
     UnitOfElectricPotential,
@@ -35,6 +36,7 @@ SENSORS: dict[str, SensorEntityDescription] = {
     "alarmdel": SensorEntityDescription(
         key="alarmdel",
         translation_key="alarm_delay",
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "ambtemp": SensorEntityDescription(
         key="ambtemp",
@@ -47,15 +49,18 @@ SENSORS: dict[str, SensorEntityDescription] = {
         key="apc",
         translation_key="apc_status",
         entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "apcmodel": SensorEntityDescription(
         key="apcmodel",
         translation_key="apc_model",
         entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "badbatts": SensorEntityDescription(
         key="badbatts",
         translation_key="bad_batteries",
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "battdate": SensorEntityDescription(
         key="battdate",
@@ -82,6 +87,7 @@ SENSORS: dict[str, SensorEntityDescription] = {
         key="cable",
         translation_key="cable_type",
         entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "cumonbatt": SensorEntityDescription(
         key="cumonbatt",
@@ -94,52 +100,63 @@ SENSORS: dict[str, SensorEntityDescription] = {
         key="date",
         translation_key="date",
         entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "dipsw": SensorEntityDescription(
         key="dipsw",
         translation_key="dip_switch_settings",
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "dlowbatt": SensorEntityDescription(
         key="dlowbatt",
         translation_key="low_battery_signal",
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "driver": SensorEntityDescription(
         key="driver",
         translation_key="driver",
         entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "dshutd": SensorEntityDescription(
         key="dshutd",
         translation_key="shutdown_delay",
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "dwake": SensorEntityDescription(
         key="dwake",
         translation_key="wake_delay",
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "end apc": SensorEntityDescription(
         key="end apc",
         translation_key="date_and_time",
         entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "extbatts": SensorEntityDescription(
         key="extbatts",
         translation_key="external_batteries",
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "firmware": SensorEntityDescription(
         key="firmware",
         translation_key="firmware_version",
         entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "hitrans": SensorEntityDescription(
         key="hitrans",
         translation_key="transfer_high",
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "hostname": SensorEntityDescription(
         key="hostname",
         translation_key="hostname",
         entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "humidity": SensorEntityDescription(
         key="humidity",
@@ -163,10 +180,12 @@ SENSORS: dict[str, SensorEntityDescription] = {
         key="lastxfer",
         translation_key="last_transfer",
         entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "linefail": SensorEntityDescription(
         key="linefail",
         translation_key="line_failure",
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "linefreq": SensorEntityDescription(
         key="linefreq",
@@ -198,15 +217,18 @@ SENSORS: dict[str, SensorEntityDescription] = {
         translation_key="transfer_low",
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "mandate": SensorEntityDescription(
         key="mandate",
         translation_key="manufacture_date",
         entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "masterupd": SensorEntityDescription(
         key="masterupd",
         translation_key="master_update",
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "maxlinev": SensorEntityDescription(
         key="maxlinev",
@@ -217,11 +239,13 @@ SENSORS: dict[str, SensorEntityDescription] = {
     "maxtime": SensorEntityDescription(
         key="maxtime",
         translation_key="max_time",
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "mbattchg": SensorEntityDescription(
         key="mbattchg",
         translation_key="max_battery_charge",
         native_unit_of_measurement=PERCENTAGE,
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "minlinev": SensorEntityDescription(
         key="minlinev",
@@ -232,41 +256,48 @@ SENSORS: dict[str, SensorEntityDescription] = {
     "mintimel": SensorEntityDescription(
         key="mintimel",
         translation_key="min_time",
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "model": SensorEntityDescription(
         key="model",
         translation_key="model",
         entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "nombattv": SensorEntityDescription(
         key="nombattv",
         translation_key="battery_nominal_voltage",
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "nominv": SensorEntityDescription(
         key="nominv",
         translation_key="nominal_input_voltage",
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "nomoutv": SensorEntityDescription(
         key="nomoutv",
         translation_key="nominal_output_voltage",
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "nompower": SensorEntityDescription(
         key="nompower",
         translation_key="nominal_output_power",
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "nomapnt": SensorEntityDescription(
         key="nomapnt",
         translation_key="nominal_apparent_power",
         native_unit_of_measurement=UnitOfApparentPower.VOLT_AMPERE,
         device_class=SensorDeviceClass.APPARENT_POWER,
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "numxfers": SensorEntityDescription(
         key="numxfers",
@@ -291,21 +322,25 @@ SENSORS: dict[str, SensorEntityDescription] = {
         key="reg1",
         translation_key="register_1_fault",
         entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "reg2": SensorEntityDescription(
         key="reg2",
         translation_key="register_2_fault",
         entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "reg3": SensorEntityDescription(
         key="reg3",
         translation_key="register_3_fault",
         entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "retpct": SensorEntityDescription(
         key="retpct",
         translation_key="restore_capacity",
         native_unit_of_measurement=PERCENTAGE,
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "selftest": SensorEntityDescription(
         key="selftest",
@@ -315,20 +350,24 @@ SENSORS: dict[str, SensorEntityDescription] = {
         key="sense",
         translation_key="sensitivity",
         entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "serialno": SensorEntityDescription(
         key="serialno",
         translation_key="serial_number",
         entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "starttime": SensorEntityDescription(
         key="starttime",
         translation_key="startup_time",
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "statflag": SensorEntityDescription(
         key="statflag",
         translation_key="online_status",
         entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "status": SensorEntityDescription(
         key="status",
@@ -337,6 +376,7 @@ SENSORS: dict[str, SensorEntityDescription] = {
     "stesti": SensorEntityDescription(
         key="stesti",
         translation_key="self_test_interval",
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "timeleft": SensorEntityDescription(
         key="timeleft",
@@ -360,23 +400,28 @@ SENSORS: dict[str, SensorEntityDescription] = {
         key="upsname",
         translation_key="ups_name",
         entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "version": SensorEntityDescription(
         key="version",
         translation_key="version",
         entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "xoffbat": SensorEntityDescription(
         key="xoffbat",
         translation_key="transfer_from_battery",
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "xoffbatt": SensorEntityDescription(
         key="xoffbatt",
         translation_key="transfer_from_battery",
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "xonbatt": SensorEntityDescription(
         key="xonbatt",
         translation_key="transfer_to_battery",
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
 }
 

homeassistant/components/bthome/manifest.json

@@ -20,5 +20,5 @@
   "dependencies": ["bluetooth_adapters"],
   "documentation": "https://www.home-assistant.io/integrations/bthome",
   "iot_class": "local_push",
-  "requirements": ["bthome-ble==3.12.4"]
+  "requirements": ["bthome-ble==3.13.1"]
 }

homeassistant/components/climate/__init__.py

@@ -105,11 +105,6 @@ DEFAULT_MAX_HUMIDITY = 99
 
 CONVERTIBLE_ATTRIBUTE = [ATTR_TEMPERATURE, ATTR_TARGET_TEMP_LOW, ATTR_TARGET_TEMP_HIGH]
 
-# Can be removed in 2025.1 after deprecation period of the new feature flags
-CHECK_TURN_ON_OFF_FEATURE_FLAG = (
-    ClimateEntityFeature.TURN_ON | ClimateEntityFeature.TURN_OFF
-)
-
 SET_TEMPERATURE_SCHEMA = vol.All(
     cv.has_at_least_one_key(
         ATTR_TEMPERATURE, ATTR_TARGET_TEMP_HIGH, ATTR_TARGET_TEMP_LOW

homeassistant/components/cloud/manifest.json

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

homeassistant/components/cover/__init__.py

@@ -300,10 +300,6 @@ class CoverEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
     def supported_features(self) -> CoverEntityFeature:
         """Flag supported features."""
         if (features := self._attr_supported_features) is not None:
-            if type(features) is int:
-                new_features = CoverEntityFeature(features)
-                self._report_deprecated_supported_features_values(new_features)
-                return new_features
             return features
 
         supported_features = (

homeassistant/components/devolo_home_control/__init__.py

@@ -91,7 +91,9 @@ async def async_unload_entry(
 
 
 async def async_remove_config_entry_device(
-    hass: HomeAssistant, config_entry: ConfigEntry, device_entry: DeviceEntry
+    hass: HomeAssistant,
+    config_entry: DevoloHomeControlConfigEntry,
+    device_entry: DeviceEntry,
 ) -> bool:
     """Remove a config entry from a device."""
     return True

homeassistant/components/devolo_home_network/device_tracker.py

@@ -87,6 +87,7 @@ class DevoloScannerEntity(  # pylint: disable=hass-enforce-class-module
 ):
     """Representation of a devolo device tracker."""
 
+    _attr_has_entity_name = True
     _attr_translation_key = "device_tracker"
 
     def __init__(
@@ -99,6 +100,7 @@ class DevoloScannerEntity(  # pylint: disable=hass-enforce-class-module
         super().__init__(coordinator)
         self._device = device
         self._attr_mac_address = mac
+        self._attr_name = mac
 
     @property
     def extra_state_attributes(self) -> dict[str, str]:

homeassistant/components/discord/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "cloud_push",
   "loggers": ["discord"],
-  "requirements": ["nextcord==2.6.0"]
+  "requirements": ["nextcord==3.1.0"]
 }

homeassistant/components/edl21/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "local_push",
   "loggers": ["sml"],
-  "requirements": ["pysml==0.0.12"]
+  "requirements": ["pysml==0.1.5"]
 }

homeassistant/components/esphome/assist_satellite.py

@@ -332,7 +332,7 @@ class EsphomeAssistSatellite(
             }
         elif event_type == VoiceAssistantEventType.VOICE_ASSISTANT_RUN_START:
             assert event.data is not None
-            if tts_output := event.data["tts_output"]:
+            if tts_output := event.data.get("tts_output"):
                 path = tts_output["url"]
                 url = async_process_play_media_url(self.hass, path)
                 data_to_send = {"url": url}

homeassistant/components/goalzero/sensor.py

@@ -109,6 +109,7 @@ SENSOR_TYPES: tuple[SensorEntityDescription, ...] = (
     SensorEntityDescription(
         key="timestamp",
         translation_key="timestamp",
+        device_class=SensorDeviceClass.DURATION,
         native_unit_of_measurement=UnitOfTime.SECONDS,
         entity_registry_enabled_default=False,
         entity_category=EntityCategory.DIAGNOSTIC,

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==7.1.0", "oauth2client==4.1.3", "ical==10.0.0"]
+  "requirements": ["gcal-sync==7.1.0", "oauth2client==4.1.3", "ical==10.0.4"]
 }

homeassistant/components/here_travel_time/coordinator.py

@@ -133,8 +133,8 @@ class HERERoutingDataUpdateCoordinator(DataUpdateCoordinator[HERETravelTimeData]
     def _parse_routing_response(self, response: dict[str, Any]) -> HERETravelTimeData:
         """Parse the routing response dict to a HERETravelTimeData."""
         distance: float = 0.0
-        duration: float = 0.0
-        duration_in_traffic: float = 0.0
+        duration: int = 0
+        duration_in_traffic: int = 0
 
         for section in response["routes"][0]["sections"]:
             distance += DistanceConverter.convert(
@@ -167,8 +167,8 @@ class HERERoutingDataUpdateCoordinator(DataUpdateCoordinator[HERETravelTimeData]
             destination_name = names[0]["value"]
         return HERETravelTimeData(
             attribution=None,
-            duration=round(duration / 60),
-            duration_in_traffic=round(duration_in_traffic / 60),
+            duration=duration,
+            duration_in_traffic=duration_in_traffic,
             distance=distance,
             origin=f"{mapped_origin_lat},{mapped_origin_lon}",
             destination=f"{mapped_destination_lat},{mapped_destination_lon}",
@@ -271,13 +271,13 @@ class HERETransitDataUpdateCoordinator(
             UnitOfLength.METERS,
             UnitOfLength.KILOMETERS,
         )
-        duration: float = sum(
+        duration: int = sum(
             section["travelSummary"]["duration"] for section in sections
         )
         return HERETravelTimeData(
             attribution=attribution,
-            duration=round(duration / 60),
-            duration_in_traffic=round(duration / 60),
+            duration=duration,
+            duration_in_traffic=duration,
             distance=distance,
             origin=f"{mapped_origin_lat},{mapped_origin_lon}",
             destination=f"{mapped_destination_lat},{mapped_destination_lon}",

homeassistant/components/here_travel_time/sensor.py

@@ -55,14 +55,18 @@ def sensor_descriptions(travel_mode: str) -> tuple[SensorEntityDescription, ...]
             icon=ICONS.get(travel_mode, ICON_CAR),
             key=ATTR_DURATION,
             state_class=SensorStateClass.MEASUREMENT,
-            native_unit_of_measurement=UnitOfTime.MINUTES,
+            device_class=SensorDeviceClass.DURATION,
+            native_unit_of_measurement=UnitOfTime.SECONDS,
+            suggested_unit_of_measurement=UnitOfTime.MINUTES,
         ),
         SensorEntityDescription(
             translation_key="duration_in_traffic",
             icon=ICONS.get(travel_mode, ICON_CAR),
             key=ATTR_DURATION_IN_TRAFFIC,
             state_class=SensorStateClass.MEASUREMENT,
-            native_unit_of_measurement=UnitOfTime.MINUTES,
+            device_class=SensorDeviceClass.DURATION,
+            native_unit_of_measurement=UnitOfTime.SECONDS,
+            suggested_unit_of_measurement=UnitOfTime.MINUTES,
         ),
         SensorEntityDescription(
             translation_key="distance",

homeassistant/components/holiday/manifest.json

@@ -5,5 +5,5 @@
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/holiday",
   "iot_class": "local_polling",
-  "requirements": ["holidays==0.74", "babel==2.15.0"]
+  "requirements": ["holidays==0.75", "babel==2.15.0"]
 }

homeassistant/components/home_connect/manifest.json

@@ -21,6 +21,7 @@
   "documentation": "https://www.home-assistant.io/integrations/home_connect",
   "iot_class": "cloud_push",
   "loggers": ["aiohomeconnect"],
-  "requirements": ["aiohomeconnect==0.17.1"],
+  "quality_scale": "platinum",
+  "requirements": ["aiohomeconnect==0.18.0"],
   "zeroconf": ["_homeconnect._tcp.local."]
 }

homeassistant/components/home_connect/quality_scale.yaml

@@ -0,0 +1,71 @@
+rules:
+  # Bronze
+  action-setup: done
+  appropriate-polling:
+    status: done
+    comment: |
+      Full polling is performed at the configuration entry setup and
+      device polling is performed when a CONNECTED or a PAIRED event is received.
+      If many CONNECTED or PAIRED events are received for a device within a short time span,
+      the integration will stop polling for that device and will create a repair issue.
+  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: done
+  config-entry-unloading: done
+  docs-configuration-parameters: done
+  docs-installation-parameters: done
+  entity-unavailable: done
+  integration-owner: done
+  log-when-unavailable: done
+  parallel-updates: done
+  reauthentication-flow: done
+  test-coverage: done
+  # Gold
+  devices: done
+  diagnostics: done
+  discovery-update-info: done
+  discovery: done
+  docs-data-update: done
+  docs-examples: done
+  docs-known-limitations: done
+  docs-supported-devices: done
+  docs-supported-functions: done
+  docs-troubleshooting: done
+  docs-use-cases: done
+  dynamic-devices: done
+  entity-category: done
+  entity-device-class: done
+  entity-disabled-by-default:
+    status: done
+    comment: |
+      Event entities are disabled by default to prevent user confusion regarding
+      which events are supported by its appliance.
+  entity-translations: done
+  exception-translations: done
+  icon-translations: done
+  reconfiguration-flow:
+    status: exempt
+    comment: |
+      This integration doesn't have settings in its configuration flow.
+  repair-issues: done
+  stale-devices: done
+  # Platinum
+  async-dependency: done
+  inject-websession: done
+  strict-typing: done

homeassistant/components/homee/strings.json

@@ -177,9 +177,9 @@
         "state_attributes": {
           "event_type": {
             "state": {
-              "upper": "[%key;component::homee::entity::event::button_state::state_attributes::event_type::state::upper%]",
-              "lower": "[%key;component::homee::entity::event::button_state::state_attributes::event_type::state::lower%]",
-              "released": "[%key;component::homee::entity::event::button_state::state_attributes::event_type::state::released%]"
+              "upper": "[%key:component::homee::entity::event::button_state::state_attributes::event_type::state::upper%]",
+              "lower": "[%key:component::homee::entity::event::button_state::state_attributes::event_type::state::lower%]",
+              "released": "[%key:component::homee::entity::event::button_state::state_attributes::event_type::state::released%]"
             }
           }
         }
@@ -189,7 +189,7 @@
         "state_attributes": {
           "event_type": {
             "state": {
-              "release": "[%key;component::homee::entity::event::button_state::state_attributes::event_type::state::released%]",
+              "release": "[%key:component::homee::entity::event::button_state::state_attributes::event_type::state::released%]",
               "up": "Up",
               "down": "Down",
               "stop": "Stop",

homeassistant/components/homewizard/__init__.py

@@ -23,9 +23,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: HomeWizardConfigEntry) -
 
     api: HomeWizardEnergy
 
-    is_battery = entry.unique_id.startswith("HWE-BAT") if entry.unique_id else False
-
-    if (token := entry.data.get(CONF_TOKEN)) and is_battery:
+    if token := entry.data.get(CONF_TOKEN):
         api = HomeWizardEnergyV2(
             entry.data[CONF_IP_ADDRESS],
             token=token,
@@ -37,8 +35,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: HomeWizardConfigEntry) -
             clientsession=async_get_clientsession(hass),
         )
 
-        if is_battery:
-            await async_check_v2_support_and_create_issue(hass, entry)
+        await async_check_v2_support_and_create_issue(hass, entry)
 
     coordinator = HWEnergyDeviceUpdateCoordinator(hass, entry, api)
     try:

homeassistant/components/husqvarna_automower/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_push",
   "loggers": ["aioautomower"],
   "quality_scale": "silver",
-  "requirements": ["aioautomower==2025.5.1"]
+  "requirements": ["aioautomower==2025.6.0"]
 }

homeassistant/components/lamarzocco/manifest.json

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

homeassistant/components/lamarzocco/number.py

@@ -58,6 +58,10 @@ ENTITIES: tuple[LaMarzoccoNumberEntityDescription, ...] = (
                 CoffeeBoiler, machine.dashboard.config[WidgetType.CM_COFFEE_BOILER]
             ).target_temperature
         ),
+        available_fn=(
+            lambda coordinator: WidgetType.CM_COFFEE_BOILER
+            in coordinator.device.dashboard.config
+        ),
     ),
     LaMarzoccoNumberEntityDescription(
         key="smart_standby_time",
@@ -221,7 +225,7 @@ class LaMarzoccoNumberEntity(LaMarzoccoEntity, NumberEntity):
     entity_description: LaMarzoccoNumberEntityDescription
 
     @property
-    def native_value(self) -> float:
+    def native_value(self) -> float | int:
         """Return the current value."""
         return self.entity_description.native_value_fn(self.coordinator.device)
 

homeassistant/components/lamarzocco/sensor.py

@@ -57,6 +57,10 @@ ENTITIES: tuple[LaMarzoccoSensorEntityDescription, ...] = (
             ).ready_start_time
         ),
         entity_category=EntityCategory.DIAGNOSTIC,
+        available_fn=(
+            lambda coordinator: WidgetType.CM_COFFEE_BOILER
+            in coordinator.device.dashboard.config
+        ),
     ),
     LaMarzoccoSensorEntityDescription(
         key="steam_boiler_ready_time",

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==10.0.0"]
+  "requirements": ["ical==10.0.4"]
 }

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==10.0.0"]
+  "requirements": ["ical==10.0.4"]
 }

homeassistant/components/meater/__init__.py

@@ -1,93 +1,28 @@
 """The Meater Temperature Probe integration."""
 
-import asyncio
-from datetime import timedelta
-import logging
-
-from meater import (
-    AuthenticationError,
-    MeaterApi,
-    ServiceUnavailableError,
-    TooManyRequestsError,
-)
-from meater.MeaterApi import MeaterProbe
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_PASSWORD, CONF_USERNAME, Platform
+from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
 from .const import DOMAIN
+from .coordinator import MeaterConfigEntry, MeaterCoordinator
 
 PLATFORMS = [Platform.SENSOR]
 
-_LOGGER = logging.getLogger(__name__)
 
-
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_setup_entry(hass: HomeAssistant, entry: MeaterConfigEntry) -> bool:
     """Set up Meater Temperature Probe from a config entry."""
-    # Store an API object to access
-    session = async_get_clientsession(hass)
-    meater_api = MeaterApi(session)
 
-    # Add the credentials
-    try:
-        _LOGGER.debug("Authenticating with the Meater API")
-        await meater_api.authenticate(
-            entry.data[CONF_USERNAME], entry.data[CONF_PASSWORD]
-        )
-    except (ServiceUnavailableError, TooManyRequestsError) as err:
-        raise ConfigEntryNotReady from err
-    except AuthenticationError as err:
-        raise ConfigEntryAuthFailed(
-            f"Unable to authenticate with the Meater API: {err}"
-        ) from err
-
-    async def async_update_data() -> dict[str, MeaterProbe]:
-        """Fetch data from API endpoint."""
-        try:
-            # Note: TimeoutError and aiohttp.ClientError are already
-            # handled by the data update coordinator.
-            async with asyncio.timeout(10):
-                devices: list[MeaterProbe] = await meater_api.get_all_devices()
-        except AuthenticationError as err:
-            raise ConfigEntryAuthFailed("The API call wasn't authenticated") from err
-        except TooManyRequestsError as err:
-            raise UpdateFailed(
-                "Too many requests have been made to the API, rate limiting is in place"
-            ) from err
-
-        return {device.id: device for device in devices}
-
-    coordinator = DataUpdateCoordinator(
-        hass,
-        _LOGGER,
-        config_entry=entry,
-        # Name of the data. For logging purposes.
-        name="meater_api",
-        update_method=async_update_data,
-        # Polling interval. Will only be polled if there are subscribers.
-        update_interval=timedelta(seconds=30),
-    )
+    coordinator = MeaterCoordinator(hass, entry)
     await coordinator.async_config_entry_first_refresh()
 
-    hass.data.setdefault(DOMAIN, {})
-    hass.data[DOMAIN].setdefault("known_probes", set())
+    hass.data.setdefault(DOMAIN, {}).setdefault("known_probes", set())
 
-    hass.data[DOMAIN][entry.entry_id] = {
-        "api": meater_api,
-        "coordinator": coordinator,
-    }
+    entry.runtime_data = coordinator
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: MeaterConfigEntry) -> bool:
     """Unload a config entry."""
-    if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
-        hass.data[DOMAIN].pop(entry.entry_id)
-
-    return unload_ok
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/meater/coordinator.py

@@ -0,0 +1,77 @@
+"""Meater Coordinator."""
+
+import asyncio
+from datetime import timedelta
+import logging
+
+from meater.MeaterApi import (
+    AuthenticationError,
+    MeaterApi,
+    MeaterProbe,
+    ServiceUnavailableError,
+    TooManyRequestsError,
+)
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
+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
+
+_LOGGER = logging.getLogger(__name__)
+
+type MeaterConfigEntry = ConfigEntry[MeaterCoordinator]
+
+
+class MeaterCoordinator(DataUpdateCoordinator[dict[str, MeaterProbe]]):
+    """Meater Coordinator."""
+
+    config_entry: MeaterConfigEntry
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        entry: MeaterConfigEntry,
+    ) -> None:
+        """Initialize the Meater Coordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            config_entry=entry,
+            name=f"Meater {entry.title}",
+            update_interval=timedelta(seconds=30),
+        )
+        session = async_get_clientsession(hass)
+        self.client = MeaterApi(session)
+
+    async def _async_setup(self) -> None:
+        """Set up the Meater Coordinator."""
+        try:
+            _LOGGER.debug("Authenticating with the Meater API")
+            await self.client.authenticate(
+                self.config_entry.data[CONF_USERNAME],
+                self.config_entry.data[CONF_PASSWORD],
+            )
+        except (ServiceUnavailableError, TooManyRequestsError) as err:
+            raise UpdateFailed from err
+        except AuthenticationError as err:
+            raise ConfigEntryAuthFailed(
+                f"Unable to authenticate with the Meater API: {err}"
+            ) from err
+
+    async def _async_update_data(self) -> dict[str, MeaterProbe]:
+        """Fetch data from API endpoint."""
+        try:
+            # Note: TimeoutError and aiohttp.ClientError are already
+            # handled by the data update coordinator.
+            async with asyncio.timeout(10):
+                devices: list[MeaterProbe] = await self.client.get_all_devices()
+        except AuthenticationError as err:
+            raise ConfigEntryAuthFailed("The API call wasn't authenticated") from err
+        except TooManyRequestsError as err:
+            raise UpdateFailed(
+                "Too many requests have been made to the API, rate limiting is in place"
+            ) from err
+
+        return {device.id: device for device in devices}

homeassistant/components/meater/diagnostics.py

@@ -0,0 +1,55 @@
+"""Diagnostics support for the Meater integration."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from homeassistant.core import HomeAssistant
+
+from . import MeaterConfigEntry
+
+
+async def async_get_config_entry_diagnostics(
+    hass: HomeAssistant, config_entry: MeaterConfigEntry
+) -> dict[str, Any]:
+    """Return diagnostics for a config entry."""
+    coordinator = config_entry.runtime_data
+
+    return {
+        identifier: {
+            "id": probe.id,
+            "internal_temperature": probe.internal_temperature,
+            "ambient_temperature": probe.ambient_temperature,
+            "time_updated": probe.time_updated.isoformat(),
+            "cook": (
+                {
+                    "id": probe.cook.id,
+                    "name": probe.cook.name,
+                    "state": probe.cook.state,
+                    "target_temperature": (
+                        probe.cook.target_temperature
+                        if hasattr(probe.cook, "target_temperature")
+                        else None
+                    ),
+                    "peak_temperature": (
+                        probe.cook.peak_temperature
+                        if hasattr(probe.cook, "peak_temperature")
+                        else None
+                    ),
+                    "time_remaining": (
+                        probe.cook.time_remaining
+                        if hasattr(probe.cook, "time_remaining")
+                        else None
+                    ),
+                    "time_elapsed": (
+                        probe.cook.time_elapsed
+                        if hasattr(probe.cook, "time_elapsed")
+                        else None
+                    ),
+                }
+                if probe.cook
+                else None
+            ),
+        }
+        for identifier, probe in coordinator.data.items()
+    }

homeassistant/components/meater/sensor.py

@@ -14,18 +14,28 @@ from homeassistant.components.sensor import (
     SensorEntityDescription,
     SensorStateClass,
 )
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import UnitOfTemperature
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.update_coordinator import (
-    CoordinatorEntity,
-    DataUpdateCoordinator,
-)
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
 from homeassistant.util import dt as dt_util
 
+from . import MeaterCoordinator
 from .const import DOMAIN
+from .coordinator import MeaterConfigEntry
+
+COOK_STATES = {
+    "Not Started": "not_started",
+    "Configured": "configured",
+    "Started": "started",
+    "Ready For Resting": "ready_for_resting",
+    "Resting": "resting",
+    "Slightly Underdone": "slightly_underdone",
+    "Finished": "finished",
+    "Slightly Overdone": "slightly_overdone",
+    "OVERCOOK!": "overcooked",
+}
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -82,13 +92,13 @@ SENSOR_TYPES = (
         available=lambda probe: probe is not None and probe.cook is not None,
         value=lambda probe: probe.cook.name if probe.cook else None,
     ),
-    # One of Not Started, Configured, Started, Ready For Resting, Resting,
-    # Slightly Underdone, Finished, Slightly Overdone, OVERCOOK!. Not translated.
     MeaterSensorEntityDescription(
         key="cook_state",
         translation_key="cook_state",
         available=lambda probe: probe is not None and probe.cook is not None,
-        value=lambda probe: probe.cook.state if probe.cook else None,
+        device_class=SensorDeviceClass.ENUM,
+        options=list(COOK_STATES.values()),
+        value=lambda probe: COOK_STATES.get(probe.cook.state) if probe.cook else None,
     ),
     # Target temperature
     MeaterSensorEntityDescription(
@@ -137,13 +147,11 @@ SENSOR_TYPES = (
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: MeaterConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the entry."""
-    coordinator: DataUpdateCoordinator[dict[str, MeaterProbe]] = hass.data[DOMAIN][
-        entry.entry_id
-    ]["coordinator"]
+    coordinator = entry.runtime_data
 
     @callback
     def async_update_data():
@@ -174,11 +182,10 @@ async def async_setup_entry(
 
     # Add a subscriber to the coordinator to discover new temperature probes
     coordinator.async_add_listener(async_update_data)
+    async_update_data()
 
 
-class MeaterProbeTemperature(
-    SensorEntity, CoordinatorEntity[DataUpdateCoordinator[dict[str, MeaterProbe]]]
-):
+class MeaterProbeTemperature(SensorEntity, CoordinatorEntity[MeaterCoordinator]):
     """Meater Temperature Sensor Entity."""
 
     entity_description: MeaterSensorEntityDescription

homeassistant/components/meater/strings.json

@@ -40,7 +40,18 @@
         "name": "Cooking"
       },
       "cook_state": {
-        "name": "Cook state"
+        "name": "Cook state",
+        "state": {
+          "not_started": "Not started",
+          "configured": "Configured",
+          "started": "Started",
+          "ready_for_resting": "Ready for resting",
+          "resting": "Resting",
+          "slightly_underdone": "Slightly underdone",
+          "finished": "Finished",
+          "slightly_overdone": "Slightly overdone",
+          "overcooked": "Overcooked"
+        }
       },
       "cook_target_temp": {
         "name": "Target temperature"

homeassistant/components/media_player/__init__.py

@@ -814,19 +814,6 @@ class MediaPlayerEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
         """Flag media player features that are supported."""
         return self._attr_supported_features
 
-    @property
-    def supported_features_compat(self) -> MediaPlayerEntityFeature:
-        """Return the supported features as MediaPlayerEntityFeature.
-
-        Remove this compatibility shim in 2025.1 or later.
-        """
-        features = self.supported_features
-        if type(features) is int:
-            new_features = MediaPlayerEntityFeature(features)
-            self._report_deprecated_supported_features_values(new_features)
-            return new_features
-        return features
-
     def turn_on(self) -> None:
         """Turn the media player on."""
         raise NotImplementedError
@@ -966,87 +953,85 @@ class MediaPlayerEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
     @property
     def support_play(self) -> bool:
         """Boolean if play is supported."""
-        return MediaPlayerEntityFeature.PLAY in self.supported_features_compat
+        return MediaPlayerEntityFeature.PLAY in self.supported_features
 
     @final
     @property
     def support_pause(self) -> bool:
         """Boolean if pause is supported."""
-        return MediaPlayerEntityFeature.PAUSE in self.supported_features_compat
+        return MediaPlayerEntityFeature.PAUSE in self.supported_features
 
     @final
     @property
     def support_stop(self) -> bool:
         """Boolean if stop is supported."""
-        return MediaPlayerEntityFeature.STOP in self.supported_features_compat
+        return MediaPlayerEntityFeature.STOP in self.supported_features
 
     @final
     @property
     def support_seek(self) -> bool:
         """Boolean if seek is supported."""
-        return MediaPlayerEntityFeature.SEEK in self.supported_features_compat
+        return MediaPlayerEntityFeature.SEEK in self.supported_features
 
     @final
     @property
     def support_volume_set(self) -> bool:
         """Boolean if setting volume is supported."""
-        return MediaPlayerEntityFeature.VOLUME_SET in self.supported_features_compat
+        return MediaPlayerEntityFeature.VOLUME_SET in self.supported_features
 
     @final
     @property
     def support_volume_mute(self) -> bool:
         """Boolean if muting volume is supported."""
-        return MediaPlayerEntityFeature.VOLUME_MUTE in self.supported_features_compat
+        return MediaPlayerEntityFeature.VOLUME_MUTE in self.supported_features
 
     @final
     @property
     def support_previous_track(self) -> bool:
         """Boolean if previous track command supported."""
-        return MediaPlayerEntityFeature.PREVIOUS_TRACK in self.supported_features_compat
+        return MediaPlayerEntityFeature.PREVIOUS_TRACK in self.supported_features
 
     @final
     @property
     def support_next_track(self) -> bool:
         """Boolean if next track command supported."""
-        return MediaPlayerEntityFeature.NEXT_TRACK in self.supported_features_compat
+        return MediaPlayerEntityFeature.NEXT_TRACK in self.supported_features
 
     @final
     @property
     def support_play_media(self) -> bool:
         """Boolean if play media command supported."""
-        return MediaPlayerEntityFeature.PLAY_MEDIA in self.supported_features_compat
+        return MediaPlayerEntityFeature.PLAY_MEDIA in self.supported_features
 
     @final
     @property
     def support_select_source(self) -> bool:
         """Boolean if select source command supported."""
-        return MediaPlayerEntityFeature.SELECT_SOURCE in self.supported_features_compat
+        return MediaPlayerEntityFeature.SELECT_SOURCE in self.supported_features
 
     @final
     @property
     def support_select_sound_mode(self) -> bool:
         """Boolean if select sound mode command supported."""
-        return (
-            MediaPlayerEntityFeature.SELECT_SOUND_MODE in self.supported_features_compat
-        )
+        return MediaPlayerEntityFeature.SELECT_SOUND_MODE in self.supported_features
 
     @final
     @property
     def support_clear_playlist(self) -> bool:
         """Boolean if clear playlist command supported."""
-        return MediaPlayerEntityFeature.CLEAR_PLAYLIST in self.supported_features_compat
+        return MediaPlayerEntityFeature.CLEAR_PLAYLIST in self.supported_features
 
     @final
     @property
     def support_shuffle_set(self) -> bool:
         """Boolean if shuffle is supported."""
-        return MediaPlayerEntityFeature.SHUFFLE_SET in self.supported_features_compat
+        return MediaPlayerEntityFeature.SHUFFLE_SET in self.supported_features
 
     @final
     @property
     def support_grouping(self) -> bool:
         """Boolean if player grouping is supported."""
-        return MediaPlayerEntityFeature.GROUPING in self.supported_features_compat
+        return MediaPlayerEntityFeature.GROUPING in self.supported_features
 
     async def async_toggle(self) -> None:
         """Toggle the power on the media player."""
@@ -1074,7 +1059,7 @@ class MediaPlayerEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
         if (
             self.volume_level is not None
             and self.volume_level < 1
-            and MediaPlayerEntityFeature.VOLUME_SET in self.supported_features_compat
+            and MediaPlayerEntityFeature.VOLUME_SET in self.supported_features
         ):
             await self.async_set_volume_level(
                 min(1, self.volume_level + self.volume_step)
@@ -1092,7 +1077,7 @@ class MediaPlayerEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
         if (
             self.volume_level is not None
             and self.volume_level > 0
-            and MediaPlayerEntityFeature.VOLUME_SET in self.supported_features_compat
+            and MediaPlayerEntityFeature.VOLUME_SET in self.supported_features
         ):
             await self.async_set_volume_level(
                 max(0, self.volume_level - self.volume_step)
@@ -1135,7 +1120,7 @@ class MediaPlayerEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
     def capability_attributes(self) -> dict[str, Any]:
         """Return capability attributes."""
         data: dict[str, Any] = {}
-        supported_features = self.supported_features_compat
+        supported_features = self.supported_features
 
         if (
             source_list := self.source_list
@@ -1364,7 +1349,7 @@ async def websocket_browse_media(
         connection.send_error(msg["id"], "entity_not_found", "Entity not found")
         return
 
-    if MediaPlayerEntityFeature.BROWSE_MEDIA not in player.supported_features_compat:
+    if MediaPlayerEntityFeature.BROWSE_MEDIA not in player.supported_features:
         connection.send_message(
             websocket_api.error_message(
                 msg["id"], ERR_NOT_SUPPORTED, "Player does not support browsing media"
@@ -1447,7 +1432,7 @@ async def websocket_search_media(
         connection.send_error(msg["id"], "entity_not_found", "Entity not found")
         return
 
-    if MediaPlayerEntityFeature.SEARCH_MEDIA not in player.supported_features_compat:
+    if MediaPlayerEntityFeature.SEARCH_MEDIA not in player.supported_features:
         connection.send_message(
             websocket_api.error_message(
                 msg["id"], ERR_NOT_SUPPORTED, "Player does not support searching media"

homeassistant/components/minecraft_server/__init__.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import logging
 from typing import Any
 
+import dns.asyncresolver
 import dns.rdata
 import dns.rdataclass
 import dns.rdatatype
@@ -22,20 +23,23 @@ PLATFORMS = [Platform.BINARY_SENSOR, Platform.SENSOR]
 _LOGGER = logging.getLogger(__name__)
 
 
-def load_dnspython_rdata_classes() -> None:
-    """Load dnspython rdata classes used by mcstatus."""
+def prevent_dnspython_blocking_operations() -> None:
+    """Prevent dnspython blocking operations by pre-loading required data."""
+
+    # Blocking import: https://github.com/rthalley/dnspython/issues/1083
     for rdtype in dns.rdatatype.RdataType:
         if not dns.rdatatype.is_metatype(rdtype) or rdtype == dns.rdatatype.OPT:
             dns.rdata.get_rdata_class(dns.rdataclass.IN, rdtype)  # type: ignore[no-untyped-call]
 
+    # Blocking open: https://github.com/rthalley/dnspython/issues/1200
+    dns.asyncresolver.get_default_resolver()
+
 
 async def async_setup_entry(
     hass: HomeAssistant, entry: MinecraftServerConfigEntry
 ) -> bool:
     """Set up Minecraft Server from a config entry."""
-
-    # Workaround to avoid blocking imports from dnspython (https://github.com/rthalley/dnspython/issues/1083)
-    await hass.async_add_executor_job(load_dnspython_rdata_classes)
+    await hass.async_add_executor_job(prevent_dnspython_blocking_operations)
 
     # Create coordinator instance and store it.
     coordinator = MinecraftServerCoordinator(hass, entry)

homeassistant/components/mqtt/config_flow.py

@@ -41,7 +41,10 @@ from homeassistant.components.sensor import (
     DEVICE_CLASS_UNITS,
     STATE_CLASS_UNITS,
     SensorDeviceClass,
-    SensorStateClass,
+)
+from homeassistant.components.sensor.helpers import (
+    create_sensor_device_class_select_selector,
+    create_sensor_state_class_select_selector,
 )
 from homeassistant.components.switch import SwitchDeviceClass
 from homeassistant.config_entries import (
@@ -412,15 +415,6 @@ SUBENTRY_AVAILABILITY_SCHEMA = vol.Schema(
     }
 )
 
-# Sensor specific selectors
-SENSOR_DEVICE_CLASS_SELECTOR = SelectSelector(
-    SelectSelectorConfig(
-        options=[device_class.value for device_class in SensorDeviceClass],
-        mode=SelectSelectorMode.DROPDOWN,
-        translation_key="device_class_sensor",
-        sort=True,
-    )
-)
 BINARY_SENSOR_DEVICE_CLASS_SELECTOR = SelectSelector(
     SelectSelectorConfig(
         options=[device_class.value for device_class in BinarySensorDeviceClass],
@@ -445,19 +439,9 @@ COVER_DEVICE_CLASS_SELECTOR = SelectSelector(
         sort=True,
     )
 )
-SENSOR_STATE_CLASS_SELECTOR = SelectSelector(
-    SelectSelectorConfig(
-        options=[device_class.value for device_class in SensorStateClass],
-        mode=SelectSelectorMode.DROPDOWN,
-        translation_key=CONF_STATE_CLASS,
-    )
-)
+
 OPTIONS_SELECTOR = SelectSelector(
-    SelectSelectorConfig(
-        options=[],
-        custom_value=True,
-        multiple=True,
-    )
+    SelectSelectorConfig(options=[], custom_value=True, multiple=True)
 )
 SUGGESTED_DISPLAY_PRECISION_SELECTOR = NumberSelector(
     NumberSelectorConfig(mode=NumberSelectorMode.BOX, min=0, max=9)
@@ -783,10 +767,12 @@ PLATFORM_ENTITY_FIELDS: dict[str, dict[str, PlatformField]] = {
     Platform.NOTIFY.value: {},
     Platform.SENSOR.value: {
         CONF_DEVICE_CLASS: PlatformField(
-            selector=SENSOR_DEVICE_CLASS_SELECTOR, required=False
+            selector=create_sensor_device_class_select_selector(),
+            required=False,
         ),
         CONF_STATE_CLASS: PlatformField(
-            selector=SENSOR_STATE_CLASS_SELECTOR, required=False
+            selector=create_sensor_state_class_select_selector(),
+            required=False,
         ),
         CONF_UNIT_OF_MEASUREMENT: PlatformField(
             selector=unit_of_measurement_selector,

homeassistant/components/mqtt/sensor.py

@@ -35,7 +35,6 @@ from homeassistant.core import CALLBACK_TYPE, HomeAssistant, State, callback
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.event import async_call_later
-from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
 from homeassistant.helpers.service_info.mqtt import ReceivePayloadType
 from homeassistant.helpers.typing import ConfigType, VolSchemaType
 from homeassistant.util import dt as dt_util
@@ -48,7 +47,6 @@ from .const import (
     CONF_OPTIONS,
     CONF_STATE_TOPIC,
     CONF_SUGGESTED_DISPLAY_PRECISION,
-    DOMAIN,
     PAYLOAD_NONE,
 )
 from .entity import MqttAvailabilityMixin, MqttEntity, async_setup_entity_entry_helper
@@ -138,12 +136,9 @@ def validate_sensor_state_and_device_class_config(config: ConfigType) -> ConfigT
         device_class in DEVICE_CLASS_UNITS
         and unit_of_measurement not in DEVICE_CLASS_UNITS[device_class]
     ):
-        _LOGGER.warning(
-            "The unit of measurement `%s` is not valid "
-            "together with device class `%s`. "
-            "this will stop working in HA Core 2025.7.0",
-            unit_of_measurement,
-            device_class,
+        raise vol.Invalid(
+            f"The unit of measurement `{unit_of_measurement}` is not valid "
+            f"together with device class `{device_class}`",
         )
 
     return config
@@ -194,40 +189,8 @@ class MqttSensor(MqttEntity, RestoreSensor):
         None
     )
 
-    @callback
-    def async_check_uom(self) -> None:
-        """Check if the unit of measurement is valid with the device class."""
-        if (
-            self._discovery_data is not None
-            or self.device_class is None
-            or self.native_unit_of_measurement is None
-        ):
-            return
-        if (
-            self.device_class in DEVICE_CLASS_UNITS
-            and self.native_unit_of_measurement
-            not in DEVICE_CLASS_UNITS[self.device_class]
-        ):
-            async_create_issue(
-                self.hass,
-                DOMAIN,
-                self.entity_id,
-                issue_domain=sensor.DOMAIN,
-                is_fixable=False,
-                severity=IssueSeverity.WARNING,
-                learn_more_url=URL_DOCS_SUPPORTED_SENSOR_UOM,
-                translation_placeholders={
-                    "uom": self.native_unit_of_measurement,
-                    "device_class": self.device_class.value,
-                    "entity_id": self.entity_id,
-                },
-                translation_key="invalid_unit_of_measurement",
-                breaks_in_ha_version="2025.7.0",
-            )
-
     async def mqtt_async_added_to_hass(self) -> None:
         """Restore state for entities with expire_after set."""
-        self.async_check_uom()
         last_state: State | None
         last_sensor_data: SensorExtraStoredData | None
         if (

homeassistant/components/mqtt/strings.json

@@ -3,10 +3,6 @@
     "invalid_platform_config": {
       "title": "Invalid config found for MQTT {domain} item",
       "description": "Home Assistant detected an invalid config for a manually configured item.\n\nPlatform domain: **{domain}**\nConfiguration file: **{config_file}**\nNear line: **{line}**\nConfiguration found:\n```yaml\n{config}\n```\nError: **{error}**.\n\nMake sure the configuration is valid and [reload](/developer-tools/yaml) the manually configured MQTT items or restart Home Assistant to fix this issue."
-    },
-    "invalid_unit_of_measurement": {
-      "title": "Sensor with invalid unit of measurement",
-      "description": "Manual configured Sensor entity **{entity_id}** has a configured unit of measurement **{uom}** which is not valid with configured device class **{device_class}**. Make sure a valid unit of measurement is configured or remove the device class, and [reload](/developer-tools/yaml) the manually configured MQTT items or restart Home Assistant to fix this issue."
     }
   },
   "config": {
@@ -821,66 +817,6 @@
         "window": "[%key:component::cover::entity_component::window::name%]"
       }
     },
-    "device_class_sensor": {
-      "options": {
-        "apparent_power": "[%key:component::sensor::entity_component::apparent_power::name%]",
-        "area": "[%key:component::sensor::entity_component::area::name%]",
-        "aqi": "[%key:component::sensor::entity_component::aqi::name%]",
-        "atmospheric_pressure": "[%key:component::sensor::entity_component::atmospheric_pressure::name%]",
-        "battery": "[%key:component::sensor::entity_component::battery::name%]",
-        "blood_glucose_concentration": "[%key:component::sensor::entity_component::blood_glucose_concentration::name%]",
-        "carbon_dioxide": "[%key:component::sensor::entity_component::carbon_dioxide::name%]",
-        "carbon_monoxide": "[%key:component::sensor::entity_component::carbon_monoxide::name%]",
-        "conductivity": "[%key:component::sensor::entity_component::conductivity::name%]",
-        "current": "[%key:component::sensor::entity_component::current::name%]",
-        "data_rate": "[%key:component::sensor::entity_component::data_rate::name%]",
-        "data_size": "[%key:component::sensor::entity_component::data_size::name%]",
-        "date": "[%key:component::sensor::entity_component::date::name%]",
-        "distance": "[%key:component::sensor::entity_component::distance::name%]",
-        "duration": "[%key:component::sensor::entity_component::duration::name%]",
-        "energy": "[%key:component::sensor::entity_component::energy::name%]",
-        "energy_distance": "[%key:component::sensor::entity_component::energy_distance::name%]",
-        "energy_storage": "[%key:component::sensor::entity_component::energy_storage::name%]",
-        "enum": "Enumeration",
-        "frequency": "[%key:component::sensor::entity_component::frequency::name%]",
-        "gas": "[%key:component::sensor::entity_component::gas::name%]",
-        "humidity": "[%key:component::sensor::entity_component::humidity::name%]",
-        "illuminance": "[%key:component::sensor::entity_component::illuminance::name%]",
-        "irradiance": "[%key:component::sensor::entity_component::irradiance::name%]",
-        "moisture": "[%key:component::sensor::entity_component::moisture::name%]",
-        "monetary": "[%key:component::sensor::entity_component::monetary::name%]",
-        "nitrogen_dioxide": "[%key:component::sensor::entity_component::nitrogen_dioxide::name%]",
-        "nitrogen_monoxide": "[%key:component::sensor::entity_component::nitrogen_monoxide::name%]",
-        "nitrous_oxide": "[%key:component::sensor::entity_component::nitrous_oxide::name%]",
-        "ozone": "[%key:component::sensor::entity_component::ozone::name%]",
-        "ph": "[%key:component::sensor::entity_component::ph::name%]",
-        "pm1": "[%key:component::sensor::entity_component::pm1::name%]",
-        "pm10": "[%key:component::sensor::entity_component::pm10::name%]",
-        "pm25": "[%key:component::sensor::entity_component::pm25::name%]",
-        "power": "[%key:component::sensor::entity_component::power::name%]",
-        "power_factor": "[%key:component::sensor::entity_component::power_factor::name%]",
-        "precipitation": "[%key:component::sensor::entity_component::precipitation::name%]",
-        "precipitation_intensity": "[%key:component::sensor::entity_component::precipitation_intensity::name%]",
-        "pressure": "[%key:component::sensor::entity_component::pressure::name%]",
-        "reactive_power": "[%key:component::sensor::entity_component::reactive_power::name%]",
-        "signal_strength": "[%key:component::sensor::entity_component::signal_strength::name%]",
-        "sound_pressure": "[%key:component::sensor::entity_component::sound_pressure::name%]",
-        "speed": "[%key:component::sensor::entity_component::speed::name%]",
-        "sulphur_dioxide": "[%key:component::sensor::entity_component::sulphur_dioxide::name%]",
-        "temperature": "[%key:component::sensor::entity_component::temperature::name%]",
-        "timestamp": "[%key:component::sensor::entity_component::timestamp::name%]",
-        "volatile_organic_compounds": "[%key:component::sensor::entity_component::volatile_organic_compounds::name%]",
-        "volatile_organic_compounds_parts": "[%key:component::sensor::entity_component::volatile_organic_compounds_parts::name%]",
-        "voltage": "[%key:component::sensor::entity_component::voltage::name%]",
-        "volume": "[%key:component::sensor::entity_component::volume::name%]",
-        "volume_flow_rate": "[%key:component::sensor::entity_component::volume_flow_rate::name%]",
-        "volume_storage": "[%key:component::sensor::entity_component::volume_storage::name%]",
-        "water": "[%key:component::sensor::entity_component::water::name%]",
-        "weight": "[%key:component::sensor::entity_component::weight::name%]",
-        "wind_direction": "[%key:component::sensor::entity_component::wind_direction::name%]",
-        "wind_speed": "[%key:component::sensor::entity_component::wind_speed::name%]"
-      }
-    },
     "device_class_switch": {
       "options": {
         "outlet": "[%key:component::switch::entity_component::outlet::name%]",
@@ -920,14 +856,6 @@
         "custom": "Custom"
       }
     },
-    "state_class": {
-      "options": {
-        "measurement": "[%key:component::sensor::entity_component::_::state_attributes::state_class::state::measurement%]",
-        "measurement_angle": "[%key:component::sensor::entity_component::_::state_attributes::state_class::state::measurement_angle%]",
-        "total": "[%key:component::sensor::entity_component::_::state_attributes::state_class::state::total%]",
-        "total_increasing": "[%key:component::sensor::entity_component::_::state_attributes::state_class::state::total_increasing%]"
-      }
-    },
     "supported_color_modes": {
       "options": {
         "onoff": "[%key:component::light::entity_component::_::state_attributes::color_mode::state::onoff%]",

homeassistant/components/mysensors/manifest.json

@@ -7,5 +7,5 @@
   "documentation": "https://www.home-assistant.io/integrations/mysensors",
   "iot_class": "local_push",
   "loggers": ["mysensors"],
-  "requirements": ["pymysensors==0.24.0"]
+  "requirements": ["pymysensors==0.25.0"]
 }

homeassistant/components/ness_alarm/manifest.json

@@ -6,5 +6,5 @@
   "iot_class": "local_push",
   "loggers": ["nessclient"],
   "quality_scale": "legacy",
-  "requirements": ["nessclient==1.1.2"]
+  "requirements": ["nessclient==1.2.0"]
 }

homeassistant/components/nextdns/binary_sensor.py

@@ -13,14 +13,13 @@ from homeassistant.components.binary_sensor import (
     BinarySensorEntityDescription,
 )
 from homeassistant.const import EntityCategory
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from . import NextDnsConfigEntry
-from .coordinator import NextDnsUpdateCoordinator
+from .entity import NextDnsEntity
 
-PARALLEL_UPDATES = 1
+PARALLEL_UPDATES = 0
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -61,30 +60,14 @@ async def async_setup_entry(
     )
 
 
-class NextDnsBinarySensor(
-    CoordinatorEntity[NextDnsUpdateCoordinator[ConnectionStatus]], BinarySensorEntity
-):
+class NextDnsBinarySensor(NextDnsEntity, BinarySensorEntity):
     """Define an NextDNS binary sensor."""
 
-    _attr_has_entity_name = True
     entity_description: NextDnsBinarySensorEntityDescription
 
-    def __init__(
-        self,
-        coordinator: NextDnsUpdateCoordinator[ConnectionStatus],
-        description: NextDnsBinarySensorEntityDescription,
-    ) -> None:
-        """Initialize."""
-        super().__init__(coordinator)
-        self._attr_device_info = coordinator.device_info
-        self._attr_unique_id = f"{coordinator.profile_id}_{description.key}"
-        self._attr_is_on = description.state(coordinator.data, coordinator.profile_id)
-        self.entity_description = description
-
-    @callback
-    def _handle_coordinator_update(self) -> None:
-        """Handle updated data from the coordinator."""
-        self._attr_is_on = self.entity_description.state(
+    @property
+    def is_on(self) -> bool:
+        """Return True if the binary sensor is on."""
+        return self.entity_description.state(
             self.coordinator.data, self.coordinator.profile_id
         )
-        self.async_write_ha_state()

homeassistant/components/nextdns/button.py

@@ -4,21 +4,21 @@ from __future__ import annotations
 
 from aiohttp import ClientError
 from aiohttp.client_exceptions import ClientConnectorError
-from nextdns import AnalyticsStatus, ApiError, InvalidApiKeyError
+from nextdns import ApiError, InvalidApiKeyError
 
 from homeassistant.components.button import ButtonEntity, ButtonEntityDescription
 from homeassistant.const import EntityCategory
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from . import NextDnsConfigEntry
 from .const import DOMAIN
-from .coordinator import NextDnsUpdateCoordinator
+from .entity import NextDnsEntity
 
 PARALLEL_UPDATES = 1
 
+
 CLEAR_LOGS_BUTTON = ButtonEntityDescription(
     key="clear_logs",
     translation_key="clear_logs",
@@ -37,24 +37,9 @@ async def async_setup_entry(
     async_add_entities([NextDnsButton(coordinator, CLEAR_LOGS_BUTTON)])
 
 
-class NextDnsButton(
-    CoordinatorEntity[NextDnsUpdateCoordinator[AnalyticsStatus]], ButtonEntity
-):
+class NextDnsButton(NextDnsEntity, ButtonEntity):
     """Define an NextDNS button."""
 
-    _attr_has_entity_name = True
-
-    def __init__(
-        self,
-        coordinator: NextDnsUpdateCoordinator[AnalyticsStatus],
-        description: ButtonEntityDescription,
-    ) -> None:
-        """Initialize."""
-        super().__init__(coordinator)
-        self._attr_device_info = coordinator.device_info
-        self._attr_unique_id = f"{coordinator.profile_id}_{description.key}"
-        self.entity_description = description
-
     async def async_press(self) -> None:
         """Trigger cleaning logs."""
         try:

homeassistant/components/nextdns/coordinator.py

@@ -24,7 +24,6 @@ from tenacity import RetryError
 
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed
-from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
 if TYPE_CHECKING:
@@ -53,14 +52,6 @@ class NextDnsUpdateCoordinator(DataUpdateCoordinator[CoordinatorDataT]):
         """Initialize."""
         self.nextdns = nextdns
         self.profile_id = profile_id
-        self.profile_name = nextdns.get_profile_name(profile_id)
-        self.device_info = DeviceInfo(
-            configuration_url=f"https://my.nextdns.io/{profile_id}/setup",
-            entry_type=DeviceEntryType.SERVICE,
-            identifiers={(DOMAIN, str(profile_id))},
-            manufacturer="NextDNS Inc.",
-            name=self.profile_name,
-        )
 
         super().__init__(
             hass,

homeassistant/components/nextdns/entity.py

@@ -0,0 +1,31 @@
+"""Define NextDNS entities."""
+
+from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
+from homeassistant.helpers.entity import EntityDescription
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN
+from .coordinator import CoordinatorDataT, NextDnsUpdateCoordinator
+
+
+class NextDnsEntity(CoordinatorEntity[NextDnsUpdateCoordinator[CoordinatorDataT]]):
+    """Define NextDNS entity."""
+
+    _attr_has_entity_name = True
+
+    def __init__(
+        self,
+        coordinator: NextDnsUpdateCoordinator[CoordinatorDataT],
+        description: EntityDescription,
+    ) -> None:
+        """Initialize."""
+        super().__init__(coordinator)
+        self._attr_device_info = DeviceInfo(
+            configuration_url=f"https://my.nextdns.io/{coordinator.profile_id}/setup",
+            entry_type=DeviceEntryType.SERVICE,
+            identifiers={(DOMAIN, str(coordinator.profile_id))},
+            manufacturer="NextDNS Inc.",
+            name=coordinator.nextdns.get_profile_name(coordinator.profile_id),
+        )
+        self._attr_unique_id = f"{coordinator.profile_id}_{description.key}"
+        self.entity_description = description

homeassistant/components/nextdns/sensor.py

@@ -20,10 +20,9 @@ from homeassistant.components.sensor import (
     SensorStateClass,
 )
 from homeassistant.const import PERCENTAGE, EntityCategory
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from . import NextDnsConfigEntry
 from .const import (
@@ -33,9 +32,10 @@ from .const import (
     ATTR_PROTOCOLS,
     ATTR_STATUS,
 )
-from .coordinator import CoordinatorDataT, NextDnsUpdateCoordinator
+from .coordinator import CoordinatorDataT
+from .entity import NextDnsEntity
 
-PARALLEL_UPDATES = 1
+PARALLEL_UPDATES = 0
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -297,27 +297,12 @@ async def async_setup_entry(
     )
 
 
-class NextDnsSensor(
-    CoordinatorEntity[NextDnsUpdateCoordinator[CoordinatorDataT]], SensorEntity
-):
+class NextDnsSensor(NextDnsEntity, SensorEntity):
     """Define an NextDNS sensor."""
 
-    _attr_has_entity_name = True
+    entity_description: NextDnsSensorEntityDescription
 
-    def __init__(
-        self,
-        coordinator: NextDnsUpdateCoordinator[CoordinatorDataT],
-        description: NextDnsSensorEntityDescription,
-    ) -> None:
-        """Initialize."""
-        super().__init__(coordinator)
-        self._attr_device_info = coordinator.device_info
-        self._attr_unique_id = f"{coordinator.profile_id}_{description.key}"
-        self._attr_native_value = description.value(coordinator.data)
-        self.entity_description: NextDnsSensorEntityDescription = description
-
-    @callback
-    def _handle_coordinator_update(self) -> None:
-        """Handle updated data from the coordinator."""
-        self._attr_native_value = self.entity_description.value(self.coordinator.data)
-        self.async_write_ha_state()
+    @property
+    def native_value(self) -> StateType:
+        """Return the state of the sensor."""
+        return self.entity_description.value(self.coordinator.data)

homeassistant/components/nextdns/strings.json

@@ -4,16 +4,25 @@
       "user": {
         "data": {
           "api_key": "[%key:common::config_flow::data::api_key%]"
+        },
+        "data_description": {
+          "api_key": "The API key for your NextDNS account"
         }
       },
       "profiles": {
         "data": {
-          "profile": "Profile"
+          "profile_name": "Profile"
+        },
+        "data_description": {
+          "profile_name": "The NextDNS configuration profile you want to integrate"
         }
       },
       "reauth_confirm": {
         "data": {
           "api_key": "[%key:common::config_flow::data::api_key%]"
+        },
+        "data_description": {
+          "api_key": "[%key:component::nextdns::config::step::user::data_description::api_key%]"
         }
       }
     },

homeassistant/components/nextdns/switch.py

@@ -15,11 +15,11 @@ from homeassistant.const import EntityCategory
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from . import NextDnsConfigEntry
 from .const import DOMAIN
 from .coordinator import NextDnsUpdateCoordinator
+from .entity import NextDnsEntity
 
 PARALLEL_UPDATES = 1
 
@@ -536,12 +536,9 @@ async def async_setup_entry(
     )
 
 
-class NextDnsSwitch(
-    CoordinatorEntity[NextDnsUpdateCoordinator[Settings]], SwitchEntity
-):
+class NextDnsSwitch(NextDnsEntity, SwitchEntity):
     """Define an NextDNS switch."""
 
-    _attr_has_entity_name = True
     entity_description: NextDnsSwitchEntityDescription
 
     def __init__(
@@ -550,11 +547,8 @@ class NextDnsSwitch(
         description: NextDnsSwitchEntityDescription,
     ) -> None:
         """Initialize."""
-        super().__init__(coordinator)
-        self._attr_device_info = coordinator.device_info
-        self._attr_unique_id = f"{coordinator.profile_id}_{description.key}"
+        super().__init__(coordinator, description)
         self._attr_is_on = description.state(coordinator.data)
-        self.entity_description = description
 
     @callback
     def _handle_coordinator_update(self) -> None:

homeassistant/components/onedrive/coordinator.py

@@ -66,6 +66,7 @@ class OneDriveUpdateCoordinator(DataUpdateCoordinator[Drive]):
                 translation_domain=DOMAIN, translation_key="authentication_failed"
             ) from err
         except OneDriveException as err:
+            _LOGGER.debug("Failed to fetch drive data: %s", err, exc_info=True)
             raise UpdateFailed(
                 translation_domain=DOMAIN, translation_key="update_failed"
             ) from err

homeassistant/components/osoenergy/manifest.json

@@ -5,5 +5,5 @@
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/osoenergy",
   "iot_class": "cloud_polling",
-  "requirements": ["pyosoenergyapi==1.1.4"]
+  "requirements": ["pyosoenergyapi==1.1.5"]
 }

homeassistant/components/paperless_ngx/__init__.py

@@ -9,7 +9,7 @@ from pypaperless.exceptions import (
     PaperlessInvalidTokenError,
 )
 
-from homeassistant.const import CONF_API_KEY, CONF_URL, Platform
+from homeassistant.const import CONF_API_KEY, CONF_URL, CONF_VERIFY_SSL, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import (
     ConfigEntryAuthFailed,
@@ -69,7 +69,7 @@ async def _get_paperless_api(
     api = Paperless(
         entry.data[CONF_URL],
         entry.data[CONF_API_KEY],
-        session=async_get_clientsession(hass),
+        session=async_get_clientsession(hass, entry.data.get(CONF_VERIFY_SSL, True)),
     )
 
     try:

homeassistant/components/paperless_ngx/config_flow.py

@@ -16,7 +16,7 @@ from pypaperless.exceptions import (
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_API_KEY, CONF_URL
+from homeassistant.const import CONF_API_KEY, CONF_URL, CONF_VERIFY_SSL
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
 from .const import DOMAIN, LOGGER
@@ -25,6 +25,7 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
     {
         vol.Required(CONF_URL): str,
         vol.Required(CONF_API_KEY): str,
+        vol.Required(CONF_VERIFY_SSL, default=True): bool,
     }
 )
 
@@ -78,15 +79,19 @@ class PaperlessConfigFlow(ConfigFlow, domain=DOMAIN):
             if not errors:
                 return self.async_update_reload_and_abort(entry, data=user_input)
 
+        if user_input is not None:
+            suggested_values = user_input
+        else:
+            suggested_values = {
+                CONF_URL: entry.data[CONF_URL],
+                CONF_VERIFY_SSL: entry.data.get(CONF_VERIFY_SSL, True),
+            }
+
         return self.async_show_form(
             step_id="reconfigure",
             data_schema=self.add_suggested_values_to_schema(
                 data_schema=STEP_USER_DATA_SCHEMA,
-                suggested_values={
-                    CONF_URL: user_input[CONF_URL]
-                    if user_input is not None
-                    else entry.data[CONF_URL],
-                },
+                suggested_values=suggested_values,
             ),
             errors=errors,
         )
@@ -122,13 +127,15 @@ class PaperlessConfigFlow(ConfigFlow, domain=DOMAIN):
             errors=errors,
         )
 
-    async def _validate_input(self, user_input: dict[str, str]) -> dict[str, str]:
+    async def _validate_input(self, user_input: dict[str, Any]) -> dict[str, str]:
         errors: dict[str, str] = {}
 
         client = Paperless(
             user_input[CONF_URL],
             user_input[CONF_API_KEY],
-            session=async_get_clientsession(self.hass),
+            session=async_get_clientsession(
+                self.hass, user_input.get(CONF_VERIFY_SSL, True)
+            ),
         )
 
         try:

homeassistant/components/paperless_ngx/strings.json

@@ -4,11 +4,13 @@
       "user": {
         "data": {
           "url": "[%key:common::config_flow::data::url%]",
-          "api_key": "[%key:common::config_flow::data::api_key%]"
+          "api_key": "[%key:common::config_flow::data::api_key%]",
+          "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
         },
         "data_description": {
           "url": "URL to connect to the Paperless-ngx instance",
-          "api_key": "API key to connect to the Paperless-ngx API"
+          "api_key": "API key to connect to the Paperless-ngx API",
+          "verify_ssl": "Verify the SSL certificate of the Paperless-ngx instance. Disable this option if you’re using a self-signed certificate."
         },
         "title": "Add Paperless-ngx instance"
       },
@@ -24,11 +26,13 @@
       "reconfigure": {
         "data": {
           "url": "[%key:common::config_flow::data::url%]",
-          "api_key": "[%key:common::config_flow::data::api_key%]"
+          "api_key": "[%key:common::config_flow::data::api_key%]",
+          "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
         },
         "data_description": {
           "url": "[%key:component::paperless_ngx::config::step::user::data_description::url%]",
-          "api_key": "[%key:component::paperless_ngx::config::step::user::data_description::api_key%]"
+          "api_key": "[%key:component::paperless_ngx::config::step::user::data_description::api_key%]",
+          "verify_ssl": "[%key:component::paperless_ngx::config::step::user::data_description::verify_ssl%]"
         },
         "title": "Reconfigure Paperless-ngx instance"
       }

homeassistant/components/remote_calendar/manifest.json

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

homeassistant/components/reolink/entity.py

@@ -75,7 +75,10 @@ class ReolinkHostCoordinatorEntity(CoordinatorEntity[DataUpdateCoordinator[None]
         )
 
         http_s = "https" if self._host.api.use_https else "http"
-        self._conf_url = f"{http_s}://{self._host.api.host}:{self._host.api.port}"
+        if self._host.api.baichuan_only:
+            self._conf_url = None
+        else:
+            self._conf_url = f"{http_s}://{self._host.api.host}:{self._host.api.port}"
         self._dev_id = self._host.unique_id
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, self._dev_id)},
@@ -184,6 +187,11 @@ class ReolinkChannelCoordinatorEntity(ReolinkHostCoordinatorEntity):
             if mac := self._host.api.baichuan.mac_address(dev_ch):
                 connections.add((CONNECTION_NETWORK_MAC, mac))
 
+            if self._conf_url is None:
+                conf_url = None
+            else:
+                conf_url = f"{self._conf_url}/?ch={dev_ch}"
+
             self._attr_device_info = DeviceInfo(
                 identifiers={(DOMAIN, self._dev_id)},
                 connections=connections,
@@ -195,7 +203,7 @@ class ReolinkChannelCoordinatorEntity(ReolinkHostCoordinatorEntity):
                 hw_version=self._host.api.camera_hardware_version(dev_ch),
                 sw_version=self._host.api.camera_sw_version(dev_ch),
                 serial_number=self._host.api.camera_uid(dev_ch),
-                configuration_url=f"{self._conf_url}/?ch={dev_ch}",
+                configuration_url=conf_url,
             )
 
     @property

homeassistant/components/reolink/icons.json

@@ -491,6 +491,12 @@
         "state": {
           "on": "mdi:eye-off"
         }
+      },
+      "privacy_mask": {
+        "default": "mdi:eye",
+        "state": {
+          "on": "mdi:eye-off"
+        }
       }
     }
   },

homeassistant/components/reolink/strings.json

@@ -960,6 +960,9 @@
       },
       "privacy_mode": {
         "name": "Privacy mode"
+      },
+      "privacy_mask": {
+        "name": "Privacy mask"
       }
     }
   }

homeassistant/components/reolink/switch.py

@@ -216,6 +216,15 @@ SWITCH_ENTITIES = (
         value=lambda api, ch: api.baichuan.privacy_mode(ch),
         method=lambda api, ch, value: api.baichuan.set_privacy_mode(ch, value),
     ),
+    ReolinkSwitchEntityDescription(
+        key="privacy_mask",
+        cmd_key="GetMask",
+        translation_key="privacy_mask",
+        entity_category=EntityCategory.CONFIG,
+        supported=lambda api, ch: api.supported(ch, "privacy_mask"),
+        value=lambda api, ch: api.privacy_mask_enabled(ch),
+        method=lambda api, ch, value: api.set_privacy_mask(ch, enable=value),
+    ),
     ReolinkSwitchEntityDescription(
         key="hardwired_chime_enabled",
         cmd_key="483",

homeassistant/components/rflink/manifest.json

@@ -6,5 +6,5 @@
   "iot_class": "assumed_state",
   "loggers": ["rflink"],
   "quality_scale": "legacy",
-  "requirements": ["rflink==0.0.66"]
+  "requirements": ["rflink==0.0.67"]
 }

homeassistant/components/russound_rio/manifest.json

@@ -7,6 +7,6 @@
   "iot_class": "local_push",
   "loggers": ["aiorussound"],
   "quality_scale": "silver",
-  "requirements": ["aiorussound==4.5.2"],
+  "requirements": ["aiorussound==4.6.0"],
   "zeroconf": ["_rio._tcp.local."]
 }

homeassistant/components/sensor/helpers.py

@@ -6,9 +6,14 @@ from datetime import date, datetime
 import logging
 
 from homeassistant.core import callback
+from homeassistant.helpers.selector import (
+    SelectSelector,
+    SelectSelectorConfig,
+    SelectSelectorMode,
+)
 from homeassistant.util import dt as dt_util
 
-from . import SensorDeviceClass
+from . import DOMAIN, SensorDeviceClass, SensorStateClass
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -37,3 +42,31 @@ def async_parse_date_datetime(
 
     _LOGGER.warning("%s rendered invalid date %s", entity_id, value)
     return None
+
+
+@callback
+def create_sensor_device_class_select_selector() -> SelectSelector:
+    """Create sensor device class select selector."""
+    return SelectSelector(
+        SelectSelectorConfig(
+            options=[device_class.value for device_class in SensorDeviceClass],
+            mode=SelectSelectorMode.DROPDOWN,
+            translation_key="device_class",
+            translation_domain=DOMAIN,
+            sort=True,
+        )
+    )
+
+
+@callback
+def create_sensor_state_class_select_selector() -> SelectSelector:
+    """Create sensor state class select selector."""
+    return SelectSelector(
+        SelectSelectorConfig(
+            options=[device_class.value for device_class in SensorStateClass],
+            mode=SelectSelectorMode.DROPDOWN,
+            translation_key="state_class",
+            translation_domain=DOMAIN,
+            sort=True,
+        )
+    )

homeassistant/components/sensor/strings.json

@@ -327,5 +327,74 @@
       "title": "The unit of {statistic_id} has changed",
       "description": ""
     }
+  },
+  "selector": {
+    "device_class": {
+      "options": {
+        "apparent_power": "[%key:component::sensor::entity_component::apparent_power::name%]",
+        "area": "[%key:component::sensor::entity_component::area::name%]",
+        "aqi": "[%key:component::sensor::entity_component::aqi::name%]",
+        "atmospheric_pressure": "[%key:component::sensor::entity_component::atmospheric_pressure::name%]",
+        "battery": "[%key:component::sensor::entity_component::battery::name%]",
+        "blood_glucose_concentration": "[%key:component::sensor::entity_component::blood_glucose_concentration::name%]",
+        "carbon_dioxide": "[%key:component::sensor::entity_component::carbon_dioxide::name%]",
+        "carbon_monoxide": "[%key:component::sensor::entity_component::carbon_monoxide::name%]",
+        "conductivity": "[%key:component::sensor::entity_component::conductivity::name%]",
+        "current": "[%key:component::sensor::entity_component::current::name%]",
+        "data_rate": "[%key:component::sensor::entity_component::data_rate::name%]",
+        "data_size": "[%key:component::sensor::entity_component::data_size::name%]",
+        "date": "[%key:component::sensor::entity_component::date::name%]",
+        "distance": "[%key:component::sensor::entity_component::distance::name%]",
+        "duration": "[%key:component::sensor::entity_component::duration::name%]",
+        "energy": "[%key:component::sensor::entity_component::energy::name%]",
+        "energy_distance": "[%key:component::sensor::entity_component::energy_distance::name%]",
+        "energy_storage": "[%key:component::sensor::entity_component::energy_storage::name%]",
+        "enum": "Enumeration",
+        "frequency": "[%key:component::sensor::entity_component::frequency::name%]",
+        "gas": "[%key:component::sensor::entity_component::gas::name%]",
+        "humidity": "[%key:component::sensor::entity_component::humidity::name%]",
+        "illuminance": "[%key:component::sensor::entity_component::illuminance::name%]",
+        "irradiance": "[%key:component::sensor::entity_component::irradiance::name%]",
+        "moisture": "[%key:component::sensor::entity_component::moisture::name%]",
+        "monetary": "[%key:component::sensor::entity_component::monetary::name%]",
+        "nitrogen_dioxide": "[%key:component::sensor::entity_component::nitrogen_dioxide::name%]",
+        "nitrogen_monoxide": "[%key:component::sensor::entity_component::nitrogen_monoxide::name%]",
+        "nitrous_oxide": "[%key:component::sensor::entity_component::nitrous_oxide::name%]",
+        "ozone": "[%key:component::sensor::entity_component::ozone::name%]",
+        "ph": "[%key:component::sensor::entity_component::ph::name%]",
+        "pm1": "[%key:component::sensor::entity_component::pm1::name%]",
+        "pm10": "[%key:component::sensor::entity_component::pm10::name%]",
+        "pm25": "[%key:component::sensor::entity_component::pm25::name%]",
+        "power": "[%key:component::sensor::entity_component::power::name%]",
+        "power_factor": "[%key:component::sensor::entity_component::power_factor::name%]",
+        "precipitation": "[%key:component::sensor::entity_component::precipitation::name%]",
+        "precipitation_intensity": "[%key:component::sensor::entity_component::precipitation_intensity::name%]",
+        "pressure": "[%key:component::sensor::entity_component::pressure::name%]",
+        "reactive_power": "[%key:component::sensor::entity_component::reactive_power::name%]",
+        "signal_strength": "[%key:component::sensor::entity_component::signal_strength::name%]",
+        "sound_pressure": "[%key:component::sensor::entity_component::sound_pressure::name%]",
+        "speed": "[%key:component::sensor::entity_component::speed::name%]",
+        "sulphur_dioxide": "[%key:component::sensor::entity_component::sulphur_dioxide::name%]",
+        "temperature": "[%key:component::sensor::entity_component::temperature::name%]",
+        "timestamp": "[%key:component::sensor::entity_component::timestamp::name%]",
+        "volatile_organic_compounds": "[%key:component::sensor::entity_component::volatile_organic_compounds::name%]",
+        "volatile_organic_compounds_parts": "[%key:component::sensor::entity_component::volatile_organic_compounds::name%]",
+        "voltage": "[%key:component::sensor::entity_component::voltage::name%]",
+        "volume": "[%key:component::sensor::entity_component::volume::name%]",
+        "volume_flow_rate": "[%key:component::sensor::entity_component::volume_flow_rate::name%]",
+        "volume_storage": "[%key:component::sensor::entity_component::volume_storage::name%]",
+        "water": "[%key:component::sensor::entity_component::water::name%]",
+        "weight": "[%key:component::sensor::entity_component::weight::name%]",
+        "wind_direction": "[%key:component::sensor::entity_component::wind_direction::name%]",
+        "wind_speed": "[%key:component::sensor::entity_component::wind_speed::name%]"
+      }
+    },
+    "state_class": {
+      "options": {
+        "measurement": "[%key:component::sensor::entity_component::_::state_attributes::state_class::state::measurement%]",
+        "total": "[%key:component::sensor::entity_component::_::state_attributes::state_class::state::total%]",
+        "total_increasing": "[%key:component::sensor::entity_component::_::state_attributes::state_class::state::total_increasing%]"
+      }
+    }
   }
 }

homeassistant/components/smarla/__init__.py

@@ -22,12 +22,13 @@ async def async_setup_entry(hass: HomeAssistant, entry: FederwiegeConfigEntry) -
 
     federwiege = Federwiege(hass.loop, connection)
     federwiege.register()
-    federwiege.connect()
 
     entry.runtime_data = federwiege
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
+    federwiege.connect()
+
     return True
 
 

homeassistant/components/smarla/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_push",
   "loggers": ["pysmarlaapi", "pysignalr"],
   "quality_scale": "bronze",
-  "requirements": ["pysmarlaapi==0.8.2"]
+  "requirements": ["pysmarlaapi==0.9.0"]
 }

homeassistant/components/smarla/number.py

@@ -53,9 +53,10 @@ class SmarlaNumber(SmarlaBaseEntity, NumberEntity):
     _property: Property[int]
 
     @property
-    def native_value(self) -> float:
+    def native_value(self) -> float | None:
         """Return the entity value to represent the entity state."""
-        return self._property.get()
+        v = self._property.get()
+        return float(v) if v is not None else None
 
     def set_native_value(self, value: float) -> None:
         """Update to the smarla device."""

homeassistant/components/smarla/switch.py

@@ -52,7 +52,7 @@ class SmarlaSwitch(SmarlaBaseEntity, SwitchEntity):
     _property: Property[bool]
 
     @property
-    def is_on(self) -> bool:
+    def is_on(self) -> bool | None:
         """Return the entity value to represent the entity state."""
         return self._property.get()
 

homeassistant/components/smartthings/manifest.json

@@ -30,5 +30,5 @@
   "iot_class": "cloud_push",
   "loggers": ["pysmartthings"],
   "quality_scale": "bronze",
-  "requirements": ["pysmartthings==3.2.4"]
+  "requirements": ["pysmartthings==3.2.5"]
 }

homeassistant/components/smartthings/strings.json

@@ -605,7 +605,10 @@
         "name": "Wrinkle prevent"
       },
       "ice_maker": {
-        "name": "Ice maker"
+        "name": "Cubed ice"
+      },
+      "ice_maker_2": {
+        "name": "Ice Bites"
       },
       "sabbath_mode": {
         "name": "Sabbath mode"

homeassistant/components/smartthings/switch.py

@@ -95,6 +95,7 @@ CAPABILITY_TO_SWITCHES: dict[Capability | str, SmartThingsSwitchEntityDescriptio
         status_attribute=Attribute.SWITCH,
         component_translation_key={
             "icemaker": "ice_maker",
+            "icemaker-02": "ice_maker_2",
         },
     ),
     Capability.SAMSUNG_CE_SABBATH_MODE: SmartThingsSwitchEntityDescription(

homeassistant/components/switch/helpers.py

@@ -0,0 +1,25 @@
+"""Helpers for switch entities."""
+
+from homeassistant.core import callback
+from homeassistant.helpers.selector import (
+    SelectSelector,
+    SelectSelectorConfig,
+    SelectSelectorMode,
+)
+
+from . import DOMAIN, SwitchDeviceClass
+
+
+@callback
+def create_switch_device_class_select_selector() -> SelectSelector:
+    """Create sensor device class select selector."""
+
+    return SelectSelector(
+        SelectSelectorConfig(
+            options=[device_class.value for device_class in SwitchDeviceClass],
+            mode=SelectSelectorMode.DROPDOWN,
+            translation_key="device_class",
+            translation_domain=DOMAIN,
+            sort=True,
+        )
+    )

homeassistant/components/switch/strings.json

@@ -52,5 +52,13 @@
       "name": "[%key:common::action::toggle%]",
       "description": "Toggles a switch on/off."
     }
+  },
+  "selector": {
+    "device_class": {
+      "options": {
+        "outlet": "[%key:component::switch::entity_component::outlet::name%]",
+        "switch": "[%key:component::switch::title%]"
+      }
+    }
   }
 }

homeassistant/components/telegram_bot/__init__.py

@@ -46,6 +46,7 @@ from .const import (
     ATTR_DISABLE_WEB_PREV,
     ATTR_FILE,
     ATTR_IS_ANONYMOUS,
+    ATTR_IS_BIG,
     ATTR_KEYBOARD,
     ATTR_KEYBOARD_INLINE,
     ATTR_MESSAGE,
@@ -58,6 +59,7 @@ from .const import (
     ATTR_PARSER,
     ATTR_PASSWORD,
     ATTR_QUESTION,
+    ATTR_REACTION,
     ATTR_RESIZE_KEYBOARD,
     ATTR_SHOW_ALERT,
     ATTR_STICKER_ID,
@@ -94,6 +96,7 @@ from .const import (
     SERVICE_SEND_STICKER,
     SERVICE_SEND_VIDEO,
     SERVICE_SEND_VOICE,
+    SERVICE_SET_MESSAGE_REACTION,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -250,6 +253,19 @@ SERVICE_SCHEMA_LEAVE_CHAT = vol.Schema(
     }
 )
 
+SERVICE_SCHEMA_SET_MESSAGE_REACTION = vol.Schema(
+    {
+        vol.Optional(CONF_CONFIG_ENTRY_ID): cv.string,
+        vol.Required(ATTR_MESSAGEID): vol.Any(
+            cv.positive_int, vol.All(cv.string, "last")
+        ),
+        vol.Required(ATTR_CHAT_ID): vol.Coerce(int),
+        vol.Required(ATTR_REACTION): cv.string,
+        vol.Optional(ATTR_IS_BIG, default=False): cv.boolean,
+    },
+    extra=vol.ALLOW_EXTRA,
+)
+
 SERVICE_MAP = {
     SERVICE_SEND_MESSAGE: SERVICE_SCHEMA_SEND_MESSAGE,
     SERVICE_SEND_PHOTO: SERVICE_SCHEMA_SEND_FILE,
@@ -266,6 +282,7 @@ SERVICE_MAP = {
     SERVICE_ANSWER_CALLBACK_QUERY: SERVICE_SCHEMA_ANSWER_CALLBACK_QUERY,
     SERVICE_DELETE_MESSAGE: SERVICE_SCHEMA_DELETE_MESSAGE,
     SERVICE_LEAVE_CHAT: SERVICE_SCHEMA_LEAVE_CHAT,
+    SERVICE_SET_MESSAGE_REACTION: SERVICE_SCHEMA_SET_MESSAGE_REACTION,
 }
 
 
@@ -378,6 +395,8 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
             messages = await notify_service.leave_chat(
                 context=service.context, **kwargs
             )
+        elif msgtype == SERVICE_SET_MESSAGE_REACTION:
+            await notify_service.set_message_reaction(context=service.context, **kwargs)
         else:
             await notify_service.edit_message(
                 msgtype, context=service.context, **kwargs

homeassistant/components/telegram_bot/bot.py

@@ -786,6 +786,39 @@ class TelegramNotificationService:
             self.bot.leave_chat, "Error leaving chat", None, chat_id, context=context
         )
 
+    async def set_message_reaction(
+        self,
+        chat_id: int,
+        reaction: str,
+        is_big: bool = False,
+        context: Context | None = None,
+        **kwargs,
+    ) -> None:
+        """Set the bot's reaction for a given message."""
+        chat_id = self._get_target_chat_ids(chat_id)[0]
+        message_id, _ = self._get_msg_ids(kwargs, chat_id)
+        params = self._get_msg_kwargs(kwargs)
+
+        _LOGGER.debug(
+            "Set reaction to message %s in chat ID %s to %s with params: %s",
+            message_id,
+            chat_id,
+            reaction,
+            params,
+        )
+
+        await self._send_msg(
+            self.bot.set_message_reaction,
+            "Error setting message reaction",
+            params[ATTR_MESSAGE_TAG],
+            chat_id,
+            message_id,
+            reaction=reaction,
+            is_big=is_big,
+            read_timeout=params[ATTR_TIMEOUT],
+            context=context,
+        )
+
 
 def initialize_bot(hass: HomeAssistant, p_config: MappingProxyType[str, Any]) -> Bot:
     """Initialize telegram bot with proxy support."""

homeassistant/components/telegram_bot/const.py

@@ -43,6 +43,7 @@ SERVICE_SEND_VOICE = "send_voice"
 SERVICE_SEND_DOCUMENT = "send_document"
 SERVICE_SEND_LOCATION = "send_location"
 SERVICE_SEND_POLL = "send_poll"
+SERVICE_SET_MESSAGE_REACTION = "set_message_reaction"
 SERVICE_EDIT_MESSAGE = "edit_message"
 SERVICE_EDIT_CAPTION = "edit_caption"
 SERVICE_EDIT_REPLYMARKUP = "edit_replymarkup"
@@ -87,6 +88,8 @@ ATTR_MSG = "message"
 ATTR_MSGID = "id"
 ATTR_PARSER = "parse_mode"
 ATTR_PASSWORD = "password"
+ATTR_REACTION = "reaction"
+ATTR_IS_BIG = "is_big"
 ATTR_REPLY_TO_MSGID = "reply_to_message_id"
 ATTR_REPLYMARKUP = "reply_markup"
 ATTR_SHOW_ALERT = "show_alert"

homeassistant/components/telegram_bot/icons.json

@@ -44,6 +44,9 @@
     },
     "leave_chat": {
       "service": "mdi:exit-run"
+    },
+    "set_message_reaction": {
+      "service": "mdi:emoticon-happy"
     }
   }
 }

homeassistant/components/telegram_bot/services.yaml

@@ -787,3 +787,29 @@ leave_chat:
       example: 12345
       selector:
         text:
+
+set_message_reaction:
+  fields:
+    config_entry_id:
+      selector:
+        config_entry:
+          integration: telegram_bot
+    message_id:
+      required: true
+      example: 54321
+      selector:
+        text:
+    chat_id:
+      required: true
+      example: 12345
+      selector:
+        text:
+    reaction:
+      required: true
+      example: 👍
+      selector:
+        text:
+    is_big:
+      required: false
+      selector:
+        boolean:

homeassistant/components/telegram_bot/strings.json

@@ -857,6 +857,32 @@
           "description": "Chat ID of the group from which the bot should be removed."
         }
       }
+    },
+    "set_message_reaction": {
+      "name": "Set message reaction",
+      "description": "Sets the bot's reaction for a given message.",
+      "fields": {
+        "config_entry_id": {
+          "name": "[%key:component::telegram_bot::services::send_message::fields::config_entry_id::name%]",
+          "description": "The config entry representing the Telegram bot to set the message reaction."
+        },
+        "message_id": {
+          "name": "[%key:component::telegram_bot::services::edit_message::fields::message_id::name%]",
+          "description": "ID of the message to react to."
+        },
+        "chat_id": {
+          "name": "[%key:component::telegram_bot::services::edit_message::fields::chat_id::name%]",
+          "description": "ID of the chat containing the message."
+        },
+        "reaction": {
+          "name": "Reaction",
+          "description": "Emoji reaction to use."
+        },
+        "is_big": {
+          "name": "Large animation",
+          "description": "Whether the reaction animation should be large."
+        }
+      }
     }
   },
   "exceptions": {

homeassistant/components/template/alarm_control_panel.py

@@ -41,13 +41,12 @@ from homeassistant.helpers.restore_state import RestoreEntity
 from homeassistant.helpers.script import Script
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
-from .const import CONF_OBJECT_ID, CONF_PICTURE, DOMAIN
+from .const import CONF_OBJECT_ID, DOMAIN
 from .entity import AbstractTemplateEntity
 from .template_entity import (
     LEGACY_FIELDS as TEMPLATE_ENTITY_LEGACY_FIELDS,
-    TEMPLATE_ENTITY_AVAILABILITY_SCHEMA,
-    TEMPLATE_ENTITY_ICON_SCHEMA,
     TemplateEntity,
+    make_template_entity_common_modern_schema,
     rewrite_common_legacy_to_modern_conf,
 )
 
@@ -105,15 +104,10 @@ ALARM_CONTROL_PANEL_SCHEMA = vol.All(
                 CONF_CODE_FORMAT, default=TemplateCodeFormat.number.name
             ): cv.enum(TemplateCodeFormat),
             vol.Optional(CONF_DISARM_ACTION): cv.SCRIPT_SCHEMA,
-            vol.Optional(CONF_NAME): cv.template,
-            vol.Optional(CONF_PICTURE): cv.template,
             vol.Optional(CONF_STATE): cv.template,
             vol.Optional(CONF_TRIGGER_ACTION): cv.SCRIPT_SCHEMA,
-            vol.Optional(CONF_UNIQUE_ID): cv.string,
         }
-    )
-    .extend(TEMPLATE_ENTITY_AVAILABILITY_SCHEMA.schema)
-    .extend(TEMPLATE_ENTITY_ICON_SCHEMA.schema),
+    ).extend(make_template_entity_common_modern_schema(DEFAULT_NAME).schema)
 )
 
 
@@ -419,9 +413,7 @@ class AlarmControlPanelTemplate(TemplateEntity, AbstractTemplateAlarmControlPane
         unique_id: str | None,
     ) -> None:
         """Initialize the panel."""
-        TemplateEntity.__init__(
-            self, hass, config=config, fallback_name=None, unique_id=unique_id
-        )
+        TemplateEntity.__init__(self, hass, config=config, unique_id=unique_id)
         AbstractTemplateAlarmControlPanel.__init__(self, config)
         if (object_id := config.get(CONF_OBJECT_ID)) is not None:
             self.entity_id = async_generate_entity_id(

homeassistant/components/template/button.py

@@ -26,29 +26,19 @@ from homeassistant.helpers.entity_platform import (
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
 from .const import CONF_PRESS, DOMAIN
-from .template_entity import (
-    TEMPLATE_ENTITY_AVAILABILITY_SCHEMA,
-    TEMPLATE_ENTITY_ICON_SCHEMA,
-    TemplateEntity,
-)
+from .template_entity import TemplateEntity, make_template_entity_common_modern_schema
 
 _LOGGER = logging.getLogger(__name__)
 
 DEFAULT_NAME = "Template Button"
 DEFAULT_OPTIMISTIC = False
 
-BUTTON_SCHEMA = (
-    vol.Schema(
-        {
-            vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.template,
-            vol.Required(CONF_PRESS): cv.SCRIPT_SCHEMA,
-            vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
-            vol.Optional(CONF_UNIQUE_ID): cv.string,
-        }
-    )
-    .extend(TEMPLATE_ENTITY_AVAILABILITY_SCHEMA.schema)
-    .extend(TEMPLATE_ENTITY_ICON_SCHEMA.schema)
-)
+BUTTON_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_PRESS): cv.SCRIPT_SCHEMA,
+        vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
+    }
+).extend(make_template_entity_common_modern_schema(DEFAULT_NAME).schema)
 
 CONFIG_BUTTON_SCHEMA = vol.Schema(
     {

homeassistant/components/template/cover.py

@@ -37,14 +37,13 @@ from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
 from . import TriggerUpdateCoordinator
-from .const import CONF_OBJECT_ID, CONF_PICTURE, DOMAIN
+from .const import CONF_OBJECT_ID, DOMAIN
 from .entity import AbstractTemplateEntity
 from .template_entity import (
     LEGACY_FIELDS as TEMPLATE_ENTITY_LEGACY_FIELDS,
-    TEMPLATE_ENTITY_AVAILABILITY_SCHEMA,
     TEMPLATE_ENTITY_COMMON_SCHEMA_LEGACY,
-    TEMPLATE_ENTITY_ICON_SCHEMA,
     TemplateEntity,
+    make_template_entity_common_modern_schema,
     rewrite_common_legacy_to_modern_conf,
 )
 from .trigger_entity import TriggerEntity
@@ -100,21 +99,16 @@ COVER_SCHEMA = vol.All(
             vol.Inclusive(CLOSE_ACTION, CONF_OPEN_AND_CLOSE): cv.SCRIPT_SCHEMA,
             vol.Inclusive(OPEN_ACTION, CONF_OPEN_AND_CLOSE): cv.SCRIPT_SCHEMA,
             vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
-            vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.template,
             vol.Optional(CONF_OPTIMISTIC): cv.boolean,
-            vol.Optional(CONF_PICTURE): cv.template,
             vol.Optional(CONF_POSITION): cv.template,
             vol.Optional(CONF_STATE): cv.template,
             vol.Optional(CONF_TILT_OPTIMISTIC): cv.boolean,
             vol.Optional(CONF_TILT): cv.template,
-            vol.Optional(CONF_UNIQUE_ID): cv.string,
             vol.Optional(POSITION_ACTION): cv.SCRIPT_SCHEMA,
             vol.Optional(STOP_ACTION): cv.SCRIPT_SCHEMA,
             vol.Optional(TILT_ACTION): cv.SCRIPT_SCHEMA,
         }
-    )
-    .extend(TEMPLATE_ENTITY_AVAILABILITY_SCHEMA.schema)
-    .extend(TEMPLATE_ENTITY_ICON_SCHEMA.schema),
+    ).extend(make_template_entity_common_modern_schema(DEFAULT_NAME).schema),
     cv.has_at_least_one_key(OPEN_ACTION, POSITION_ACTION),
 )
 
@@ -463,9 +457,7 @@ class CoverTemplate(TemplateEntity, AbstractTemplateCover):
         unique_id,
     ) -> None:
         """Initialize the Template cover."""
-        TemplateEntity.__init__(
-            self, hass, config=config, fallback_name=None, unique_id=unique_id
-        )
+        TemplateEntity.__init__(self, hass, config=config, unique_id=unique_id)
         AbstractTemplateCover.__init__(self, config)
         if (object_id := config.get(CONF_OBJECT_ID)) is not None:
             self.entity_id = async_generate_entity_id(

homeassistant/components/template/fan.py

@@ -37,14 +37,13 @@ from homeassistant.helpers.entity import async_generate_entity_id
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
-from .const import CONF_OBJECT_ID, CONF_PICTURE, DOMAIN
+from .const import CONF_OBJECT_ID, DOMAIN
 from .entity import AbstractTemplateEntity
 from .template_entity import (
     LEGACY_FIELDS as TEMPLATE_ENTITY_LEGACY_FIELDS,
-    TEMPLATE_ENTITY_AVAILABILITY_SCHEMA,
     TEMPLATE_ENTITY_AVAILABILITY_SCHEMA_LEGACY,
-    TEMPLATE_ENTITY_ICON_SCHEMA,
     TemplateEntity,
+    make_template_entity_common_modern_schema,
     rewrite_common_legacy_to_modern_conf,
 )
 
@@ -85,12 +84,10 @@ FAN_SCHEMA = vol.All(
     vol.Schema(
         {
             vol.Optional(CONF_DIRECTION): cv.template,
-            vol.Optional(CONF_NAME): cv.template,
             vol.Required(CONF_OFF_ACTION): cv.SCRIPT_SCHEMA,
             vol.Required(CONF_ON_ACTION): cv.SCRIPT_SCHEMA,
             vol.Optional(CONF_OSCILLATING): cv.template,
             vol.Optional(CONF_PERCENTAGE): cv.template,
-            vol.Optional(CONF_PICTURE): cv.template,
             vol.Optional(CONF_PRESET_MODE): cv.template,
             vol.Optional(CONF_PRESET_MODES): cv.ensure_list,
             vol.Optional(CONF_SET_DIRECTION_ACTION): cv.SCRIPT_SCHEMA,
@@ -99,11 +96,8 @@ FAN_SCHEMA = vol.All(
             vol.Optional(CONF_SET_PRESET_MODE_ACTION): cv.SCRIPT_SCHEMA,
             vol.Optional(CONF_SPEED_COUNT): vol.Coerce(int),
             vol.Optional(CONF_STATE): cv.template,
-            vol.Optional(CONF_UNIQUE_ID): cv.string,
         }
-    )
-    .extend(TEMPLATE_ENTITY_AVAILABILITY_SCHEMA.schema)
-    .extend(TEMPLATE_ENTITY_ICON_SCHEMA.schema),
+    ).extend(make_template_entity_common_modern_schema(DEFAULT_NAME).schema)
 )
 
 LEGACY_FAN_SCHEMA = vol.All(
@@ -488,9 +482,7 @@ class TemplateFan(TemplateEntity, AbstractTemplateFan):
         unique_id,
     ) -> None:
         """Initialize the fan."""
-        TemplateEntity.__init__(
-            self, hass, config=config, fallback_name=None, unique_id=unique_id
-        )
+        TemplateEntity.__init__(self, hass, config=config, unique_id=unique_id)
         AbstractTemplateFan.__init__(self, config)
         if (object_id := config.get(CONF_OBJECT_ID)) is not None:
             self.entity_id = async_generate_entity_id(

homeassistant/components/template/image.py

@@ -29,7 +29,10 @@ from homeassistant.util import dt as dt_util
 
 from . import TriggerUpdateCoordinator
 from .const import CONF_PICTURE
-from .template_entity import TemplateEntity, make_template_entity_common_schema
+from .template_entity import (
+    TemplateEntity,
+    make_template_entity_common_modern_attributes_schema,
+)
 from .trigger_entity import TriggerEntity
 
 _LOGGER = logging.getLogger(__name__)
@@ -43,7 +46,7 @@ IMAGE_SCHEMA = vol.Schema(
         vol.Required(CONF_URL): cv.template,
         vol.Optional(CONF_VERIFY_SSL, default=True): bool,
     }
-).extend(make_template_entity_common_schema(DEFAULT_NAME).schema)
+).extend(make_template_entity_common_modern_attributes_schema(DEFAULT_NAME).schema)
 
 
 IMAGE_CONFIG_SCHEMA = vol.Schema(

homeassistant/components/template/light.py

@@ -49,14 +49,13 @@ from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 from homeassistant.util import color as color_util
 
 from . import TriggerUpdateCoordinator
-from .const import CONF_OBJECT_ID, CONF_PICTURE, DOMAIN
+from .const import CONF_OBJECT_ID, DOMAIN
 from .entity import AbstractTemplateEntity
 from .template_entity import (
     LEGACY_FIELDS as TEMPLATE_ENTITY_LEGACY_FIELDS,
-    TEMPLATE_ENTITY_AVAILABILITY_SCHEMA,
     TEMPLATE_ENTITY_COMMON_SCHEMA_LEGACY,
-    TEMPLATE_ENTITY_ICON_SCHEMA,
     TemplateEntity,
+    make_template_entity_common_modern_schema,
     rewrite_common_legacy_to_modern_conf,
 )
 from .trigger_entity import TriggerEntity
@@ -124,38 +123,31 @@ LEGACY_FIELDS = TEMPLATE_ENTITY_LEGACY_FIELDS | {
 
 DEFAULT_NAME = "Template Light"
 
-LIGHT_SCHEMA = (
-    vol.Schema(
-        {
-            vol.Inclusive(CONF_EFFECT_ACTION, "effect"): cv.SCRIPT_SCHEMA,
-            vol.Inclusive(CONF_EFFECT_LIST, "effect"): cv.template,
-            vol.Inclusive(CONF_EFFECT, "effect"): cv.template,
-            vol.Optional(CONF_HS_ACTION): cv.SCRIPT_SCHEMA,
-            vol.Optional(CONF_HS): cv.template,
-            vol.Optional(CONF_LEVEL_ACTION): cv.SCRIPT_SCHEMA,
-            vol.Optional(CONF_LEVEL): cv.template,
-            vol.Optional(CONF_MAX_MIREDS): cv.template,
-            vol.Optional(CONF_MIN_MIREDS): cv.template,
-            vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.template,
-            vol.Optional(CONF_PICTURE): cv.template,
-            vol.Optional(CONF_RGB_ACTION): cv.SCRIPT_SCHEMA,
-            vol.Optional(CONF_RGB): cv.template,
-            vol.Optional(CONF_RGBW_ACTION): cv.SCRIPT_SCHEMA,
-            vol.Optional(CONF_RGBW): cv.template,
-            vol.Optional(CONF_RGBWW_ACTION): cv.SCRIPT_SCHEMA,
-            vol.Optional(CONF_RGBWW): cv.template,
-            vol.Optional(CONF_STATE): cv.template,
-            vol.Optional(CONF_SUPPORTS_TRANSITION): cv.template,
-            vol.Optional(CONF_TEMPERATURE_ACTION): cv.SCRIPT_SCHEMA,
-            vol.Optional(CONF_TEMPERATURE): cv.template,
-            vol.Optional(CONF_UNIQUE_ID): cv.string,
-            vol.Required(CONF_OFF_ACTION): cv.SCRIPT_SCHEMA,
-            vol.Required(CONF_ON_ACTION): cv.SCRIPT_SCHEMA,
-        }
-    )
-    .extend(TEMPLATE_ENTITY_AVAILABILITY_SCHEMA.schema)
-    .extend(TEMPLATE_ENTITY_ICON_SCHEMA.schema)
-)
+LIGHT_SCHEMA = vol.Schema(
+    {
+        vol.Inclusive(CONF_EFFECT_ACTION, "effect"): cv.SCRIPT_SCHEMA,
+        vol.Inclusive(CONF_EFFECT_LIST, "effect"): cv.template,
+        vol.Inclusive(CONF_EFFECT, "effect"): cv.template,
+        vol.Optional(CONF_HS_ACTION): cv.SCRIPT_SCHEMA,
+        vol.Optional(CONF_HS): cv.template,
+        vol.Optional(CONF_LEVEL_ACTION): cv.SCRIPT_SCHEMA,
+        vol.Optional(CONF_LEVEL): cv.template,
+        vol.Optional(CONF_MAX_MIREDS): cv.template,
+        vol.Optional(CONF_MIN_MIREDS): cv.template,
+        vol.Optional(CONF_RGB_ACTION): cv.SCRIPT_SCHEMA,
+        vol.Optional(CONF_RGB): cv.template,
+        vol.Optional(CONF_RGBW_ACTION): cv.SCRIPT_SCHEMA,
+        vol.Optional(CONF_RGBW): cv.template,
+        vol.Optional(CONF_RGBWW_ACTION): cv.SCRIPT_SCHEMA,
+        vol.Optional(CONF_RGBWW): cv.template,
+        vol.Optional(CONF_STATE): cv.template,
+        vol.Optional(CONF_SUPPORTS_TRANSITION): cv.template,
+        vol.Optional(CONF_TEMPERATURE_ACTION): cv.SCRIPT_SCHEMA,
+        vol.Optional(CONF_TEMPERATURE): cv.template,
+        vol.Required(CONF_OFF_ACTION): cv.SCRIPT_SCHEMA,
+        vol.Required(CONF_ON_ACTION): cv.SCRIPT_SCHEMA,
+    }
+).extend(make_template_entity_common_modern_schema(DEFAULT_NAME).schema)
 
 LEGACY_LIGHT_SCHEMA = vol.All(
     cv.deprecated(CONF_ENTITY_ID),
@@ -955,9 +947,7 @@ class LightTemplate(TemplateEntity, AbstractTemplateLight):
         unique_id: str | None,
     ) -> None:
         """Initialize the light."""
-        TemplateEntity.__init__(
-            self, hass, config=config, fallback_name=None, unique_id=unique_id
-        )
+        TemplateEntity.__init__(self, hass, config=config, unique_id=unique_id)
         AbstractTemplateLight.__init__(self, config)
         if (object_id := config.get(CONF_OBJECT_ID)) is not None:
             self.entity_id = async_generate_entity_id(

homeassistant/components/template/lock.py

@@ -31,10 +31,9 @@ from .const import CONF_PICTURE, DOMAIN
 from .entity import AbstractTemplateEntity
 from .template_entity import (
     LEGACY_FIELDS as TEMPLATE_ENTITY_LEGACY_FIELDS,
-    TEMPLATE_ENTITY_AVAILABILITY_SCHEMA,
     TEMPLATE_ENTITY_AVAILABILITY_SCHEMA_LEGACY,
-    TEMPLATE_ENTITY_ICON_SCHEMA,
     TemplateEntity,
+    make_template_entity_common_modern_schema,
     rewrite_common_legacy_to_modern_conf,
 )
 
@@ -57,17 +56,13 @@ LOCK_SCHEMA = vol.All(
         {
             vol.Optional(CONF_CODE_FORMAT): cv.template,
             vol.Required(CONF_LOCK): cv.SCRIPT_SCHEMA,
-            vol.Optional(CONF_NAME): cv.template,
             vol.Optional(CONF_OPEN): cv.SCRIPT_SCHEMA,
             vol.Optional(CONF_OPTIMISTIC, default=DEFAULT_OPTIMISTIC): cv.boolean,
             vol.Optional(CONF_PICTURE): cv.template,
             vol.Required(CONF_STATE): cv.template,
-            vol.Optional(CONF_UNIQUE_ID): cv.string,
             vol.Required(CONF_UNLOCK): cv.SCRIPT_SCHEMA,
         }
-    )
-    .extend(TEMPLATE_ENTITY_AVAILABILITY_SCHEMA.schema)
-    .extend(TEMPLATE_ENTITY_ICON_SCHEMA.schema),
+    ).extend(make_template_entity_common_modern_schema(DEFAULT_NAME).schema)
 )
 
 
@@ -313,9 +308,7 @@ class TemplateLock(TemplateEntity, AbstractTemplateLock):
         unique_id: str | None,
     ) -> None:
         """Initialize the lock."""
-        TemplateEntity.__init__(
-            self, hass, config=config, fallback_name=DEFAULT_NAME, unique_id=unique_id
-        )
+        TemplateEntity.__init__(self, hass, config=config, unique_id=unique_id)
         AbstractTemplateLock.__init__(self, config)
         name = self._attr_name
         if TYPE_CHECKING:

homeassistant/components/template/number.py

@@ -35,11 +35,7 @@ from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
 from . import TriggerUpdateCoordinator
 from .const import CONF_MAX, CONF_MIN, CONF_STEP, DOMAIN
-from .template_entity import (
-    TEMPLATE_ENTITY_AVAILABILITY_SCHEMA,
-    TEMPLATE_ENTITY_ICON_SCHEMA,
-    TemplateEntity,
-)
+from .template_entity import TemplateEntity, make_template_entity_common_modern_schema
 from .trigger_entity import TriggerEntity
 
 _LOGGER = logging.getLogger(__name__)
@@ -49,23 +45,17 @@ CONF_SET_VALUE = "set_value"
 DEFAULT_NAME = "Template Number"
 DEFAULT_OPTIMISTIC = False
 
-NUMBER_SCHEMA = (
-    vol.Schema(
-        {
-            vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.template,
-            vol.Required(CONF_STATE): cv.template,
-            vol.Required(CONF_SET_VALUE): cv.SCRIPT_SCHEMA,
-            vol.Required(CONF_STEP): cv.template,
-            vol.Optional(CONF_MIN, default=DEFAULT_MIN_VALUE): cv.template,
-            vol.Optional(CONF_MAX, default=DEFAULT_MAX_VALUE): cv.template,
-            vol.Optional(CONF_UNIT_OF_MEASUREMENT): cv.string,
-            vol.Optional(CONF_OPTIMISTIC, default=DEFAULT_OPTIMISTIC): cv.boolean,
-            vol.Optional(CONF_UNIQUE_ID): cv.string,
-        }
-    )
-    .extend(TEMPLATE_ENTITY_AVAILABILITY_SCHEMA.schema)
-    .extend(TEMPLATE_ENTITY_ICON_SCHEMA.schema)
-)
+NUMBER_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_STATE): cv.template,
+        vol.Required(CONF_SET_VALUE): cv.SCRIPT_SCHEMA,
+        vol.Required(CONF_STEP): cv.template,
+        vol.Optional(CONF_MIN, default=DEFAULT_MIN_VALUE): cv.template,
+        vol.Optional(CONF_MAX, default=DEFAULT_MAX_VALUE): cv.template,
+        vol.Optional(CONF_UNIT_OF_MEASUREMENT): cv.string,
+        vol.Optional(CONF_OPTIMISTIC, default=DEFAULT_OPTIMISTIC): cv.boolean,
+    }
+).extend(make_template_entity_common_modern_schema(DEFAULT_NAME).schema)
 NUMBER_CONFIG_SCHEMA = vol.Schema(
     {
         vol.Required(CONF_NAME): cv.template,

homeassistant/components/template/select.py

@@ -32,11 +32,7 @@ from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
 from . import TriggerUpdateCoordinator
 from .const import DOMAIN
-from .template_entity import (
-    TEMPLATE_ENTITY_AVAILABILITY_SCHEMA,
-    TEMPLATE_ENTITY_ICON_SCHEMA,
-    TemplateEntity,
-)
+from .template_entity import TemplateEntity, make_template_entity_common_modern_schema
 from .trigger_entity import TriggerEntity
 
 _LOGGER = logging.getLogger(__name__)
@@ -47,20 +43,14 @@ CONF_SELECT_OPTION = "select_option"
 DEFAULT_NAME = "Template Select"
 DEFAULT_OPTIMISTIC = False
 
-SELECT_SCHEMA = (
-    vol.Schema(
-        {
-            vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.template,
-            vol.Required(CONF_STATE): cv.template,
-            vol.Required(CONF_SELECT_OPTION): cv.SCRIPT_SCHEMA,
-            vol.Required(ATTR_OPTIONS): cv.template,
-            vol.Optional(CONF_OPTIMISTIC, default=DEFAULT_OPTIMISTIC): cv.boolean,
-            vol.Optional(CONF_UNIQUE_ID): cv.string,
-        }
-    )
-    .extend(TEMPLATE_ENTITY_AVAILABILITY_SCHEMA.schema)
-    .extend(TEMPLATE_ENTITY_ICON_SCHEMA.schema)
-)
+SELECT_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_STATE): cv.template,
+        vol.Required(CONF_SELECT_OPTION): cv.SCRIPT_SCHEMA,
+        vol.Required(ATTR_OPTIONS): cv.template,
+        vol.Optional(CONF_OPTIMISTIC, default=DEFAULT_OPTIMISTIC): cv.boolean,
+    }
+).extend(make_template_entity_common_modern_schema(DEFAULT_NAME).schema)
 
 
 SELECT_CONFIG_SCHEMA = vol.Schema(

homeassistant/components/template/switch.py

@@ -40,13 +40,12 @@ from homeassistant.helpers.restore_state import RestoreEntity
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
 from . import TriggerUpdateCoordinator
-from .const import CONF_OBJECT_ID, CONF_PICTURE, CONF_TURN_OFF, CONF_TURN_ON, DOMAIN
+from .const import CONF_OBJECT_ID, CONF_TURN_OFF, CONF_TURN_ON, DOMAIN
 from .template_entity import (
     LEGACY_FIELDS as TEMPLATE_ENTITY_LEGACY_FIELDS,
-    TEMPLATE_ENTITY_AVAILABILITY_SCHEMA,
     TEMPLATE_ENTITY_COMMON_SCHEMA_LEGACY,
-    TEMPLATE_ENTITY_ICON_SCHEMA,
     TemplateEntity,
+    make_template_entity_common_modern_schema,
     rewrite_common_legacy_to_modern_conf,
 )
 from .trigger_entity import TriggerEntity
@@ -60,20 +59,13 @@ LEGACY_FIELDS = TEMPLATE_ENTITY_LEGACY_FIELDS | {
 DEFAULT_NAME = "Template Switch"
 
 
-SWITCH_SCHEMA = (
-    vol.Schema(
-        {
-            vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.template,
-            vol.Optional(CONF_STATE): cv.template,
-            vol.Required(CONF_TURN_ON): cv.SCRIPT_SCHEMA,
-            vol.Required(CONF_TURN_OFF): cv.SCRIPT_SCHEMA,
-            vol.Optional(CONF_UNIQUE_ID): cv.string,
-            vol.Optional(CONF_PICTURE): cv.template,
-        }
-    )
-    .extend(TEMPLATE_ENTITY_AVAILABILITY_SCHEMA.schema)
-    .extend(TEMPLATE_ENTITY_ICON_SCHEMA.schema)
-)
+SWITCH_SCHEMA = vol.Schema(
+    {
+        vol.Optional(CONF_STATE): cv.template,
+        vol.Required(CONF_TURN_ON): cv.SCRIPT_SCHEMA,
+        vol.Required(CONF_TURN_OFF): cv.SCRIPT_SCHEMA,
+    }
+).extend(make_template_entity_common_modern_schema(DEFAULT_NAME).schema)
 
 LEGACY_SWITCH_SCHEMA = vol.All(
     cv.deprecated(ATTR_ENTITY_ID),
@@ -228,7 +220,7 @@ class SwitchTemplate(TemplateEntity, SwitchEntity, RestoreEntity):
         unique_id: str | None,
     ) -> None:
         """Initialize the Template switch."""
-        super().__init__(hass, config=config, fallback_name=None, unique_id=unique_id)
+        super().__init__(hass, config=config, unique_id=unique_id)
         if (object_id := config.get(CONF_OBJECT_ID)) is not None:
             self.entity_id = async_generate_entity_id(
                 ENTITY_ID_FORMAT, object_id, hass=hass

homeassistant/components/template/template_entity.py

@@ -94,16 +94,24 @@ TEMPLATE_ENTITY_COMMON_SCHEMA = (
 )
 
 
-def make_template_entity_common_schema(default_name: str) -> vol.Schema:
+def make_template_entity_common_modern_schema(
+    default_name: str,
+) -> vol.Schema:
     """Return a schema with default name."""
-    return (
-        vol.Schema(
-            {
-                vol.Optional(CONF_AVAILABILITY): cv.template,
-            }
-        )
-        .extend(make_template_entity_base_schema(default_name).schema)
-        .extend(TEMPLATE_ENTITY_ATTRIBUTES_SCHEMA.schema)
+    return vol.Schema(
+        {
+            vol.Optional(CONF_AVAILABILITY): cv.template,
+            vol.Optional(CONF_VARIABLES): cv.SCRIPT_VARIABLES_SCHEMA,
+        }
+    ).extend(make_template_entity_base_schema(default_name).schema)
+
+
+def make_template_entity_common_modern_attributes_schema(
+    default_name: str,
+) -> vol.Schema:
+    """Return a schema with default name."""
+    return make_template_entity_common_modern_schema(default_name).extend(
+        TEMPLATE_ENTITY_ATTRIBUTES_SCHEMA.schema
     )
 
 

homeassistant/components/template/vacuum.py

@@ -38,16 +38,14 @@ from homeassistant.helpers.entity import async_generate_entity_id
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
-from .const import CONF_OBJECT_ID, CONF_PICTURE, DOMAIN
+from .const import CONF_OBJECT_ID, DOMAIN
 from .entity import AbstractTemplateEntity
 from .template_entity import (
     LEGACY_FIELDS as TEMPLATE_ENTITY_LEGACY_FIELDS,
-    TEMPLATE_ENTITY_ATTRIBUTES_SCHEMA,
     TEMPLATE_ENTITY_ATTRIBUTES_SCHEMA_LEGACY,
-    TEMPLATE_ENTITY_AVAILABILITY_SCHEMA,
     TEMPLATE_ENTITY_AVAILABILITY_SCHEMA_LEGACY,
-    TEMPLATE_ENTITY_ICON_SCHEMA,
     TemplateEntity,
+    make_template_entity_common_modern_attributes_schema,
     rewrite_common_legacy_to_modern_conf,
 )
 
@@ -60,6 +58,8 @@ CONF_FAN_SPEED_LIST = "fan_speeds"
 CONF_FAN_SPEED = "fan_speed"
 CONF_FAN_SPEED_TEMPLATE = "fan_speed_template"
 
+DEFAULT_NAME = "Template Vacuum"
+
 ENTITY_ID_FORMAT = VACUUM_DOMAIN + ".{}"
 _VALID_STATES = [
     VacuumActivity.CLEANING,
@@ -80,13 +80,9 @@ VACUUM_SCHEMA = vol.All(
     vol.Schema(
         {
             vol.Optional(CONF_BATTERY_LEVEL): cv.template,
-            vol.Optional(CONF_ENTITY_ID): cv.entity_ids,
             vol.Optional(CONF_FAN_SPEED_LIST, default=[]): cv.ensure_list,
             vol.Optional(CONF_FAN_SPEED): cv.template,
-            vol.Optional(CONF_NAME): cv.template,
-            vol.Optional(CONF_PICTURE): cv.template,
             vol.Optional(CONF_STATE): cv.template,
-            vol.Optional(CONF_UNIQUE_ID): cv.string,
             vol.Optional(SERVICE_CLEAN_SPOT): cv.SCRIPT_SCHEMA,
             vol.Optional(SERVICE_LOCATE): cv.SCRIPT_SCHEMA,
             vol.Optional(SERVICE_PAUSE): cv.SCRIPT_SCHEMA,
@@ -95,10 +91,7 @@ VACUUM_SCHEMA = vol.All(
             vol.Required(SERVICE_START): cv.SCRIPT_SCHEMA,
             vol.Optional(SERVICE_STOP): cv.SCRIPT_SCHEMA,
         }
-    )
-    .extend(TEMPLATE_ENTITY_ATTRIBUTES_SCHEMA.schema)
-    .extend(TEMPLATE_ENTITY_AVAILABILITY_SCHEMA.schema)
-    .extend(TEMPLATE_ENTITY_ICON_SCHEMA.schema),
+    ).extend(make_template_entity_common_modern_attributes_schema(DEFAULT_NAME).schema)
 )
 
 LEGACY_VACUUM_SCHEMA = vol.All(
@@ -353,9 +346,7 @@ class TemplateVacuum(TemplateEntity, AbstractTemplateVacuum):
         unique_id,
     ) -> None:
         """Initialize the vacuum."""
-        TemplateEntity.__init__(
-            self, hass, config=config, fallback_name=None, unique_id=unique_id
-        )
+        TemplateEntity.__init__(self, hass, config=config, unique_id=unique_id)
         AbstractTemplateVacuum.__init__(self, config)
         if (object_id := config.get(CONF_OBJECT_ID)) is not None:
             self.entity_id = async_generate_entity_id(

homeassistant/components/template/weather.py

@@ -32,7 +32,6 @@ from homeassistant.components.weather import (
     WeatherEntityFeature,
 )
 from homeassistant.const import (
-    CONF_NAME,
     CONF_TEMPERATURE_UNIT,
     CONF_UNIQUE_ID,
     STATE_UNAVAILABLE,
@@ -53,7 +52,11 @@ from homeassistant.util.unit_conversion import (
 )
 
 from .coordinator import TriggerUpdateCoordinator
-from .template_entity import TemplateEntity, rewrite_common_legacy_to_modern_conf
+from .template_entity import (
+    TemplateEntity,
+    make_template_entity_common_modern_schema,
+    rewrite_common_legacy_to_modern_conf,
+)
 from .trigger_entity import TriggerEntity
 
 CHECK_FORECAST_KEYS = (
@@ -104,33 +107,33 @@ CONF_CLOUD_COVERAGE_TEMPLATE = "cloud_coverage_template"
 CONF_DEW_POINT_TEMPLATE = "dew_point_template"
 CONF_APPARENT_TEMPERATURE_TEMPLATE = "apparent_temperature_template"
 
+DEFAULT_NAME = "Template Weather"
+
 WEATHER_SCHEMA = vol.Schema(
     {
-        vol.Required(CONF_NAME): cv.template,
-        vol.Required(CONF_CONDITION_TEMPLATE): cv.template,
-        vol.Required(CONF_TEMPERATURE_TEMPLATE): cv.template,
-        vol.Required(CONF_HUMIDITY_TEMPLATE): cv.template,
+        vol.Optional(CONF_APPARENT_TEMPERATURE_TEMPLATE): cv.template,
         vol.Optional(CONF_ATTRIBUTION_TEMPLATE): cv.template,
-        vol.Optional(CONF_PRESSURE_TEMPLATE): cv.template,
-        vol.Optional(CONF_WIND_SPEED_TEMPLATE): cv.template,
-        vol.Optional(CONF_WIND_BEARING_TEMPLATE): cv.template,
-        vol.Optional(CONF_OZONE_TEMPLATE): cv.template,
-        vol.Optional(CONF_VISIBILITY_TEMPLATE): cv.template,
+        vol.Optional(CONF_CLOUD_COVERAGE_TEMPLATE): cv.template,
+        vol.Required(CONF_CONDITION_TEMPLATE): cv.template,
+        vol.Optional(CONF_DEW_POINT_TEMPLATE): cv.template,
+        vol.Required(CONF_HUMIDITY_TEMPLATE): cv.template,
         vol.Optional(CONF_FORECAST_DAILY_TEMPLATE): cv.template,
         vol.Optional(CONF_FORECAST_HOURLY_TEMPLATE): cv.template,
         vol.Optional(CONF_FORECAST_TWICE_DAILY_TEMPLATE): cv.template,
-        vol.Optional(CONF_UNIQUE_ID): cv.string,
-        vol.Optional(CONF_TEMPERATURE_UNIT): vol.In(TemperatureConverter.VALID_UNITS),
-        vol.Optional(CONF_PRESSURE_UNIT): vol.In(PressureConverter.VALID_UNITS),
-        vol.Optional(CONF_WIND_SPEED_UNIT): vol.In(SpeedConverter.VALID_UNITS),
-        vol.Optional(CONF_VISIBILITY_UNIT): vol.In(DistanceConverter.VALID_UNITS),
+        vol.Optional(CONF_OZONE_TEMPLATE): cv.template,
         vol.Optional(CONF_PRECIPITATION_UNIT): vol.In(DistanceConverter.VALID_UNITS),
+        vol.Optional(CONF_PRESSURE_TEMPLATE): cv.template,
+        vol.Optional(CONF_PRESSURE_UNIT): vol.In(PressureConverter.VALID_UNITS),
+        vol.Required(CONF_TEMPERATURE_TEMPLATE): cv.template,
+        vol.Optional(CONF_TEMPERATURE_UNIT): vol.In(TemperatureConverter.VALID_UNITS),
+        vol.Optional(CONF_VISIBILITY_TEMPLATE): cv.template,
+        vol.Optional(CONF_VISIBILITY_UNIT): vol.In(DistanceConverter.VALID_UNITS),
+        vol.Optional(CONF_WIND_BEARING_TEMPLATE): cv.template,
         vol.Optional(CONF_WIND_GUST_SPEED_TEMPLATE): cv.template,
-        vol.Optional(CONF_CLOUD_COVERAGE_TEMPLATE): cv.template,
-        vol.Optional(CONF_DEW_POINT_TEMPLATE): cv.template,
-        vol.Optional(CONF_APPARENT_TEMPERATURE_TEMPLATE): cv.template,
+        vol.Optional(CONF_WIND_SPEED_TEMPLATE): cv.template,
+        vol.Optional(CONF_WIND_SPEED_UNIT): vol.In(SpeedConverter.VALID_UNITS),
     }
-)
+).extend(make_template_entity_common_modern_schema(DEFAULT_NAME).schema)
 
 PLATFORM_SCHEMA = WEATHER_PLATFORM_SCHEMA.extend(WEATHER_SCHEMA.schema)
 

homeassistant/components/tesla_fleet/config_flow.py

@@ -4,14 +4,30 @@ from __future__ import annotations
 
 from collections.abc import Mapping
 import logging
-from typing import Any
+import re
+from typing import Any, cast
 
 import jwt
+from tesla_fleet_api import TeslaFleetApi
+from tesla_fleet_api.const import SERVERS
+from tesla_fleet_api.exceptions import (
+    InvalidResponse,
+    PreconditionFailed,
+    TeslaFleetError,
+)
+import voluptuous as vol
 
 from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlowResult
 from homeassistant.helpers import config_entry_oauth2_flow
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.selector import (
+    QrCodeSelector,
+    QrCodeSelectorConfig,
+    QrErrorCorrectionLevel,
+)
 
-from .const import DOMAIN, LOGGER
+from .const import CONF_DOMAIN, DOMAIN, LOGGER
+from .oauth import TeslaUserImplementation
 
 
 class OAuth2FlowHandler(
@@ -21,36 +37,173 @@ class OAuth2FlowHandler(
 
     DOMAIN = DOMAIN
 
+    def __init__(self) -> None:
+        """Initialize config flow."""
+        super().__init__()
+        self.domain: str | None = None
+        self.registration_status: dict[str, bool] = {}
+        self.tesla_apis: dict[str, TeslaFleetApi] = {}
+        self.failed_regions: list[str] = []
+        self.data: dict[str, Any] = {}
+        self.uid: str | None = None
+        self.api: TeslaFleetApi | None = None
+
     @property
     def logger(self) -> logging.Logger:
         """Return logger."""
         return LOGGER
 
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle a flow start."""
-        return await super().async_step_user()
-
     async def async_oauth_create_entry(
         self,
         data: dict[str, Any],
     ) -> ConfigFlowResult:
-        """Handle the initial step."""
-
+        """Handle OAuth completion and proceed to domain registration."""
         token = jwt.decode(
             data["token"]["access_token"], options={"verify_signature": False}
         )
-        uid = token["sub"]
 
-        await self.async_set_unique_id(uid)
+        self.data = data
+        self.uid = token["sub"]
+        server = SERVERS[token["ou_code"].lower()]
+
+        await self.async_set_unique_id(self.uid)
         if self.source == SOURCE_REAUTH:
             self._abort_if_unique_id_mismatch(reason="reauth_account_mismatch")
             return self.async_update_reload_and_abort(
                 self._get_reauth_entry(), data=data
             )
         self._abort_if_unique_id_configured()
-        return self.async_create_entry(title=uid, data=data)
+
+        # OAuth done, setup a Partner API connection
+        implementation = cast(TeslaUserImplementation, self.flow_impl)
+
+        session = async_get_clientsession(self.hass)
+        self.api = TeslaFleetApi(
+            session=session,
+            server=server,
+            partner_scope=True,
+            charging_scope=False,
+            energy_scope=False,
+            user_scope=False,
+            vehicle_scope=False,
+        )
+        await self.api.get_private_key(self.hass.config.path("tesla_fleet.key"))
+        await self.api.partner_login(
+            implementation.client_id, implementation.client_secret
+        )
+
+        return await self.async_step_domain_input()
+
+    async def async_step_domain_input(
+        self,
+        user_input: dict[str, Any] | None = None,
+        errors: dict[str, str] | None = None,
+    ) -> ConfigFlowResult:
+        """Handle domain input step."""
+
+        errors = errors or {}
+
+        if user_input is not None:
+            domain = user_input[CONF_DOMAIN].strip().lower()
+
+            # Validate domain format
+            if not self._is_valid_domain(domain):
+                errors[CONF_DOMAIN] = "invalid_domain"
+            else:
+                self.domain = domain
+                return await self.async_step_domain_registration()
+
+        return self.async_show_form(
+            step_id="domain_input",
+            description_placeholders={
+                "dashboard": "https://developer.tesla.com/en_AU/dashboard/"
+            },
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_DOMAIN): str,
+                }
+            ),
+            errors=errors,
+        )
+
+    async def async_step_domain_registration(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle domain registration for both regions."""
+
+        assert self.api
+        assert self.api.private_key
+        assert self.domain
+
+        errors = {}
+        description_placeholders = {
+            "public_key_url": f"https://{self.domain}/.well-known/appspecific/com.tesla.3p.public-key.pem",
+            "pem": self.api.public_pem,
+        }
+
+        try:
+            register_response = await self.api.partner.register(self.domain)
+        except PreconditionFailed:
+            return await self.async_step_domain_input(
+                errors={CONF_DOMAIN: "precondition_failed"}
+            )
+        except InvalidResponse:
+            errors["base"] = "invalid_response"
+        except TeslaFleetError as e:
+            errors["base"] = "unknown_error"
+            description_placeholders["error"] = e.message
+        else:
+            # Get public key from response
+            registered_public_key = register_response.get("response", {}).get(
+                "public_key"
+            )
+
+            if not registered_public_key:
+                errors["base"] = "public_key_not_found"
+            elif (
+                registered_public_key.lower()
+                != self.api.public_uncompressed_point.lower()
+            ):
+                errors["base"] = "public_key_mismatch"
+            else:
+                return await self.async_step_registration_complete()
+
+        return self.async_show_form(
+            step_id="domain_registration",
+            description_placeholders=description_placeholders,
+            errors=errors,
+        )
+
+    async def async_step_registration_complete(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Show completion and virtual key installation."""
+        if user_input is not None and self.uid and self.data:
+            return self.async_create_entry(title=self.uid, data=self.data)
+
+        if not self.domain:
+            return await self.async_step_domain_input()
+
+        virtual_key_url = f"https://www.tesla.com/_ak/{self.domain}"
+        data_schema = vol.Schema({}).extend(
+            {
+                vol.Optional("qr_code"): QrCodeSelector(
+                    config=QrCodeSelectorConfig(
+                        data=virtual_key_url,
+                        scale=6,
+                        error_correction_level=QrErrorCorrectionLevel.QUARTILE,
+                    )
+                ),
+            }
+        )
+
+        return self.async_show_form(
+            step_id="registration_complete",
+            data_schema=data_schema,
+            description_placeholders={
+                "virtual_key_url": virtual_key_url,
+            },
+        )
 
     async def async_step_reauth(
         self, entry_data: Mapping[str, Any]
@@ -67,4 +220,11 @@ class OAuth2FlowHandler(
                 step_id="reauth_confirm",
                 description_placeholders={"name": "Tesla Fleet"},
             )
-        return await self.async_step_user()
+        # For reauth, skip domain registration and go straight to OAuth
+        return await super().async_step_user()
+
+    def _is_valid_domain(self, domain: str) -> bool:
+        """Validate domain format."""
+        # Basic domain validation regex
+        domain_pattern = re.compile(r"^(?:[a-zA-Z0-9]+\.)+[a-zA-Z0-9-]+$")
+        return bool(domain_pattern.match(domain))

homeassistant/components/tesla_fleet/const.py

@@ -9,6 +9,7 @@ from tesla_fleet_api.const import Scope
 
 DOMAIN = "tesla_fleet"
 
+CONF_DOMAIN = "domain"
 CONF_REFRESH_TOKEN = "refresh_token"
 
 LOGGER = logging.getLogger(__package__)

homeassistant/components/tesla_fleet/manifest.json

@@ -7,5 +7,5 @@
   "documentation": "https://www.home-assistant.io/integrations/tesla_fleet",
   "iot_class": "cloud_polling",
   "loggers": ["tesla-fleet-api"],
-  "requirements": ["tesla-fleet-api==1.1.3"]
+  "requirements": ["tesla-fleet-api==1.2.0"]
 }

homeassistant/components/tesla_fleet/strings.json

@@ -4,6 +4,7 @@
       "authorize_url_timeout": "[%key:common::config_flow::abort::oauth2_authorize_url_timeout%]",
       "missing_configuration": "[%key:common::config_flow::abort::oauth2_missing_configuration%]",
       "already_configured": "Configuration updated for profile.",
+      "already_in_progress": "[%key:common::config_flow::abort::already_in_progress%]",
       "no_url_available": "[%key:common::config_flow::abort::oauth2_no_url_available%]",
       "oauth_error": "[%key:common::config_flow::abort::oauth2_error%]",
       "oauth_timeout": "[%key:common::config_flow::abort::oauth2_timeout%]",
@@ -13,7 +14,12 @@
       "reauth_account_mismatch": "The reauthentication account does not match the original account"
     },
     "error": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_account%]"
+      "invalid_domain": "Invalid domain format. Please enter a valid domain name.",
+      "public_key_not_found": "Public key not found.",
+      "public_key_mismatch": "The public key hosted at your domain does not match the expected key. Please ensure the correct public key is hosted at the specified location.",
+      "precondition_failed": "The domain does not match the application's allowed origins.",
+      "invalid_response": "The registration was rejected by Tesla",
+      "unknown_error": "An unknown error occurred: {error}"
     },
     "step": {
       "pick_implementation": {
@@ -25,6 +31,21 @@
           "implementation": "[%key:common::config_flow::description::implementation%]"
         }
       },
+      "domain_input": {
+        "title": "Tesla Fleet domain registration",
+        "description": "Enter the domain that will host your public key. This is typically the domain of the origin you specified during registration at {dashboard}.",
+        "data": {
+          "domain": "Domain"
+        }
+      },
+      "domain_registration": {
+        "title": "Registering public key",
+        "description": "You must host the public key at:\n\n{public_key_url}\n\n```\n{pem}\n```"
+      },
+      "registration_complete": {
+        "title": "Command signing",
+        "description": "To enable command signing, you must open the Tesla app, select your vehicle, and then visit the following URL to set up a virtual key. You must repeat this process for each vehicle.\n\n{virtual_key_url}"
+      },
       "reauth_confirm": {
         "title": "[%key:common::config_flow::title::reauth%]",
         "description": "The {name} integration needs to re-authenticate your account"