Allow to wait for MQTT subscription

.github/workflows/ci.yaml

@@ -37,7 +37,7 @@ on:
         type: boolean
 
 env:
-  CACHE_VERSION: 9
+  CACHE_VERSION: 8
   UV_CACHE_VERSION: 1
   MYPY_CACHE_VERSION: 1
   HA_SHORT_VERSION: "2025.11"
@@ -525,7 +525,7 @@ jobs:
           . venv/bin/activate
           python --version
           pip install "$(grep '^uv' < requirements.txt)"
-          uv pip install -U "pip>=25.2"
+          uv pip install -U "pip>=21.3.1" setuptools wheel
           uv pip install -r requirements.txt
           python -m script.gen_requirements_all ci
           uv pip install -r requirements_all_pytest.txt -r requirements_test.txt
@@ -741,7 +741,7 @@ jobs:
       - name: Generate partial mypy restore key
         id: generate-mypy-key
         run: |
-          mypy_version=$(cat requirements_test.txt | grep 'mypy.*=' | cut -d '=' -f 3)
+          mypy_version=$(cat requirements_test.txt | grep mypy | cut -d '=' -f 3)
           echo "version=$mypy_version" >> $GITHUB_OUTPUT
           echo "key=mypy-${{ env.MYPY_CACHE_VERSION }}-$mypy_version-${{
             env.HA_SHORT_VERSION }}-$(date -u '+%Y-%m-%dT%H:%M:%s')" >> $GITHUB_OUTPUT

.github/workflows/codeql.yml

@@ -24,11 +24,11 @@ jobs:
         uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@e296a935590eb16afc0c0108289f68c87e2a89a5 # v4.30.7
+        uses: github/codeql-action/init@64d10c13136e1c5bce3e5fbde8d4906eeaafc885 # v3.30.6
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@e296a935590eb16afc0c0108289f68c87e2a89a5 # v4.30.7
+        uses: github/codeql-action/analyze@64d10c13136e1c5bce3e5fbde8d4906eeaafc885 # v3.30.6
         with:
           category: "/language:python"

.strict-typing

@@ -221,7 +221,6 @@ homeassistant.components.generic_thermostat.*
 homeassistant.components.geo_location.*
 homeassistant.components.geocaching.*
 homeassistant.components.gios.*
-homeassistant.components.github.*
 homeassistant.components.glances.*
 homeassistant.components.go2rtc.*
 homeassistant.components.goalzero.*

CODEOWNERS

@@ -762,8 +762,8 @@ build.json @home-assistant/supervisor
 /homeassistant/components/intent/ @home-assistant/core @synesthesiam @arturpragacz
 /tests/components/intent/ @home-assistant/core @synesthesiam @arturpragacz
 /homeassistant/components/intesishome/ @jnimmo
-/homeassistant/components/iometer/ @jukrebs
-/tests/components/iometer/ @jukrebs
+/homeassistant/components/iometer/ @MaestroOnICe
+/tests/components/iometer/ @MaestroOnICe
 /homeassistant/components/ios/ @robbiet480
 /tests/components/ios/ @robbiet480
 /homeassistant/components/iotawatt/ @gtdiehl @jyavenard
@@ -1065,8 +1065,8 @@ build.json @home-assistant/supervisor
 /homeassistant/components/nilu/ @hfurubotten
 /homeassistant/components/nina/ @DeerMaximum
 /tests/components/nina/ @DeerMaximum
-/homeassistant/components/nintendo_parental_controls/ @pantherale0
-/tests/components/nintendo_parental_controls/ @pantherale0
+/homeassistant/components/nintendo_parental/ @pantherale0
+/tests/components/nintendo_parental/ @pantherale0
 /homeassistant/components/nissan_leaf/ @filcole
 /homeassistant/components/noaa_tides/ @jdelaney72
 /homeassistant/components/nobo_hub/ @echoromeo @oyvindwe
@@ -1413,8 +1413,8 @@ build.json @home-assistant/supervisor
 /tests/components/sfr_box/ @epenet
 /homeassistant/components/sftp_storage/ @maretodoric
 /tests/components/sftp_storage/ @maretodoric
-/homeassistant/components/sharkiq/ @JeffResc @funkybunch @TheOneOgre
-/tests/components/sharkiq/ @JeffResc @funkybunch @TheOneOgre
+/homeassistant/components/sharkiq/ @JeffResc @funkybunch
+/tests/components/sharkiq/ @JeffResc @funkybunch
 /homeassistant/components/shell_command/ @home-assistant/core
 /tests/components/shell_command/ @home-assistant/core
 /homeassistant/components/shelly/ @bieniu @thecode @chemelli74 @bdraco
@@ -1479,8 +1479,8 @@ build.json @home-assistant/supervisor
 /tests/components/snoo/ @Lash-L
 /homeassistant/components/snooz/ @AustinBrunkhorst
 /tests/components/snooz/ @AustinBrunkhorst
-/homeassistant/components/solaredge/ @frenck @bdraco @tronikos
-/tests/components/solaredge/ @frenck @bdraco @tronikos
+/homeassistant/components/solaredge/ @frenck @bdraco
+/tests/components/solaredge/ @frenck @bdraco
 /homeassistant/components/solaredge_local/ @drobtravels @scheric
 /homeassistant/components/solarlog/ @Ernst79 @dontinelli
 /tests/components/solarlog/ @Ernst79 @dontinelli

Dockerfile.dev

@@ -34,11 +34,9 @@ WORKDIR /usr/src
 
 COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
 
+RUN uv python install 3.13.2
+
 USER vscode
-
-ENV UV_PYTHON=3.13.2
-RUN uv python install
-
 ENV VIRTUAL_ENV="/home/vscode/.local/ha-venv"
 RUN uv venv $VIRTUAL_ENV
 ENV PATH="$VIRTUAL_ENV/bin:$PATH"

homeassistant/components/accuweather/const.py

@@ -71,4 +71,4 @@ POLLEN_CATEGORY_MAP = {
 }
 UPDATE_INTERVAL_OBSERVATION = timedelta(minutes=10)
 UPDATE_INTERVAL_DAILY_FORECAST = timedelta(hours=6)
-UPDATE_INTERVAL_HOURLY_FORECAST = timedelta(minutes=30)
+UPDATE_INTERVAL_HOURLY_FORECAST = timedelta(hours=30)

homeassistant/components/accuweather/icons.json

@@ -1,9 +1,6 @@
 {
   "entity": {
     "sensor": {
-      "air_quality": {
-        "default": "mdi:air-filter"
-      },
       "cloud_ceiling": {
         "default": "mdi:weather-fog"
       },
@@ -37,6 +34,9 @@
       "thunderstorm_probability_night": {
         "default": "mdi:weather-lightning"
       },
+      "translation_key": {
+        "default": "mdi:air-filter"
+      },
       "tree_pollen": {
         "default": "mdi:tree-outline"
       },

homeassistant/components/airgradient/update.py

@@ -1,9 +1,7 @@
 """Airgradient Update platform."""
 
 from datetime import timedelta
-import logging
 
-from airgradient import AirGradientConnectionError
 from propcache.api import cached_property
 
 from homeassistant.components.update import UpdateDeviceClass, UpdateEntity
@@ -15,7 +13,6 @@ from .entity import AirGradientEntity
 
 PARALLEL_UPDATES = 1
 SCAN_INTERVAL = timedelta(hours=1)
-_LOGGER = logging.getLogger(__name__)
 
 
 async def async_setup_entry(
@@ -34,7 +31,6 @@ class AirGradientUpdate(AirGradientEntity, UpdateEntity):
     """Representation of Airgradient Update."""
 
     _attr_device_class = UpdateDeviceClass.FIRMWARE
-    _server_unreachable_logged = False
 
     def __init__(self, coordinator: AirGradientCoordinator) -> None:
         """Initialize the entity."""
@@ -51,27 +47,10 @@ class AirGradientUpdate(AirGradientEntity, UpdateEntity):
         """Return the installed version of the entity."""
         return self.coordinator.data.measures.firmware_version
 
-    @property
-    def available(self) -> bool:
-        """Return if entity is available."""
-        return super().available and self._attr_available
-
     async def async_update(self) -> None:
         """Update the entity."""
-        try:
-            self._attr_latest_version = (
-                await self.coordinator.client.get_latest_firmware_version(
-                    self.coordinator.serial_number
-                )
+        self._attr_latest_version = (
+            await self.coordinator.client.get_latest_firmware_version(
+                self.coordinator.serial_number
             )
-        except AirGradientConnectionError:
-            self._attr_latest_version = None
-            self._attr_available = False
-            if not self._server_unreachable_logged:
-                _LOGGER.error(
-                    "Unable to connect to AirGradient server to check for updates"
-                )
-                self._server_unreachable_logged = True
-        else:
-            self._server_unreachable_logged = False
-            self._attr_available = True
+        )

homeassistant/components/airthings_ble/sensor.py

@@ -16,12 +16,10 @@ from homeassistant.components.sensor import (
 from homeassistant.const import (
     CONCENTRATION_PARTS_PER_BILLION,
     CONCENTRATION_PARTS_PER_MILLION,
-    LIGHT_LUX,
     PERCENTAGE,
     EntityCategory,
     Platform,
     UnitOfPressure,
-    UnitOfSoundPressure,
     UnitOfTemperature,
 )
 from homeassistant.core import HomeAssistant, callback
@@ -114,21 +112,6 @@ SENSORS_MAPPING_TEMPLATE: dict[str, SensorEntityDescription] = {
         state_class=SensorStateClass.MEASUREMENT,
         suggested_display_precision=0,
     ),
-    "lux": SensorEntityDescription(
-        key="lux",
-        device_class=SensorDeviceClass.ILLUMINANCE,
-        native_unit_of_measurement=LIGHT_LUX,
-        state_class=SensorStateClass.MEASUREMENT,
-        suggested_display_precision=0,
-    ),
-    "noise": SensorEntityDescription(
-        key="noise",
-        translation_key="ambient_noise",
-        device_class=SensorDeviceClass.SOUND_PRESSURE,
-        native_unit_of_measurement=UnitOfSoundPressure.WEIGHTED_DECIBEL_A,
-        state_class=SensorStateClass.MEASUREMENT,
-        suggested_display_precision=0,
-    ),
 }
 
 PARALLEL_UPDATES = 0

homeassistant/components/airthings_ble/strings.json

@@ -41,9 +41,6 @@
       },
       "illuminance": {
         "name": "[%key:component::sensor::entity_component::illuminance::name%]"
-      },
-      "ambient_noise": {
-        "name": "Ambient noise"
       }
     }
   }

homeassistant/components/alarm_control_panel/__init__.py

@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
+import asyncio
 from datetime import timedelta
 import logging
-from typing import Any, Final, final
+from typing import TYPE_CHECKING, Any, Final, final
 
 from propcache.api import cached_property
 import voluptuous as vol
@@ -27,6 +28,8 @@ from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.config_validation import make_entity_service_schema
 from homeassistant.helpers.entity import Entity, EntityDescription
 from homeassistant.helpers.entity_component import EntityComponent
+from homeassistant.helpers.entity_platform import EntityPlatform
+from homeassistant.helpers.frame import ReportBehavior, report_usage
 from homeassistant.helpers.typing import ConfigType
 from homeassistant.util.hass_dict import HassKey
 
@@ -146,11 +149,68 @@ class AlarmControlPanelEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_A
     )
     _alarm_control_panel_option_default_code: str | None = None
 
+    __alarm_legacy_state: bool = False
+
+    def __init_subclass__(cls, **kwargs: Any) -> None:
+        """Post initialisation processing."""
+        super().__init_subclass__(**kwargs)
+        if any(method in cls.__dict__ for method in ("_attr_state", "state")):
+            # Integrations should use the 'alarm_state' property instead of
+            # setting the state directly.
+            cls.__alarm_legacy_state = True
+
+    def __setattr__(self, name: str, value: Any, /) -> None:
+        """Set attribute.
+
+        Deprecation warning if setting '_attr_state' directly
+        unless already reported.
+        """
+        if name == "_attr_state":
+            self._report_deprecated_alarm_state_handling()
+        return super().__setattr__(name, value)
+
+    @callback
+    def add_to_platform_start(
+        self,
+        hass: HomeAssistant,
+        platform: EntityPlatform,
+        parallel_updates: asyncio.Semaphore | None,
+    ) -> None:
+        """Start adding an entity to a platform."""
+        super().add_to_platform_start(hass, platform, parallel_updates)
+        if self.__alarm_legacy_state:
+            self._report_deprecated_alarm_state_handling()
+
+    @callback
+    def _report_deprecated_alarm_state_handling(self) -> None:
+        """Report on deprecated handling of alarm state.
+
+        Integrations should implement alarm_state instead of using state directly.
+        """
+        report_usage(
+            "is setting state directly."
+            f" Entity {self.entity_id} ({type(self)}) should implement the 'alarm_state'"
+            " property and return its state using the AlarmControlPanelState enum",
+            core_integration_behavior=ReportBehavior.ERROR,
+            custom_integration_behavior=ReportBehavior.LOG,
+            breaks_in_ha_version="2025.11",
+            integration_domain=self.platform.platform_name if self.platform else None,
+            exclude_integrations={DOMAIN},
+        )
+
     @final
     @property
     def state(self) -> str | None:
         """Return the current state."""
-        return self.alarm_state
+        if (alarm_state := self.alarm_state) is not None:
+            return alarm_state
+        if self._attr_state is not None:
+            # Backwards compatibility for integrations that set state directly
+            # Should be removed in 2025.11
+            if TYPE_CHECKING:
+                assert isinstance(self._attr_state, str)
+            return self._attr_state
+        return None
 
     @cached_property
     def alarm_state(self) -> AlarmControlPanelState | None:

homeassistant/components/alexa/capabilities.py

@@ -1472,10 +1472,10 @@ class AlexaModeController(AlexaCapability):
             # Return state instead of position when using ModeController.
             mode = self.entity.state
             if mode in (
-                cover.CoverState.OPEN,
-                cover.CoverState.OPENING,
-                cover.CoverState.CLOSED,
-                cover.CoverState.CLOSING,
+                cover.STATE_OPEN,
+                cover.STATE_OPENING,
+                cover.STATE_CLOSED,
+                cover.STATE_CLOSING,
                 STATE_UNKNOWN,
             ):
                 return f"{cover.ATTR_POSITION}.{mode}"
@@ -1594,11 +1594,11 @@ class AlexaModeController(AlexaCapability):
                 ["Position", AlexaGlobalCatalog.SETTING_OPENING], False
             )
             self._resource.add_mode(
-                f"{cover.ATTR_POSITION}.{cover.CoverState.OPEN}",
+                f"{cover.ATTR_POSITION}.{cover.STATE_OPEN}",
                 [AlexaGlobalCatalog.VALUE_OPEN],
             )
             self._resource.add_mode(
-                f"{cover.ATTR_POSITION}.{cover.CoverState.CLOSED}",
+                f"{cover.ATTR_POSITION}.{cover.STATE_CLOSED}",
                 [AlexaGlobalCatalog.VALUE_CLOSE],
             )
             self._resource.add_mode(
@@ -1651,22 +1651,22 @@ class AlexaModeController(AlexaCapability):
                 raise_labels.append(AlexaSemantics.ACTION_OPEN)
                 self._semantics.add_states_to_value(
                     [AlexaSemantics.STATES_CLOSED],
-                    f"{cover.ATTR_POSITION}.{cover.CoverState.CLOSED}",
+                    f"{cover.ATTR_POSITION}.{cover.STATE_CLOSED}",
                 )
                 self._semantics.add_states_to_value(
                     [AlexaSemantics.STATES_OPEN],
-                    f"{cover.ATTR_POSITION}.{cover.CoverState.OPEN}",
+                    f"{cover.ATTR_POSITION}.{cover.STATE_OPEN}",
                 )
 
             self._semantics.add_action_to_directive(
                 lower_labels,
                 "SetMode",
-                {"mode": f"{cover.ATTR_POSITION}.{cover.CoverState.CLOSED}"},
+                {"mode": f"{cover.ATTR_POSITION}.{cover.STATE_CLOSED}"},
             )
             self._semantics.add_action_to_directive(
                 raise_labels,
                 "SetMode",
-                {"mode": f"{cover.ATTR_POSITION}.{cover.CoverState.OPEN}"},
+                {"mode": f"{cover.ATTR_POSITION}.{cover.STATE_OPEN}"},
             )
 
             return self._semantics.serialize_semantics()

homeassistant/components/alexa/handlers.py

@@ -1261,9 +1261,9 @@ async def async_api_set_mode(
     elif instance == f"{cover.DOMAIN}.{cover.ATTR_POSITION}":
         position = mode.split(".")[1]
 
-        if position == cover.CoverState.CLOSED:
+        if position == cover.STATE_CLOSED:
             service = cover.SERVICE_CLOSE_COVER
-        elif position == cover.CoverState.OPEN:
+        elif position == cover.STATE_OPEN:
             service = cover.SERVICE_OPEN_COVER
         elif position == "custom":
             service = cover.SERVICE_STOP_COVER

homeassistant/components/alexa_devices/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["aioamazondevices"],
   "quality_scale": "platinum",
-  "requirements": ["aioamazondevices==6.4.0"]
+  "requirements": ["aioamazondevices==6.2.9"]
 }

homeassistant/components/anthropic/config_flow.py

@@ -4,15 +4,12 @@ from __future__ import annotations
 
 from collections.abc import Mapping
 from functools import partial
-import json
 import logging
 from typing import Any, cast
 
 import anthropic
 import voluptuous as vol
-from voluptuous_openapi import convert
 
-from homeassistant.components.zone import ENTITY_ID_HOME
 from homeassistant.config_entries import (
     ConfigEntry,
     ConfigEntryState,
@@ -21,13 +18,7 @@ from homeassistant.config_entries import (
     ConfigSubentryFlow,
     SubentryFlowResult,
 )
-from homeassistant.const import (
-    ATTR_LATITUDE,
-    ATTR_LONGITUDE,
-    CONF_API_KEY,
-    CONF_LLM_HASS_API,
-    CONF_NAME,
-)
+from homeassistant.const import CONF_API_KEY, CONF_LLM_HASS_API, CONF_NAME
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import llm
 from homeassistant.helpers.selector import (
@@ -46,23 +37,12 @@ from .const import (
     CONF_RECOMMENDED,
     CONF_TEMPERATURE,
     CONF_THINKING_BUDGET,
-    CONF_WEB_SEARCH,
-    CONF_WEB_SEARCH_CITY,
-    CONF_WEB_SEARCH_COUNTRY,
-    CONF_WEB_SEARCH_MAX_USES,
-    CONF_WEB_SEARCH_REGION,
-    CONF_WEB_SEARCH_TIMEZONE,
-    CONF_WEB_SEARCH_USER_LOCATION,
     DEFAULT_CONVERSATION_NAME,
     DOMAIN,
     RECOMMENDED_CHAT_MODEL,
     RECOMMENDED_MAX_TOKENS,
     RECOMMENDED_TEMPERATURE,
     RECOMMENDED_THINKING_BUDGET,
-    RECOMMENDED_WEB_SEARCH,
-    RECOMMENDED_WEB_SEARCH_MAX_USES,
-    RECOMMENDED_WEB_SEARCH_USER_LOCATION,
-    WEB_SEARCH_UNSUPPORTED_MODELS,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -188,14 +168,6 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
                 CONF_THINKING_BUDGET, RECOMMENDED_THINKING_BUDGET
             ) >= user_input.get(CONF_MAX_TOKENS, RECOMMENDED_MAX_TOKENS):
                 errors[CONF_THINKING_BUDGET] = "thinking_budget_too_large"
-            if user_input.get(CONF_WEB_SEARCH, RECOMMENDED_WEB_SEARCH):
-                model = user_input.get(CONF_CHAT_MODEL, RECOMMENDED_CHAT_MODEL)
-                if model.startswith(tuple(WEB_SEARCH_UNSUPPORTED_MODELS)):
-                    errors[CONF_WEB_SEARCH] = "web_search_unsupported_model"
-                elif user_input.get(
-                    CONF_WEB_SEARCH_USER_LOCATION, RECOMMENDED_WEB_SEARCH_USER_LOCATION
-                ):
-                    user_input.update(await self._get_location_data())
 
             if not errors:
                 if self._is_new:
@@ -243,68 +215,6 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
             errors=errors or None,
         )
 
-    async def _get_location_data(self) -> dict[str, str]:
-        """Get approximate location data of the user."""
-        location_data: dict[str, str] = {}
-        zone_home = self.hass.states.get(ENTITY_ID_HOME)
-        if zone_home is not None:
-            client = await self.hass.async_add_executor_job(
-                partial(
-                    anthropic.AsyncAnthropic,
-                    api_key=self._get_entry().data[CONF_API_KEY],
-                )
-            )
-            location_schema = vol.Schema(
-                {
-                    vol.Optional(
-                        CONF_WEB_SEARCH_CITY,
-                        description="Free text input for the city, e.g. `San Francisco`",
-                    ): str,
-                    vol.Optional(
-                        CONF_WEB_SEARCH_REGION,
-                        description="Free text input for the region, e.g. `California`",
-                    ): str,
-                }
-            )
-            response = await client.messages.create(
-                model=RECOMMENDED_CHAT_MODEL,
-                messages=[
-                    {
-                        "role": "user",
-                        "content": "Where are the following coordinates located: "
-                        f"({zone_home.attributes[ATTR_LATITUDE]},"
-                        f" {zone_home.attributes[ATTR_LONGITUDE]})? Please respond "
-                        "only with a JSON object using the following schema:\n"
-                        f"{convert(location_schema)}",
-                    },
-                    {
-                        "role": "assistant",
-                        "content": "{",  # hints the model to skip any preamble
-                    },
-                ],
-                max_tokens=RECOMMENDED_MAX_TOKENS,
-            )
-            _LOGGER.debug("Model response: %s", response.content)
-            location_data = location_schema(
-                json.loads(
-                    "{"
-                    + "".join(
-                        block.text
-                        for block in response.content
-                        if isinstance(block, anthropic.types.TextBlock)
-                    )
-                )
-                or {}
-            )
-
-        if self.hass.config.country:
-            location_data[CONF_WEB_SEARCH_COUNTRY] = self.hass.config.country
-        location_data[CONF_WEB_SEARCH_TIMEZONE] = self.hass.config.time_zone
-
-        _LOGGER.debug("Location data: %s", location_data)
-
-        return location_data
-
     async_step_user = async_step_set_options
     async_step_reconfigure = async_step_set_options
 
@@ -363,18 +273,6 @@ def anthropic_config_option_schema(
                 CONF_THINKING_BUDGET,
                 default=RECOMMENDED_THINKING_BUDGET,
             ): int,
-            vol.Optional(
-                CONF_WEB_SEARCH,
-                default=RECOMMENDED_WEB_SEARCH,
-            ): bool,
-            vol.Optional(
-                CONF_WEB_SEARCH_MAX_USES,
-                default=RECOMMENDED_WEB_SEARCH_MAX_USES,
-            ): int,
-            vol.Optional(
-                CONF_WEB_SEARCH_USER_LOCATION,
-                default=RECOMMENDED_WEB_SEARCH_USER_LOCATION,
-            ): bool,
         }
     )
     return schema

homeassistant/components/anthropic/const.py

@@ -18,26 +18,9 @@ RECOMMENDED_TEMPERATURE = 1.0
 CONF_THINKING_BUDGET = "thinking_budget"
 RECOMMENDED_THINKING_BUDGET = 0
 MIN_THINKING_BUDGET = 1024
-CONF_WEB_SEARCH = "web_search"
-RECOMMENDED_WEB_SEARCH = False
-CONF_WEB_SEARCH_USER_LOCATION = "user_location"
-RECOMMENDED_WEB_SEARCH_USER_LOCATION = False
-CONF_WEB_SEARCH_MAX_USES = "web_search_max_uses"
-RECOMMENDED_WEB_SEARCH_MAX_USES = 5
-CONF_WEB_SEARCH_CITY = "city"
-CONF_WEB_SEARCH_REGION = "region"
-CONF_WEB_SEARCH_COUNTRY = "country"
-CONF_WEB_SEARCH_TIMEZONE = "timezone"
 
 NON_THINKING_MODELS = [
     "claude-3-5",  # Both sonnet and haiku
     "claude-3-opus",
     "claude-3-haiku",
 ]
-
-WEB_SEARCH_UNSUPPORTED_MODELS = [
-    "claude-3-haiku",
-    "claude-3-opus",
-    "claude-3-5-sonnet-20240620",
-    "claude-3-5-sonnet-20241022",
-]

homeassistant/components/anthropic/entity.py

@@ -1,17 +1,12 @@
 """Base entity for Anthropic."""
 
 from collections.abc import AsyncGenerator, Callable, Iterable
-from dataclasses import dataclass, field
 import json
 from typing import Any
 
 import anthropic
 from anthropic import AsyncStream
 from anthropic.types import (
-    CitationsDelta,
-    CitationsWebSearchResultLocation,
-    CitationWebSearchResultLocationParam,
-    ContentBlockParam,
     InputJSONDelta,
     MessageDeltaUsage,
     MessageParam,
@@ -21,16 +16,11 @@ from anthropic.types import (
     RawContentBlockStopEvent,
     RawMessageDeltaEvent,
     RawMessageStartEvent,
-    RawMessageStopEvent,
     RedactedThinkingBlock,
     RedactedThinkingBlockParam,
-    ServerToolUseBlock,
-    ServerToolUseBlockParam,
     SignatureDelta,
     TextBlock,
     TextBlockParam,
-    TextCitation,
-    TextCitationParam,
     TextDelta,
     ThinkingBlock,
     ThinkingBlockParam,
@@ -39,15 +29,9 @@ from anthropic.types import (
     ThinkingDelta,
     ToolParam,
     ToolResultBlockParam,
-    ToolUnionParam,
     ToolUseBlock,
     ToolUseBlockParam,
     Usage,
-    WebSearchTool20250305Param,
-    WebSearchToolRequestErrorParam,
-    WebSearchToolResultBlock,
-    WebSearchToolResultBlockParam,
-    WebSearchToolResultError,
 )
 from anthropic.types.message_create_params import MessageCreateParamsStreaming
 from voluptuous_openapi import convert
@@ -64,13 +48,6 @@ from .const import (
     CONF_MAX_TOKENS,
     CONF_TEMPERATURE,
     CONF_THINKING_BUDGET,
-    CONF_WEB_SEARCH,
-    CONF_WEB_SEARCH_CITY,
-    CONF_WEB_SEARCH_COUNTRY,
-    CONF_WEB_SEARCH_MAX_USES,
-    CONF_WEB_SEARCH_REGION,
-    CONF_WEB_SEARCH_TIMEZONE,
-    CONF_WEB_SEARCH_USER_LOCATION,
     DOMAIN,
     LOGGER,
     MIN_THINKING_BUDGET,
@@ -96,69 +73,6 @@ def _format_tool(
     )
 
 
-@dataclass(slots=True)
-class CitationDetails:
-    """Citation details for a content part."""
-
-    index: int = 0
-    """Start position of the text."""
-
-    length: int = 0
-    """Length of the relevant data."""
-
-    citations: list[TextCitationParam] = field(default_factory=list)
-    """Citations for the content part."""
-
-
-@dataclass(slots=True)
-class ContentDetails:
-    """Native data for AssistantContent."""
-
-    citation_details: list[CitationDetails] = field(default_factory=list)
-
-    def has_content(self) -> bool:
-        """Check if there is any content."""
-        return any(detail.length > 0 for detail in self.citation_details)
-
-    def has_citations(self) -> bool:
-        """Check if there are any citations."""
-        return any(detail.citations for detail in self.citation_details)
-
-    def add_citation_detail(self) -> None:
-        """Add a new citation detail."""
-        if not self.citation_details or self.citation_details[-1].length > 0:
-            self.citation_details.append(
-                CitationDetails(
-                    index=self.citation_details[-1].index
-                    + self.citation_details[-1].length
-                    if self.citation_details
-                    else 0
-                )
-            )
-
-    def add_citation(self, citation: TextCitation) -> None:
-        """Add a citation to the current detail."""
-        if not self.citation_details:
-            self.citation_details.append(CitationDetails())
-        citation_param: TextCitationParam | None = None
-        if isinstance(citation, CitationsWebSearchResultLocation):
-            citation_param = CitationWebSearchResultLocationParam(
-                type="web_search_result_location",
-                title=citation.title,
-                url=citation.url,
-                cited_text=citation.cited_text,
-                encrypted_index=citation.encrypted_index,
-            )
-        if citation_param:
-            self.citation_details[-1].citations.append(citation_param)
-
-    def delete_empty(self) -> None:
-        """Delete empty citation details."""
-        self.citation_details = [
-            detail for detail in self.citation_details if detail.citations
-        ]
-
-
 def _convert_content(
     chat_content: Iterable[conversation.Content],
 ) -> list[MessageParam]:
@@ -167,31 +81,15 @@ def _convert_content(
 
     for content in chat_content:
         if isinstance(content, conversation.ToolResultContent):
-            if content.tool_name == "web_search":
-                tool_result_block: ContentBlockParam = WebSearchToolResultBlockParam(
-                    type="web_search_tool_result",
-                    tool_use_id=content.tool_call_id,
-                    content=content.tool_result["content"]
-                    if "content" in content.tool_result
-                    else WebSearchToolRequestErrorParam(
-                        type="web_search_tool_result_error",
-                        error_code=content.tool_result.get("error_code", "unavailable"),  # type: ignore[typeddict-item]
-                    ),
-                )
-                external_tool = True
-            else:
-                tool_result_block = ToolResultBlockParam(
-                    type="tool_result",
-                    tool_use_id=content.tool_call_id,
-                    content=json.dumps(content.tool_result),
-                )
-                external_tool = False
-            if not messages or messages[-1]["role"] != (
-                "assistant" if external_tool else "user"
-            ):
+            tool_result_block = ToolResultBlockParam(
+                type="tool_result",
+                tool_use_id=content.tool_call_id,
+                content=json.dumps(content.tool_result),
+            )
+            if not messages or messages[-1]["role"] != "user":
                 messages.append(
                     MessageParam(
-                        role="assistant" if external_tool else "user",
+                        role="user",
                         content=[tool_result_block],
                     )
                 )
@@ -253,56 +151,13 @@ def _convert_content(
                         redacted_thinking_block
                     )
             if content.content:
-                current_index = 0
-                for detail in (
-                    content.native.citation_details
-                    if isinstance(content.native, ContentDetails)
-                    else [CitationDetails(length=len(content.content))]
-                ):
-                    if detail.index > current_index:
-                        # Add text block for any text without citations
-                        messages[-1]["content"].append(  # type: ignore[union-attr]
-                            TextBlockParam(
-                                type="text",
-                                text=content.content[current_index : detail.index],
-                            )
-                        )
-                    messages[-1]["content"].append(  # type: ignore[union-attr]
-                        TextBlockParam(
-                            type="text",
-                            text=content.content[
-                                detail.index : detail.index + detail.length
-                            ],
-                            citations=detail.citations,
-                        )
-                        if detail.citations
-                        else TextBlockParam(
-                            type="text",
-                            text=content.content[
-                                detail.index : detail.index + detail.length
-                            ],
-                        )
-                    )
-                    current_index = detail.index + detail.length
-                if current_index < len(content.content):
-                    # Add text block for any remaining text without citations
-                    messages[-1]["content"].append(  # type: ignore[union-attr]
-                        TextBlockParam(
-                            type="text",
-                            text=content.content[current_index:],
-                        )
-                    )
+                messages[-1]["content"].append(  # type: ignore[union-attr]
+                    TextBlockParam(type="text", text=content.content)
+                )
             if content.tool_calls:
                 messages[-1]["content"].extend(  # type: ignore[union-attr]
                     [
-                        ServerToolUseBlockParam(
-                            type="server_tool_use",
-                            id=tool_call.id,
-                            name="web_search",
-                            input=tool_call.tool_args,
-                        )
-                        if tool_call.external and tool_call.tool_name == "web_search"
-                        else ToolUseBlockParam(
+                        ToolUseBlockParam(
                             type="tool_use",
                             id=tool_call.id,
                             name=tool_call.tool_name,
@@ -318,12 +173,10 @@ def _convert_content(
     return messages
 
 
-async def _transform_stream(  # noqa: C901 - This is complex, but better to have it in one place
+async def _transform_stream(
     chat_log: conversation.ChatLog,
     stream: AsyncStream[MessageStreamEvent],
-) -> AsyncGenerator[
-    conversation.AssistantContentDeltaDict | conversation.ToolResultContentDeltaDict
-]:
+) -> AsyncGenerator[conversation.AssistantContentDeltaDict]:
     """Transform the response stream into HA format.
 
     A typical stream of responses might look something like the following:
@@ -356,13 +209,11 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
     if stream is None:
         raise TypeError("Expected a stream of messages")
 
-    current_tool_block: ToolUseBlockParam | ServerToolUseBlockParam | None = None
+    current_tool_block: ToolUseBlockParam | None = None
     current_tool_args: str
-    content_details = ContentDetails()
-    content_details.add_citation_detail()
     input_usage: Usage | None = None
+    has_content = False
     has_native = False
-    first_block: bool
 
     async for response in stream:
         LOGGER.debug("Received response: %s", response)
@@ -371,7 +222,6 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
             if response.message.role != "assistant":
                 raise ValueError("Unexpected message role")
             input_usage = response.message.usage
-            first_block = True
         elif isinstance(response, RawContentBlockStartEvent):
             if isinstance(response.content_block, ToolUseBlock):
                 current_tool_block = ToolUseBlockParam(
@@ -382,37 +232,17 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
                 )
                 current_tool_args = ""
             elif isinstance(response.content_block, TextBlock):
-                if (  # Do not start a new assistant content just for citations, concatenate consecutive blocks with citations instead.
-                    first_block
-                    or (
-                        not content_details.has_citations()
-                        and response.content_block.citations is None
-                        and content_details.has_content()
-                    )
-                ):
-                    if content_details.has_citations():
-                        content_details.delete_empty()
-                        yield {"native": content_details}
-                    content_details = ContentDetails()
+                if has_content:
                     yield {"role": "assistant"}
                     has_native = False
-                    first_block = False
-                content_details.add_citation_detail()
+                has_content = True
                 if response.content_block.text:
-                    content_details.citation_details[-1].length += len(
-                        response.content_block.text
-                    )
                     yield {"content": response.content_block.text}
             elif isinstance(response.content_block, ThinkingBlock):
-                if first_block or has_native:
-                    if content_details.has_citations():
-                        content_details.delete_empty()
-                        yield {"native": content_details}
-                    content_details = ContentDetails()
-                    content_details.add_citation_detail()
+                if has_native:
                     yield {"role": "assistant"}
                     has_native = False
-                    first_block = False
+                    has_content = False
             elif isinstance(response.content_block, RedactedThinkingBlock):
                 LOGGER.debug(
                     "Some of Claude’s internal reasoning has been automatically "
@@ -420,60 +250,15 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
                     "responses"
                 )
                 if has_native:
-                    if content_details.has_citations():
-                        content_details.delete_empty()
-                        yield {"native": content_details}
-                    content_details = ContentDetails()
-                    content_details.add_citation_detail()
                     yield {"role": "assistant"}
                     has_native = False
-                    first_block = False
+                    has_content = False
                 yield {"native": response.content_block}
                 has_native = True
-            elif isinstance(response.content_block, ServerToolUseBlock):
-                current_tool_block = ServerToolUseBlockParam(
-                    type="server_tool_use",
-                    id=response.content_block.id,
-                    name=response.content_block.name,
-                    input="",
-                )
-                current_tool_args = ""
-            elif isinstance(response.content_block, WebSearchToolResultBlock):
-                if content_details.has_citations():
-                    content_details.delete_empty()
-                    yield {"native": content_details}
-                content_details = ContentDetails()
-                content_details.add_citation_detail()
-                yield {
-                    "role": "tool_result",
-                    "tool_call_id": response.content_block.tool_use_id,
-                    "tool_name": "web_search",
-                    "tool_result": {
-                        "type": "web_search_tool_result_error",
-                        "error_code": response.content_block.content.error_code,
-                    }
-                    if isinstance(
-                        response.content_block.content, WebSearchToolResultError
-                    )
-                    else {
-                        "content": [
-                            {
-                                "type": "web_search_result",
-                                "encrypted_content": block.encrypted_content,
-                                "page_age": block.page_age,
-                                "title": block.title,
-                                "url": block.url,
-                            }
-                            for block in response.content_block.content
-                        ]
-                    },
-                }
-                first_block = True
         elif isinstance(response, RawContentBlockDeltaEvent):
             if isinstance(response.delta, InputJSONDelta):
                 current_tool_args += response.delta.partial_json
             elif isinstance(response.delta, TextDelta):
-                content_details.citation_details[-1].length += len(response.delta.text)
                 yield {"content": response.delta.text}
             elif isinstance(response.delta, ThinkingDelta):
                 yield {"thinking_content": response.delta.thinking}
@@ -486,8 +271,6 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
                     )
                 }
                 has_native = True
-            elif isinstance(response.delta, CitationsDelta):
-                content_details.add_citation(response.delta.citation)
         elif isinstance(response, RawContentBlockStopEvent):
             if current_tool_block is not None:
                 tool_args = json.loads(current_tool_args) if current_tool_args else {}
@@ -498,7 +281,6 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
                             id=current_tool_block["id"],
                             tool_name=current_tool_block["name"],
                             tool_args=tool_args,
-                            external=current_tool_block["type"] == "server_tool_use",
                         )
                     ]
                 }
@@ -508,12 +290,6 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
                 chat_log.async_trace(_create_token_stats(input_usage, usage))
             if response.delta.stop_reason == "refusal":
                 raise HomeAssistantError("Potential policy violation detected")
-        elif isinstance(response, RawMessageStopEvent):
-            if content_details.has_citations():
-                content_details.delete_empty()
-                yield {"native": content_details}
-            content_details = ContentDetails()
-            content_details.add_citation_detail()
 
 
 def _create_token_stats(
@@ -561,11 +337,21 @@ class AnthropicBaseLLMEntity(Entity):
         """Generate an answer for the chat log."""
         options = self.subentry.data
 
+        tools: list[ToolParam] | None = None
+        if chat_log.llm_api:
+            tools = [
+                _format_tool(tool, chat_log.llm_api.custom_serializer)
+                for tool in chat_log.llm_api.tools
+            ]
+
         system = chat_log.content[0]
         if not isinstance(system, conversation.SystemContent):
             raise TypeError("First message must be a system message")
         messages = _convert_content(chat_log.content[1:])
 
+        client = self.entry.runtime_data
+
+        thinking_budget = options.get(CONF_THINKING_BUDGET, RECOMMENDED_THINKING_BUDGET)
         model = options.get(CONF_CHAT_MODEL, RECOMMENDED_CHAT_MODEL)
 
         model_args = MessageCreateParamsStreaming(
@@ -575,8 +361,8 @@ class AnthropicBaseLLMEntity(Entity):
             system=system.content,
             stream=True,
         )
-
-        thinking_budget = options.get(CONF_THINKING_BUDGET, RECOMMENDED_THINKING_BUDGET)
+        if tools:
+            model_args["tools"] = tools
         if (
             not model.startswith(tuple(NON_THINKING_MODELS))
             and thinking_budget >= MIN_THINKING_BUDGET
@@ -590,34 +376,6 @@ class AnthropicBaseLLMEntity(Entity):
                 CONF_TEMPERATURE, RECOMMENDED_TEMPERATURE
             )
 
-        tools: list[ToolUnionParam] = []
-        if chat_log.llm_api:
-            tools = [
-                _format_tool(tool, chat_log.llm_api.custom_serializer)
-                for tool in chat_log.llm_api.tools
-            ]
-
-        if options.get(CONF_WEB_SEARCH):
-            web_search = WebSearchTool20250305Param(
-                name="web_search",
-                type="web_search_20250305",
-                max_uses=options.get(CONF_WEB_SEARCH_MAX_USES),
-            )
-            if options.get(CONF_WEB_SEARCH_USER_LOCATION):
-                web_search["user_location"] = {
-                    "type": "approximate",
-                    "city": options.get(CONF_WEB_SEARCH_CITY, ""),
-                    "region": options.get(CONF_WEB_SEARCH_REGION, ""),
-                    "country": options.get(CONF_WEB_SEARCH_COUNTRY, ""),
-                    "timezone": options.get(CONF_WEB_SEARCH_TIMEZONE, ""),
-                }
-            tools.append(web_search)
-
-        if tools:
-            model_args["tools"] = tools
-
-        client = self.entry.runtime_data
-
         # To prevent infinite loops, we limit the number of iterations
         for _iteration in range(MAX_TOOL_ITERATIONS):
             try:

homeassistant/components/anthropic/strings.json

@@ -35,17 +35,11 @@
             "temperature": "Temperature",
             "llm_hass_api": "[%key:common::config_flow::data::llm_hass_api%]",
             "recommended": "Recommended model settings",
-            "thinking_budget": "Thinking budget",
-            "web_search": "Enable web search",
-            "web_search_max_uses": "Maximum web searches",
-            "user_location": "Include home location"
+            "thinking_budget_tokens": "Thinking budget"
           },
           "data_description": {
             "prompt": "Instruct how the LLM should respond. This can be a template.",
-            "thinking_budget": "The number of tokens the model can use to think about the response out of the total maximum number of tokens. Set to 1024 or greater to enable extended thinking.",
-            "web_search": "The web search tool gives Claude direct access to real-time web content, allowing it to answer questions with up-to-date information beyond its knowledge cutoff",
-            "web_search_max_uses": "Limit the number of searches performed per response",
-            "user_location": "Localize search results based on home location"
+            "thinking_budget_tokens": "The number of tokens the model can use to think about the response out of the total maximum number of tokens. Set to 1024 or greater to enable extended thinking."
           }
         }
       },
@@ -54,8 +48,7 @@
         "entry_not_loaded": "Cannot add things while the configuration is disabled."
       },
       "error": {
-        "thinking_budget_too_large": "Maximum tokens must be greater than the thinking budget.",
-        "web_search_unsupported_model": "Web search is not supported by the selected model. Please choose a compatible model or disable web search."
+        "thinking_budget_too_large": "Maximum tokens must be greater than the thinking budget."
       }
     }
   }

homeassistant/components/aprilaire/climate.py

@@ -7,8 +7,6 @@ from typing import Any
 from pyaprilaire.const import Attribute
 
 from homeassistant.components.climate import (
-    ATTR_TARGET_TEMP_HIGH,
-    ATTR_TARGET_TEMP_LOW,
     FAN_AUTO,
     FAN_ON,
     PRESET_AWAY,
@@ -18,12 +16,7 @@ from homeassistant.components.climate import (
     HVACAction,
     HVACMode,
 )
-from homeassistant.const import (
-    ATTR_TEMPERATURE,
-    PRECISION_HALVES,
-    PRECISION_WHOLE,
-    UnitOfTemperature,
-)
+from homeassistant.const import PRECISION_HALVES, PRECISION_WHOLE, UnitOfTemperature
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
@@ -239,15 +232,15 @@ class AprilaireClimate(BaseAprilaireEntity, ClimateEntity):
         cool_setpoint = 0
         heat_setpoint = 0
 
-        if temperature := kwargs.get(ATTR_TEMPERATURE):
+        if temperature := kwargs.get("temperature"):
             if self.coordinator.data.get(Attribute.MODE) == 3:
                 cool_setpoint = temperature
             else:
                 heat_setpoint = temperature
         else:
-            if target_temp_low := kwargs.get(ATTR_TARGET_TEMP_LOW):
+            if target_temp_low := kwargs.get("target_temp_low"):
                 heat_setpoint = target_temp_low
-            if target_temp_high := kwargs.get(ATTR_TARGET_TEMP_HIGH):
+            if target_temp_high := kwargs.get("target_temp_high"):
                 cool_setpoint = target_temp_high
 
         if cool_setpoint == 0 and heat_setpoint == 0:

homeassistant/components/autarco/manifest.json

@@ -5,5 +5,5 @@
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/autarco",
   "iot_class": "cloud_polling",
-  "requirements": ["autarco==3.2.0"]
+  "requirements": ["autarco==3.1.0"]
 }

homeassistant/components/brother/manifest.json

@@ -8,7 +8,7 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["brother", "pyasn1", "pysmi", "pysnmp"],
-  "requirements": ["brother==5.1.1"],
+  "requirements": ["brother==5.1.0"],
   "zeroconf": [
     {
       "type": "_printer._tcp.local.",

homeassistant/components/bryant_evolution/climate.py

@@ -7,14 +7,12 @@ from typing import Any
 from evolutionhttp import BryantEvolutionLocalClient
 
 from homeassistant.components.climate import (
-    ATTR_TARGET_TEMP_HIGH,
-    ATTR_TARGET_TEMP_LOW,
     ClimateEntity,
     ClimateEntityFeature,
     HVACAction,
     HVACMode,
 )
-from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
+from homeassistant.const import UnitOfTemperature
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.device_registry import DeviceInfo
@@ -210,24 +208,24 @@ class BryantEvolutionClimate(ClimateEntity):
 
     async def async_set_temperature(self, **kwargs: Any) -> None:
         """Set new target temperature."""
-        if value := kwargs.get(ATTR_TARGET_TEMP_HIGH):
-            temp = int(value)
+        if kwargs.get("target_temp_high"):
+            temp = int(kwargs["target_temp_high"])
             if not await self._client.set_cooling_setpoint(temp):
                 raise HomeAssistantError(
                     translation_domain=DOMAIN, translation_key="failed_to_set_clsp"
                 )
             self._attr_target_temperature_high = temp
 
-        if value := kwargs.get(ATTR_TARGET_TEMP_LOW):
-            temp = int(value)
+        if kwargs.get("target_temp_low"):
+            temp = int(kwargs["target_temp_low"])
             if not await self._client.set_heating_setpoint(temp):
                 raise HomeAssistantError(
                     translation_domain=DOMAIN, translation_key="failed_to_set_htsp"
                 )
             self._attr_target_temperature_low = temp
 
-        if value := kwargs.get(ATTR_TEMPERATURE):
-            temp = int(value)
+        if kwargs.get("temperature"):
+            temp = int(kwargs["temperature"])
             fn = (
                 self._client.set_heating_setpoint
                 if self.hvac_mode == HVACMode.HEAT

homeassistant/components/calendar/trigger.py

@@ -169,7 +169,7 @@ class CalendarEventListener:
     def __init__(
         self,
         hass: HomeAssistant,
-        job: HassJob[..., Coroutine[Any, Any, None] | Any],
+        job: HassJob[..., Coroutine[Any, Any, None]],
         trigger_data: dict[str, Any],
         fetcher: QueuedEventFetcher,
     ) -> None:

homeassistant/components/citybikes/manifest.json

@@ -4,6 +4,5 @@
   "codeowners": [],
   "documentation": "https://www.home-assistant.io/integrations/citybikes",
   "iot_class": "cloud_polling",
-  "quality_scale": "legacy",
-  "requirements": ["python-citybikes==0.3.3"]
+  "quality_scale": "legacy"
 }

homeassistant/components/citybikes/sensor.py

@@ -5,11 +5,8 @@ from __future__ import annotations
 import asyncio
 from datetime import timedelta
 import logging
-import sys
 
 import aiohttp
-from citybikes import __version__ as CITYBIKES_CLIENT_VERSION
-from citybikes.asyncio import Client as CitybikesClient
 import voluptuous as vol
 
 from homeassistant.components.sensor import (
@@ -18,18 +15,21 @@ from homeassistant.components.sensor import (
     SensorEntity,
 )
 from homeassistant.const import (
-    APPLICATION_NAME,
+    ATTR_ID,
+    ATTR_LATITUDE,
+    ATTR_LOCATION,
+    ATTR_LONGITUDE,
+    ATTR_NAME,
     CONF_LATITUDE,
     CONF_LONGITUDE,
     CONF_NAME,
     CONF_RADIUS,
-    EVENT_HOMEASSISTANT_CLOSE,
     UnitOfLength,
-    __version__,
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import PlatformNotReady
 from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.entity import async_generate_entity_id
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.event import async_track_time_interval
@@ -40,33 +40,31 @@ from homeassistant.util.unit_system import US_CUSTOMARY_SYSTEM
 
 _LOGGER = logging.getLogger(__name__)
 
-HA_USER_AGENT = (
-    f"{APPLICATION_NAME}/{__version__} "
-    f"python-citybikes/{CITYBIKES_CLIENT_VERSION} "
-    f"Python/{sys.version_info[0]}.{sys.version_info[1]}"
-)
-
-ATTR_UID = "uid"
-ATTR_LATITUDE = "latitude"
-ATTR_LONGITUDE = "longitude"
 ATTR_EMPTY_SLOTS = "empty_slots"
+ATTR_EXTRA = "extra"
+ATTR_FREE_BIKES = "free_bikes"
+ATTR_NETWORK = "network"
+ATTR_NETWORKS_LIST = "networks"
+ATTR_STATIONS_LIST = "stations"
 ATTR_TIMESTAMP = "timestamp"
+ATTR_UID = "uid"
 
 CONF_NETWORK = "network"
 CONF_STATIONS_LIST = "stations"
 
+DEFAULT_ENDPOINT = "https://api.citybik.es/{uri}"
 PLATFORM = "citybikes"
 
 MONITORED_NETWORKS = "monitored-networks"
 
-DATA_CLIENT = "client"
-
 NETWORKS_URI = "v2/networks"
 
-REQUEST_TIMEOUT = aiohttp.ClientTimeout(total=5)
+REQUEST_TIMEOUT = 5  # In seconds; argument to asyncio.timeout
 
 SCAN_INTERVAL = timedelta(minutes=5)  # Timely, and doesn't suffocate the API
 
+STATIONS_URI = "v2/networks/{uid}?fields=network.stations"
+
 CITYBIKES_ATTRIBUTION = (
     "Information provided by the CityBikes Project (https://citybik.es/#about)"
 )
@@ -89,6 +87,72 @@ PLATFORM_SCHEMA = vol.All(
     ),
 )
 
+NETWORK_SCHEMA = vol.Schema(
+    {
+        vol.Required(ATTR_ID): cv.string,
+        vol.Required(ATTR_NAME): cv.string,
+        vol.Required(ATTR_LOCATION): vol.Schema(
+            {
+                vol.Required(ATTR_LATITUDE): cv.latitude,
+                vol.Required(ATTR_LONGITUDE): cv.longitude,
+            },
+            extra=vol.REMOVE_EXTRA,
+        ),
+    },
+    extra=vol.REMOVE_EXTRA,
+)
+
+NETWORKS_RESPONSE_SCHEMA = vol.Schema(
+    {vol.Required(ATTR_NETWORKS_LIST): [NETWORK_SCHEMA]}
+)
+
+STATION_SCHEMA = vol.Schema(
+    {
+        vol.Required(ATTR_FREE_BIKES): cv.positive_int,
+        vol.Required(ATTR_EMPTY_SLOTS): vol.Any(cv.positive_int, None),
+        vol.Required(ATTR_LATITUDE): cv.latitude,
+        vol.Required(ATTR_LONGITUDE): cv.longitude,
+        vol.Required(ATTR_ID): cv.string,
+        vol.Required(ATTR_NAME): cv.string,
+        vol.Required(ATTR_TIMESTAMP): cv.string,
+        vol.Optional(ATTR_EXTRA): vol.Schema(
+            {vol.Optional(ATTR_UID): cv.string}, extra=vol.REMOVE_EXTRA
+        ),
+    },
+    extra=vol.REMOVE_EXTRA,
+)
+
+STATIONS_RESPONSE_SCHEMA = vol.Schema(
+    {
+        vol.Required(ATTR_NETWORK): vol.Schema(
+            {vol.Required(ATTR_STATIONS_LIST): [STATION_SCHEMA]}, extra=vol.REMOVE_EXTRA
+        )
+    }
+)
+
+
+class CityBikesRequestError(Exception):
+    """Error to indicate a CityBikes API request has failed."""
+
+
+async def async_citybikes_request(hass, uri, schema):
+    """Perform a request to CityBikes API endpoint, and parse the response."""
+    try:
+        session = async_get_clientsession(hass)
+
+        async with asyncio.timeout(REQUEST_TIMEOUT):
+            req = await session.get(DEFAULT_ENDPOINT.format(uri=uri))
+
+        json_response = await req.json()
+        return schema(json_response)
+    except (TimeoutError, aiohttp.ClientError):
+        _LOGGER.error("Could not connect to CityBikes API endpoint")
+    except ValueError:
+        _LOGGER.error("Received non-JSON data from CityBikes API endpoint")
+    except vol.Invalid as err:
+        _LOGGER.error("Received unexpected JSON from CityBikes API endpoint: %s", err)
+    raise CityBikesRequestError
+
 
 async def async_setup_platform(
     hass: HomeAssistant,
@@ -111,14 +175,6 @@ async def async_setup_platform(
             radius, UnitOfLength.FEET, UnitOfLength.METERS
         )
 
-    client = CitybikesClient(user_agent=HA_USER_AGENT, timeout=REQUEST_TIMEOUT)
-    hass.data[PLATFORM][DATA_CLIENT] = client
-
-    async def _async_close_client(event):
-        await client.close()
-
-    hass.bus.async_listen_once(EVENT_HOMEASSISTANT_CLOSE, _async_close_client)
-
     # Create a single instance of CityBikesNetworks.
     networks = hass.data.setdefault(CITYBIKES_NETWORKS, CityBikesNetworks(hass))
 
@@ -138,10 +194,10 @@ async def async_setup_platform(
     devices = []
     for station in network.stations:
         dist = location_util.distance(
-            latitude, longitude, station.latitude, station.longitude
+            latitude, longitude, station[ATTR_LATITUDE], station[ATTR_LONGITUDE]
         )
-        station_id = station.id
-        station_uid = str(station.extra.get(ATTR_UID, ""))
+        station_id = station[ATTR_ID]
+        station_uid = str(station.get(ATTR_EXTRA, {}).get(ATTR_UID, ""))
 
         if radius > dist or stations_list.intersection((station_id, station_uid)):
             if name:
@@ -160,7 +216,6 @@ class CityBikesNetworks:
     def __init__(self, hass):
         """Initialize the networks instance."""
         self.hass = hass
-        self.client = hass.data[PLATFORM][DATA_CLIENT]
         self.networks = None
         self.networks_loading = asyncio.Condition()
 
@@ -169,21 +224,24 @@ class CityBikesNetworks:
         try:
             await self.networks_loading.acquire()
             if self.networks is None:
-                self.networks = await self.client.networks.fetch()
-        except aiohttp.ClientError as err:
+                networks = await async_citybikes_request(
+                    self.hass, NETWORKS_URI, NETWORKS_RESPONSE_SCHEMA
+                )
+                self.networks = networks[ATTR_NETWORKS_LIST]
+        except CityBikesRequestError as err:
             raise PlatformNotReady from err
         else:
             result = None
             minimum_dist = None
             for network in self.networks:
-                network_latitude = network.location.latitude
-                network_longitude = network.location.longitude
+                network_latitude = network[ATTR_LOCATION][ATTR_LATITUDE]
+                network_longitude = network[ATTR_LOCATION][ATTR_LONGITUDE]
                 dist = location_util.distance(
                     latitude, longitude, network_latitude, network_longitude
                 )
                 if minimum_dist is None or dist < minimum_dist:
                     minimum_dist = dist
-                    result = network.id
+                    result = network[ATTR_ID]
 
             return result
         finally:
@@ -199,20 +257,22 @@ class CityBikesNetwork:
         self.network_id = network_id
         self.stations = []
         self.ready = asyncio.Event()
-        self.client = hass.data[PLATFORM][DATA_CLIENT]
 
     async def async_refresh(self, now=None):
         """Refresh the state of the network."""
         try:
-            network = await self.client.network(uid=self.network_id).fetch()
-        except aiohttp.ClientError as err:
-            if now is None:
+            network = await async_citybikes_request(
+                self.hass,
+                STATIONS_URI.format(uid=self.network_id),
+                STATIONS_RESPONSE_SCHEMA,
+            )
+            self.stations = network[ATTR_NETWORK][ATTR_STATIONS_LIST]
+            self.ready.set()
+        except CityBikesRequestError as err:
+            if now is not None:
+                self.ready.clear()
+            else:
                 raise PlatformNotReady from err
-            self.ready.clear()
-            return
-
-        self.stations = network.stations
-        self.ready.set()
 
 
 class CityBikesStation(SensorEntity):
@@ -230,13 +290,16 @@ class CityBikesStation(SensorEntity):
 
     async def async_update(self) -> None:
         """Update station state."""
-        station = next(s for s in self._network.stations if s.id == self._station_id)
-        self._attr_name = station.name
-        self._attr_native_value = station.free_bikes
+        for station in self._network.stations:
+            if station[ATTR_ID] == self._station_id:
+                station_data = station
+                break
+        self._attr_name = station_data.get(ATTR_NAME)
+        self._attr_native_value = station_data.get(ATTR_FREE_BIKES)
         self._attr_extra_state_attributes = {
-            ATTR_UID: station.extra.get(ATTR_UID),
-            ATTR_LATITUDE: station.latitude,
-            ATTR_LONGITUDE: station.longitude,
-            ATTR_EMPTY_SLOTS: station.empty_slots,
-            ATTR_TIMESTAMP: station.timestamp,
+            ATTR_UID: station_data.get(ATTR_EXTRA, {}).get(ATTR_UID),
+            ATTR_LATITUDE: station_data.get(ATTR_LATITUDE),
+            ATTR_LONGITUDE: station_data.get(ATTR_LONGITUDE),
+            ATTR_EMPTY_SLOTS: station_data.get(ATTR_EMPTY_SLOTS),
+            ATTR_TIMESTAMP: station_data.get(ATTR_TIMESTAMP),
         }

homeassistant/components/comelit/binary_sensor.py

@@ -15,7 +15,6 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .coordinator import ComelitConfigEntry, ComelitVedoSystem
-from .utils import DeviceType, new_device_listener
 
 # Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
@@ -30,19 +29,23 @@ async def async_setup_entry(
 
     coordinator = cast(ComelitVedoSystem, config_entry.runtime_data)
 
-    def _add_new_entities(new_devices: list[DeviceType], dev_type: str) -> None:
-        """Add entities for new monitors."""
-        entities = [
-            ComelitVedoBinarySensorEntity(coordinator, device, config_entry.entry_id)
-            for device in coordinator.data["alarm_zones"].values()
-            if device in new_devices
-        ]
-        if entities:
-            async_add_entities(entities)
+    known_devices: set[int] = set()
 
-    config_entry.async_on_unload(
-        new_device_listener(coordinator, _add_new_entities, "alarm_zones")
-    )
+    def _check_device() -> None:
+        current_devices = set(coordinator.data["alarm_zones"])
+        new_devices = current_devices - known_devices
+        if new_devices:
+            known_devices.update(new_devices)
+            async_add_entities(
+                ComelitVedoBinarySensorEntity(
+                    coordinator, device, config_entry.entry_id
+                )
+                for device in coordinator.data["alarm_zones"].values()
+                if device.index in new_devices
+            )
+
+    _check_device()
+    config_entry.async_on_unload(coordinator.async_add_listener(_check_device))
 
 
 class ComelitVedoBinarySensorEntity(

homeassistant/components/comelit/cover.py

@@ -7,14 +7,14 @@ from typing import Any, cast
 from aiocomelit import ComelitSerialBridgeObject
 from aiocomelit.const import COVER, STATE_COVER, STATE_OFF, STATE_ON
 
-from homeassistant.components.cover import CoverDeviceClass, CoverEntity, CoverState
+from homeassistant.components.cover import CoverDeviceClass, CoverEntity
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.restore_state import RestoreEntity
 
 from .coordinator import ComelitConfigEntry, ComelitSerialBridge
 from .entity import ComelitBridgeBaseEntity
-from .utils import DeviceType, bridge_api_call, new_device_listener
+from .utils import bridge_api_call
 
 # Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
@@ -29,19 +29,21 @@ async def async_setup_entry(
 
     coordinator = cast(ComelitSerialBridge, config_entry.runtime_data)
 
-    def _add_new_entities(new_devices: list[DeviceType], dev_type: str) -> None:
-        """Add entities for new monitors."""
-        entities = [
-            ComelitCoverEntity(coordinator, device, config_entry.entry_id)
-            for device in coordinator.data[dev_type].values()
-            if device in new_devices
-        ]
-        if entities:
-            async_add_entities(entities)
+    known_devices: set[int] = set()
 
-    config_entry.async_on_unload(
-        new_device_listener(coordinator, _add_new_entities, COVER)
-    )
+    def _check_device() -> None:
+        current_devices = set(coordinator.data[COVER])
+        new_devices = current_devices - known_devices
+        if new_devices:
+            known_devices.update(new_devices)
+            async_add_entities(
+                ComelitCoverEntity(coordinator, device, config_entry.entry_id)
+                for device in coordinator.data[COVER].values()
+                if device.index in new_devices
+            )
+
+    _check_device()
+    config_entry.async_on_unload(coordinator.async_add_listener(_check_device))
 
 
 class ComelitCoverEntity(ComelitBridgeBaseEntity, RestoreEntity, CoverEntity):
@@ -60,6 +62,7 @@ class ComelitCoverEntity(ComelitBridgeBaseEntity, RestoreEntity, CoverEntity):
         super().__init__(coordinator, device, config_entry_entry_id)
         # Device doesn't provide a status so we assume UNKNOWN at first startup
         self._last_action: int | None = None
+        self._last_state: str | None = None
 
     def _current_action(self, action: str) -> bool:
         """Return the current cover action."""
@@ -95,6 +98,7 @@ class ComelitCoverEntity(ComelitBridgeBaseEntity, RestoreEntity, CoverEntity):
     @bridge_api_call
     async def _cover_set_state(self, action: int, state: int) -> None:
         """Set desired cover state."""
+        self._last_state = self.state
         await self.coordinator.api.set_device_status(COVER, self._device.index, action)
         self.coordinator.data[COVER][self._device.index].status = state
         self.async_write_ha_state()
@@ -120,10 +124,5 @@ class ComelitCoverEntity(ComelitBridgeBaseEntity, RestoreEntity, CoverEntity):
 
         await super().async_added_to_hass()
 
-        if (state := await self.async_get_last_state()) is not None:
-            if state.state == CoverState.CLOSED:
-                self._last_action = STATE_COVER.index(CoverState.CLOSING)
-            if state.state == CoverState.OPEN:
-                self._last_action = STATE_COVER.index(CoverState.OPENING)
-
-            self._attr_is_closed = state.state == CoverState.CLOSED
+        if last_state := await self.async_get_last_state():
+            self._last_state = last_state.state

homeassistant/components/comelit/light.py

@@ -12,7 +12,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .coordinator import ComelitConfigEntry, ComelitSerialBridge
 from .entity import ComelitBridgeBaseEntity
-from .utils import DeviceType, bridge_api_call, new_device_listener
+from .utils import bridge_api_call
 
 # Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
@@ -27,19 +27,21 @@ async def async_setup_entry(
 
     coordinator = cast(ComelitSerialBridge, config_entry.runtime_data)
 
-    def _add_new_entities(new_devices: list[DeviceType], dev_type: str) -> None:
-        """Add entities for new monitors."""
-        entities = [
-            ComelitLightEntity(coordinator, device, config_entry.entry_id)
-            for device in coordinator.data[dev_type].values()
-            if device in new_devices
-        ]
-        if entities:
-            async_add_entities(entities)
+    known_devices: set[int] = set()
 
-    config_entry.async_on_unload(
-        new_device_listener(coordinator, _add_new_entities, LIGHT)
-    )
+    def _check_device() -> None:
+        current_devices = set(coordinator.data[LIGHT])
+        new_devices = current_devices - known_devices
+        if new_devices:
+            known_devices.update(new_devices)
+            async_add_entities(
+                ComelitLightEntity(coordinator, device, config_entry.entry_id)
+                for device in coordinator.data[LIGHT].values()
+                if device.index in new_devices
+            )
+
+    _check_device()
+    config_entry.async_on_unload(coordinator.async_add_listener(_check_device))
 
 
 class ComelitLightEntity(ComelitBridgeBaseEntity, LightEntity):

homeassistant/components/comelit/sensor.py

@@ -20,7 +20,6 @@ from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .coordinator import ComelitConfigEntry, ComelitSerialBridge, ComelitVedoSystem
 from .entity import ComelitBridgeBaseEntity
-from .utils import DeviceType, new_device_listener
 
 # Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
@@ -66,22 +65,24 @@ async def async_setup_bridge_entry(
 
     coordinator = cast(ComelitSerialBridge, config_entry.runtime_data)
 
-    def _add_new_entities(new_devices: list[DeviceType], dev_type: str) -> None:
-        """Add entities for new monitors."""
-        entities = [
-            ComelitBridgeSensorEntity(
-                coordinator, device, config_entry.entry_id, sensor_desc
-            )
-            for sensor_desc in SENSOR_BRIDGE_TYPES
-            for device in coordinator.data[dev_type].values()
-            if device in new_devices
-        ]
-        if entities:
-            async_add_entities(entities)
+    known_devices: set[int] = set()
 
-    config_entry.async_on_unload(
-        new_device_listener(coordinator, _add_new_entities, OTHER)
-    )
+    def _check_device() -> None:
+        current_devices = set(coordinator.data[OTHER])
+        new_devices = current_devices - known_devices
+        if new_devices:
+            known_devices.update(new_devices)
+            async_add_entities(
+                ComelitBridgeSensorEntity(
+                    coordinator, device, config_entry.entry_id, sensor_desc
+                )
+                for sensor_desc in SENSOR_BRIDGE_TYPES
+                for device in coordinator.data[OTHER].values()
+                if device.index in new_devices
+            )
+
+    _check_device()
+    config_entry.async_on_unload(coordinator.async_add_listener(_check_device))
 
 
 async def async_setup_vedo_entry(
@@ -93,22 +94,24 @@ async def async_setup_vedo_entry(
 
     coordinator = cast(ComelitVedoSystem, config_entry.runtime_data)
 
-    def _add_new_entities(new_devices: list[DeviceType], dev_type: str) -> None:
-        """Add entities for new monitors."""
-        entities = [
-            ComelitVedoSensorEntity(
-                coordinator, device, config_entry.entry_id, sensor_desc
-            )
-            for sensor_desc in SENSOR_VEDO_TYPES
-            for device in coordinator.data["alarm_zones"].values()
-            if device in new_devices
-        ]
-        if entities:
-            async_add_entities(entities)
+    known_devices: set[int] = set()
 
-    config_entry.async_on_unload(
-        new_device_listener(coordinator, _add_new_entities, "alarm_zones")
-    )
+    def _check_device() -> None:
+        current_devices = set(coordinator.data["alarm_zones"])
+        new_devices = current_devices - known_devices
+        if new_devices:
+            known_devices.update(new_devices)
+            async_add_entities(
+                ComelitVedoSensorEntity(
+                    coordinator, device, config_entry.entry_id, sensor_desc
+                )
+                for sensor_desc in SENSOR_VEDO_TYPES
+                for device in coordinator.data["alarm_zones"].values()
+                if device.index in new_devices
+            )
+
+    _check_device()
+    config_entry.async_on_unload(coordinator.async_add_listener(_check_device))
 
 
 class ComelitBridgeSensorEntity(ComelitBridgeBaseEntity, SensorEntity):

homeassistant/components/comelit/switch.py

@@ -13,7 +13,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .coordinator import ComelitConfigEntry, ComelitSerialBridge
 from .entity import ComelitBridgeBaseEntity
-from .utils import DeviceType, bridge_api_call, new_device_listener
+from .utils import bridge_api_call
 
 # Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
@@ -28,20 +28,35 @@ async def async_setup_entry(
 
     coordinator = cast(ComelitSerialBridge, config_entry.runtime_data)
 
-    def _add_new_entities(new_devices: list[DeviceType], dev_type: str) -> None:
-        """Add entities for new monitors."""
-        entities = [
-            ComelitSwitchEntity(coordinator, device, config_entry.entry_id)
-            for device in coordinator.data[dev_type].values()
-            if device in new_devices
-        ]
-        if entities:
-            async_add_entities(entities)
+    entities: list[ComelitSwitchEntity] = []
+    entities.extend(
+        ComelitSwitchEntity(coordinator, device, config_entry.entry_id)
+        for device in coordinator.data[IRRIGATION].values()
+    )
+    entities.extend(
+        ComelitSwitchEntity(coordinator, device, config_entry.entry_id)
+        for device in coordinator.data[OTHER].values()
+    )
+    async_add_entities(entities)
 
-    for dev_type in (IRRIGATION, OTHER):
-        config_entry.async_on_unload(
-            new_device_listener(coordinator, _add_new_entities, dev_type)
-        )
+    known_devices: dict[str, set[int]] = {
+        dev_type: set() for dev_type in (IRRIGATION, OTHER)
+    }
+
+    def _check_device() -> None:
+        for dev_type in (IRRIGATION, OTHER):
+            current_devices = set(coordinator.data[dev_type])
+            new_devices = current_devices - known_devices[dev_type]
+            if new_devices:
+                known_devices[dev_type].update(new_devices)
+                async_add_entities(
+                    ComelitSwitchEntity(coordinator, device, config_entry.entry_id)
+                    for device in coordinator.data[dev_type].values()
+                    if device.index in new_devices
+                )
+
+    _check_device()
+    config_entry.async_on_unload(coordinator.async_add_listener(_check_device))
 
 
 class ComelitSwitchEntity(ComelitBridgeBaseEntity, SwitchEntity):

homeassistant/components/comelit/utils.py

@@ -4,11 +4,7 @@ from collections.abc import Awaitable, Callable, Coroutine
 from functools import wraps
 from typing import Any, Concatenate
 
-from aiocomelit.api import (
-    ComelitSerialBridgeObject,
-    ComelitVedoAreaObject,
-    ComelitVedoZoneObject,
-)
+from aiocomelit import ComelitSerialBridgeObject
 from aiocomelit.exceptions import CannotAuthenticate, CannotConnect, CannotRetrieveData
 from aiohttp import ClientSession, CookieJar
 
@@ -23,11 +19,8 @@ from homeassistant.helpers import (
 )
 
 from .const import _LOGGER, DOMAIN
-from .coordinator import ComelitBaseCoordinator
 from .entity import ComelitBridgeBaseEntity
 
-DeviceType = ComelitSerialBridgeObject | ComelitVedoAreaObject | ComelitVedoZoneObject
-
 
 async def async_client_session(hass: HomeAssistant) -> ClientSession:
     """Return a new aiohttp session."""
@@ -120,41 +113,3 @@ def bridge_api_call[_T: ComelitBridgeBaseEntity, **_P](
             self.coordinator.config_entry.async_start_reauth(self.hass)
 
     return cmd_wrapper
-
-
-def new_device_listener(
-    coordinator: ComelitBaseCoordinator,
-    new_devices_callback: Callable[
-        [
-            list[
-                ComelitSerialBridgeObject
-                | ComelitVedoAreaObject
-                | ComelitVedoZoneObject
-            ],
-            str,
-        ],
-        None,
-    ],
-    data_type: str,
-) -> Callable[[], None]:
-    """Subscribe to coordinator updates to check for new devices."""
-    known_devices: set[int] = set()
-
-    def _check_devices() -> None:
-        """Check for new devices and call callback with any new monitors."""
-        if not coordinator.data:
-            return
-
-        new_devices: list[DeviceType] = []
-        for _id in coordinator.data[data_type]:
-            if _id not in known_devices:
-                known_devices.add(_id)
-                new_devices.append(coordinator.data[data_type][_id])
-
-        if new_devices:
-            new_devices_callback(new_devices, data_type)
-
-    # Check for devices immediately
-    _check_devices()
-
-    return coordinator.async_add_listener(_check_devices)

homeassistant/components/conversation/chat_log.py

@@ -514,7 +514,7 @@ class ChatLog:
         """Set the LLM system prompt."""
         llm_api: llm.APIInstance | None = None
 
-        if not user_llm_hass_api:
+        if user_llm_hass_api is None:
             pass
         elif isinstance(user_llm_hass_api, llm.API):
             llm_api = await user_llm_hass_api.async_get_api_instance(llm_context)

homeassistant/components/conversation/default_agent.py

@@ -38,30 +38,22 @@ from home_assistant_intents import (
     ErrorKey,
     FuzzyConfig,
     FuzzyLanguageResponses,
-    LanguageScores,
     get_fuzzy_config,
     get_fuzzy_language,
     get_intents,
-    get_language_scores,
     get_languages,
 )
 import yaml
 
+from homeassistant import core
 from homeassistant.components.homeassistant.exposed_entities import (
     async_listen_entity_updates,
     async_should_expose,
 )
 from homeassistant.const import EVENT_STATE_CHANGED, MATCH_ALL
-from homeassistant.core import (
-    Event,
-    EventStateChangedData,
-    HomeAssistant,
-    State,
-    callback,
-)
+from homeassistant.core import Event, callback
 from homeassistant.helpers import (
     area_registry as ar,
-    config_validation as cv,
     device_registry as dr,
     entity_registry as er,
     floor_registry as fr,
@@ -200,7 +192,7 @@ class IntentCache:
 
 
 async def async_setup_default_agent(
-    hass: HomeAssistant,
+    hass: core.HomeAssistant,
     entity_component: EntityComponent[ConversationEntity],
     config_intents: dict[str, Any],
 ) -> None:
@@ -209,13 +201,15 @@ async def async_setup_default_agent(
     await entity_component.async_add_entities([agent])
     await get_agent_manager(hass).async_setup_default_agent(agent)
 
-    @callback
-    def async_entity_state_listener(event: Event[EventStateChangedData]) -> None:
+    @core.callback
+    def async_entity_state_listener(
+        event: core.Event[core.EventStateChangedData],
+    ) -> None:
         """Set expose flag on new entities."""
         async_should_expose(hass, DOMAIN, event.data["entity_id"])
 
-    @callback
-    def async_hass_started(hass: HomeAssistant) -> None:
+    @core.callback
+    def async_hass_started(hass: core.HomeAssistant) -> None:
         """Set expose flag on all entities."""
         for state in hass.states.async_all():
             async_should_expose(hass, DOMAIN, state.entity_id)
@@ -230,7 +224,9 @@ class DefaultAgent(ConversationEntity):
     _attr_name = "Home Assistant"
     _attr_supported_features = ConversationEntityFeature.CONTROL
 
-    def __init__(self, hass: HomeAssistant, config_intents: dict[str, Any]) -> None:
+    def __init__(
+        self, hass: core.HomeAssistant, config_intents: dict[str, Any]
+    ) -> None:
         """Initialize the default agent."""
         self.hass = hass
         self._lang_intents: dict[str, LanguageIntents | object] = {}
@@ -263,7 +259,7 @@ class DefaultAgent(ConversationEntity):
         """Return a list of supported languages."""
         return get_languages()
 
-    @callback
+    @core.callback
     def _filter_entity_registry_changes(
         self, event_data: er.EventEntityRegistryUpdatedData
     ) -> bool:
@@ -272,12 +268,12 @@ class DefaultAgent(ConversationEntity):
             field in event_data["changes"] for field in _ENTITY_REGISTRY_UPDATE_FIELDS
         )
 
-    @callback
-    def _filter_state_changes(self, event_data: EventStateChangedData) -> bool:
+    @core.callback
+    def _filter_state_changes(self, event_data: core.EventStateChangedData) -> bool:
         """Filter state changed events."""
         return not event_data["old_state"] or not event_data["new_state"]
 
-    @callback
+    @core.callback
     def _listen_clear_slot_list(self) -> None:
         """Listen for changes that can invalidate slot list."""
         assert self._unsub_clear_slot_list is None
@@ -346,81 +342,6 @@ class DefaultAgent(ConversationEntity):
 
         return result
 
-    async def async_debug_recognize(
-        self, user_input: ConversationInput
-    ) -> dict[str, Any] | None:
-        """Debug recognize from user input."""
-        result_dict: dict[str, Any] | None = None
-
-        if trigger_result := await self.async_recognize_sentence_trigger(user_input):
-            result_dict = {
-                # Matched a user-defined sentence trigger.
-                # We can't provide the response here without executing the
-                # trigger.
-                "match": True,
-                "source": "trigger",
-                "sentence_template": trigger_result.sentence_template or "",
-            }
-        elif intent_result := await self.async_recognize_intent(user_input):
-            successful_match = not intent_result.unmatched_entities
-            result_dict = {
-                # Name of the matching intent (or the closest)
-                "intent": {
-                    "name": intent_result.intent.name,
-                },
-                # Slot values that would be received by the intent
-                "slots": {  # direct access to values
-                    entity_key: entity.text or entity.value
-                    for entity_key, entity in intent_result.entities.items()
-                },
-                # Extra slot details, such as the originally matched text
-                "details": {
-                    entity_key: {
-                        "name": entity.name,
-                        "value": entity.value,
-                        "text": entity.text,
-                    }
-                    for entity_key, entity in intent_result.entities.items()
-                },
-                # Entities/areas/etc. that would be targeted
-                "targets": {},
-                # True if match was successful
-                "match": successful_match,
-                # Text of the sentence template that matched (or was closest)
-                "sentence_template": "",
-                # When match is incomplete, this will contain the best slot guesses
-                "unmatched_slots": _get_unmatched_slots(intent_result),
-                # True if match was not exact
-                "fuzzy_match": False,
-            }
-
-            if successful_match:
-                result_dict["targets"] = {
-                    state.entity_id: {"matched": is_matched}
-                    for state, is_matched in _get_debug_targets(
-                        self.hass, intent_result
-                    )
-                }
-
-            if intent_result.intent_sentence is not None:
-                result_dict["sentence_template"] = intent_result.intent_sentence.text
-
-            if intent_result.intent_metadata:
-                # Inspect metadata to determine if this matched a custom sentence
-                if intent_result.intent_metadata.get(METADATA_CUSTOM_SENTENCE):
-                    result_dict["source"] = "custom"
-                    result_dict["file"] = intent_result.intent_metadata.get(
-                        METADATA_CUSTOM_FILE
-                    )
-                else:
-                    result_dict["source"] = "builtin"
-
-                result_dict["fuzzy_match"] = intent_result.intent_metadata.get(
-                    METADATA_FUZZY_MATCH, False
-                )
-
-        return result_dict
-
     async def _async_handle_message(
         self,
         user_input: ConversationInput,
@@ -969,7 +890,7 @@ class DefaultAgent(ConversationEntity):
     ) -> str:
         # Get first matched or unmatched state.
         # This is available in the response template as "state".
-        state1: State | None = None
+        state1: core.State | None = None
         if intent_response.matched_states:
             state1 = intent_response.matched_states[0]
         elif intent_response.unmatched_states:
@@ -1607,10 +1528,6 @@ class DefaultAgent(ConversationEntity):
             return None
         return response
 
-    async def async_get_language_scores(self) -> dict[str, LanguageScores]:
-        """Get support scores per language."""
-        return await self.hass.async_add_executor_job(get_language_scores)
-
 
 def _make_error_result(
     language: str,
@@ -1672,7 +1589,7 @@ def _get_unmatched_response(result: RecognizeResult) -> tuple[ErrorKey, dict[str
 
 
 def _get_match_error_response(
-    hass: HomeAssistant,
+    hass: core.HomeAssistant,
     match_error: intent.MatchFailedError,
 ) -> tuple[ErrorKey, dict[str, Any]]:
     """Return key and template arguments for error when target matching fails."""
@@ -1807,75 +1724,3 @@ def _collect_list_references(expression: Expression, list_names: set[str]) -> No
     elif isinstance(expression, ListReference):
         # {list}
         list_names.add(expression.slot_name)
-
-
-def _get_debug_targets(
-    hass: HomeAssistant,
-    result: RecognizeResult,
-) -> Iterable[tuple[State, bool]]:
-    """Yield state/is_matched pairs for a hassil recognition."""
-    entities = result.entities
-
-    name: str | None = None
-    area_name: str | None = None
-    domains: set[str] | None = None
-    device_classes: set[str] | None = None
-    state_names: set[str] | None = None
-
-    if "name" in entities:
-        name = str(entities["name"].value)
-
-    if "area" in entities:
-        area_name = str(entities["area"].value)
-
-    if "domain" in entities:
-        domains = set(cv.ensure_list(entities["domain"].value))
-
-    if "device_class" in entities:
-        device_classes = set(cv.ensure_list(entities["device_class"].value))
-
-    if "state" in entities:
-        # HassGetState only
-        state_names = set(cv.ensure_list(entities["state"].value))
-
-    if (
-        (name is None)
-        and (area_name is None)
-        and (not domains)
-        and (not device_classes)
-        and (not state_names)
-    ):
-        # Avoid "matching" all entities when there is no filter
-        return
-
-    states = intent.async_match_states(
-        hass,
-        name=name,
-        area_name=area_name,
-        domains=domains,
-        device_classes=device_classes,
-    )
-
-    for state in states:
-        # For queries, a target is "matched" based on its state
-        is_matched = (state_names is None) or (state.state in state_names)
-        yield state, is_matched
-
-
-def _get_unmatched_slots(
-    result: RecognizeResult,
-) -> dict[str, str | int | float]:
-    """Return a dict of unmatched text/range slot entities."""
-    unmatched_slots: dict[str, str | int | float] = {}
-    for entity in result.unmatched_entities_list:
-        if isinstance(entity, UnmatchedTextEntity):
-            if entity.text == MISSING_ENTITY:
-                # Don't report <missing> since these are just missing context
-                # slots.
-                continue
-
-            unmatched_slots[entity.name] = entity.text
-        elif isinstance(entity, UnmatchedRangeEntity):
-            unmatched_slots[entity.name] = entity.value
-
-    return unmatched_slots

homeassistant/components/conversation/http.py

@@ -2,16 +2,21 @@
 
 from __future__ import annotations
 
+from collections.abc import Iterable
 from dataclasses import asdict
 from typing import Any
 
 from aiohttp import web
+from hassil.recognize import MISSING_ENTITY, RecognizeResult
+from hassil.string_matcher import UnmatchedRangeEntity, UnmatchedTextEntity
+from home_assistant_intents import get_language_scores
 import voluptuous as vol
 
 from homeassistant.components import http, websocket_api
 from homeassistant.components.http.data_validator import RequestDataValidator
 from homeassistant.const import MATCH_ALL
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import HomeAssistant, State, callback
+from homeassistant.helpers import config_validation as cv, intent
 from homeassistant.util import language as language_util
 
 from .agent_manager import (
@@ -21,6 +26,11 @@ from .agent_manager import (
     get_agent_manager,
 )
 from .const import DATA_COMPONENT
+from .default_agent import (
+    METADATA_CUSTOM_FILE,
+    METADATA_CUSTOM_SENTENCE,
+    METADATA_FUZZY_MATCH,
+)
 from .entity import ConversationEntity
 from .models import ConversationInput
 
@@ -196,12 +206,150 @@ async def websocket_hass_agent_debug(
             language=msg.get("language", hass.config.language),
             agent_id=agent.entity_id,
         )
-        result_dict = await agent.async_debug_recognize(user_input)
+        result_dict: dict[str, Any] | None = None
+
+        if trigger_result := await agent.async_recognize_sentence_trigger(user_input):
+            result_dict = {
+                # Matched a user-defined sentence trigger.
+                # We can't provide the response here without executing the
+                # trigger.
+                "match": True,
+                "source": "trigger",
+                "sentence_template": trigger_result.sentence_template or "",
+            }
+        elif intent_result := await agent.async_recognize_intent(user_input):
+            successful_match = not intent_result.unmatched_entities
+            result_dict = {
+                # Name of the matching intent (or the closest)
+                "intent": {
+                    "name": intent_result.intent.name,
+                },
+                # Slot values that would be received by the intent
+                "slots": {  # direct access to values
+                    entity_key: entity.text or entity.value
+                    for entity_key, entity in intent_result.entities.items()
+                },
+                # Extra slot details, such as the originally matched text
+                "details": {
+                    entity_key: {
+                        "name": entity.name,
+                        "value": entity.value,
+                        "text": entity.text,
+                    }
+                    for entity_key, entity in intent_result.entities.items()
+                },
+                # Entities/areas/etc. that would be targeted
+                "targets": {},
+                # True if match was successful
+                "match": successful_match,
+                # Text of the sentence template that matched (or was closest)
+                "sentence_template": "",
+                # When match is incomplete, this will contain the best slot guesses
+                "unmatched_slots": _get_unmatched_slots(intent_result),
+                # True if match was not exact
+                "fuzzy_match": False,
+            }
+
+            if successful_match:
+                result_dict["targets"] = {
+                    state.entity_id: {"matched": is_matched}
+                    for state, is_matched in _get_debug_targets(hass, intent_result)
+                }
+
+            if intent_result.intent_sentence is not None:
+                result_dict["sentence_template"] = intent_result.intent_sentence.text
+
+            if intent_result.intent_metadata:
+                # Inspect metadata to determine if this matched a custom sentence
+                if intent_result.intent_metadata.get(METADATA_CUSTOM_SENTENCE):
+                    result_dict["source"] = "custom"
+                    result_dict["file"] = intent_result.intent_metadata.get(
+                        METADATA_CUSTOM_FILE
+                    )
+                else:
+                    result_dict["source"] = "builtin"
+
+                result_dict["fuzzy_match"] = intent_result.intent_metadata.get(
+                    METADATA_FUZZY_MATCH, False
+                )
+
         result_dicts.append(result_dict)
 
     connection.send_result(msg["id"], {"results": result_dicts})
 
 
+def _get_debug_targets(
+    hass: HomeAssistant,
+    result: RecognizeResult,
+) -> Iterable[tuple[State, bool]]:
+    """Yield state/is_matched pairs for a hassil recognition."""
+    entities = result.entities
+
+    name: str | None = None
+    area_name: str | None = None
+    domains: set[str] | None = None
+    device_classes: set[str] | None = None
+    state_names: set[str] | None = None
+
+    if "name" in entities:
+        name = str(entities["name"].value)
+
+    if "area" in entities:
+        area_name = str(entities["area"].value)
+
+    if "domain" in entities:
+        domains = set(cv.ensure_list(entities["domain"].value))
+
+    if "device_class" in entities:
+        device_classes = set(cv.ensure_list(entities["device_class"].value))
+
+    if "state" in entities:
+        # HassGetState only
+        state_names = set(cv.ensure_list(entities["state"].value))
+
+    if (
+        (name is None)
+        and (area_name is None)
+        and (not domains)
+        and (not device_classes)
+        and (not state_names)
+    ):
+        # Avoid "matching" all entities when there is no filter
+        return
+
+    states = intent.async_match_states(
+        hass,
+        name=name,
+        area_name=area_name,
+        domains=domains,
+        device_classes=device_classes,
+    )
+
+    for state in states:
+        # For queries, a target is "matched" based on its state
+        is_matched = (state_names is None) or (state.state in state_names)
+        yield state, is_matched
+
+
+def _get_unmatched_slots(
+    result: RecognizeResult,
+) -> dict[str, str | int | float]:
+    """Return a dict of unmatched text/range slot entities."""
+    unmatched_slots: dict[str, str | int | float] = {}
+    for entity in result.unmatched_entities_list:
+        if isinstance(entity, UnmatchedTextEntity):
+            if entity.text == MISSING_ENTITY:
+                # Don't report <missing> since these are just missing context
+                # slots.
+                continue
+
+            unmatched_slots[entity.name] = entity.text
+        elif isinstance(entity, UnmatchedRangeEntity):
+            unmatched_slots[entity.name] = entity.value
+
+    return unmatched_slots
+
+
 @websocket_api.websocket_command(
     {
         vol.Required("type"): "conversation/agent/homeassistant/language_scores",
@@ -216,13 +364,10 @@ async def websocket_hass_agent_language_scores(
     msg: dict[str, Any],
 ) -> None:
     """Get support scores per language."""
-    agent = get_agent_manager(hass).default_agent
-    assert agent is not None
-
     language = msg.get("language", hass.config.language)
     country = msg.get("country", hass.config.country)
 
-    scores = await agent.async_get_language_scores()
+    scores = await hass.async_add_executor_job(get_language_scores)
     matching_langs = language_util.matches(language, scores.keys(), country=country)
     preferred_lang = matching_langs[0] if matching_langs else language
     result = {

homeassistant/components/cover/__init__.py

@@ -13,7 +13,7 @@ from propcache.api import cached_property
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import (
+from homeassistant.const import (  # noqa: F401
     SERVICE_CLOSE_COVER,
     SERVICE_CLOSE_COVER_TILT,
     SERVICE_OPEN_COVER,
@@ -24,9 +24,19 @@ from homeassistant.const import (
     SERVICE_STOP_COVER_TILT,
     SERVICE_TOGGLE,
     SERVICE_TOGGLE_COVER_TILT,
+    STATE_CLOSED,
+    STATE_CLOSING,
+    STATE_OPEN,
+    STATE_OPENING,
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.deprecation import (
+    DeprecatedConstantEnum,
+    all_with_deprecated_constants,
+    check_if_deprecated_constant,
+    dir_with_deprecated_constants,
+)
 from homeassistant.helpers.entity import Entity, EntityDescription
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.typing import ConfigType
@@ -53,6 +63,15 @@ class CoverState(StrEnum):
     OPENING = "opening"
 
 
+# STATE_* below are deprecated as of 2024.11
+# when imported from homeassistant.components.cover
+# use the CoverState enum instead.
+_DEPRECATED_STATE_CLOSED = DeprecatedConstantEnum(CoverState.CLOSED, "2025.11")
+_DEPRECATED_STATE_CLOSING = DeprecatedConstantEnum(CoverState.CLOSING, "2025.11")
+_DEPRECATED_STATE_OPEN = DeprecatedConstantEnum(CoverState.OPEN, "2025.11")
+_DEPRECATED_STATE_OPENING = DeprecatedConstantEnum(CoverState.OPENING, "2025.11")
+
+
 class CoverDeviceClass(StrEnum):
     """Device class for cover."""
 
@@ -444,3 +463,11 @@ class CoverEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
         return (
             fns["close"] if self._cover_is_last_toggle_direction_open else fns["open"]
         )
+
+
+# These can be removed if no deprecated constant are in this module anymore
+__getattr__ = ft.partial(check_if_deprecated_constant, module_globals=globals())
+__dir__ = ft.partial(
+    dir_with_deprecated_constants, module_globals_keys=[*globals().keys()]
+)
+__all__ = all_with_deprecated_constants(globals())

homeassistant/components/duke_energy/coordinator.py

@@ -24,7 +24,6 @@ from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 from homeassistant.util import dt as dt_util
-from homeassistant.util.unit_conversion import EnergyConverter
 
 from .const import DOMAIN
 
@@ -147,7 +146,6 @@ class DukeEnergyCoordinator(DataUpdateCoordinator[None]):
                 name=f"{name_prefix} Consumption",
                 source=DOMAIN,
                 statistic_id=consumption_statistic_id,
-                unit_class=EnergyConverter.UNIT_CLASS,
                 unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR
                 if meter["serviceType"] == "ELECTRIC"
                 else UnitOfVolume.CENTUM_CUBIC_FEET,

homeassistant/components/ecovacs/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/ecovacs",
   "iot_class": "cloud_push",
   "loggers": ["sleekxmppfs", "sucks", "deebot_client"],
-  "requirements": ["py-sucks==0.9.11", "deebot-client==15.1.0"]
+  "requirements": ["py-sucks==0.9.11", "deebot-client==15.0.0"]
 }

homeassistant/components/elevenlabs/__init__.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-import logging
 
 from elevenlabs import AsyncElevenLabs, Model
 from elevenlabs.core import ApiError
@@ -19,14 +18,9 @@ from homeassistant.exceptions import (
 )
 from homeassistant.helpers.httpx_client import get_async_client
 
-from .const import CONF_MODEL, CONF_STT_MODEL
+from .const import CONF_MODEL
 
-_LOGGER = logging.getLogger(__name__)
-
-PLATFORMS: list[Platform] = [
-    Platform.STT,
-    Platform.TTS,
-]
+PLATFORMS: list[Platform] = [Platform.TTS]
 
 
 async def get_model_by_id(client: AsyncElevenLabs, model_id: str) -> Model | None:
@@ -45,7 +39,6 @@ class ElevenLabsData:
 
     client: AsyncElevenLabs
     model: Model
-    stt_model: str
 
 
 type ElevenLabsConfigEntry = ConfigEntry[ElevenLabsData]
@@ -69,9 +62,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ElevenLabsConfigEntry) -
     if model is None or (not model.languages):
         raise ConfigEntryError("Model could not be resolved")
 
-    entry.runtime_data = ElevenLabsData(
-        client=client, model=model, stt_model=entry.options[CONF_STT_MODEL]
-    )
+    entry.runtime_data = ElevenLabsData(client=client, model=model)
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
     return True
@@ -87,44 +78,3 @@ async def update_listener(
 ) -> None:
     """Handle options update."""
     await hass.config_entries.async_reload(config_entry.entry_id)
-
-
-async def async_migrate_entry(
-    hass: HomeAssistant, config_entry: ElevenLabsConfigEntry
-) -> bool:
-    """Migrate old config entry to new format."""
-
-    _LOGGER.debug(
-        "Migrating configuration from version %s.%s",
-        config_entry.version,
-        config_entry.minor_version,
-    )
-
-    if config_entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False
-
-    if config_entry.version == 1:
-        new_options = {**config_entry.options}
-
-        if config_entry.minor_version < 2:
-            # Add defaults only if they’re not already present
-            if "stt_auto_language" not in new_options:
-                new_options["stt_auto_language"] = False
-            if "stt_model" not in new_options:
-                new_options["stt_model"] = "scribe_v1"
-
-        hass.config_entries.async_update_entry(
-            config_entry,
-            options=new_options,
-            minor_version=2,
-            version=1,
-        )
-
-    _LOGGER.debug(
-        "Migration to configuration version %s.%s successful",
-        config_entry.version,
-        config_entry.minor_version,
-    )
-
-    return True  # already up to date

homeassistant/components/elevenlabs/config_flow.py

@@ -25,20 +25,15 @@ from .const import (
     CONF_MODEL,
     CONF_SIMILARITY,
     CONF_STABILITY,
-    CONF_STT_AUTO_LANGUAGE,
-    CONF_STT_MODEL,
     CONF_STYLE,
     CONF_USE_SPEAKER_BOOST,
     CONF_VOICE,
+    DEFAULT_MODEL,
     DEFAULT_SIMILARITY,
     DEFAULT_STABILITY,
-    DEFAULT_STT_AUTO_LANGUAGE,
-    DEFAULT_STT_MODEL,
     DEFAULT_STYLE,
-    DEFAULT_TTS_MODEL,
     DEFAULT_USE_SPEAKER_BOOST,
     DOMAIN,
-    STT_MODELS,
 )
 
 USER_STEP_SCHEMA = vol.Schema({vol.Required(CONF_API_KEY): str})
@@ -73,7 +68,6 @@ class ElevenLabsConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for ElevenLabs text-to-speech."""
 
     VERSION = 1
-    MINOR_VERSION = 2
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
@@ -94,12 +88,7 @@ class ElevenLabsConfigFlow(ConfigFlow, domain=DOMAIN):
                 return self.async_create_entry(
                     title="ElevenLabs",
                     data=user_input,
-                    options={
-                        CONF_MODEL: DEFAULT_TTS_MODEL,
-                        CONF_VOICE: list(voices)[0],
-                        CONF_STT_MODEL: DEFAULT_STT_MODEL,
-                        CONF_STT_AUTO_LANGUAGE: False,
-                    },
+                    options={CONF_MODEL: DEFAULT_MODEL, CONF_VOICE: list(voices)[0]},
                 )
         return self.async_show_form(
             step_id="user", data_schema=USER_STEP_SCHEMA, errors=errors
@@ -124,9 +113,6 @@ class ElevenLabsOptionsFlow(OptionsFlow):
         self.models: dict[str, str] = {}
         self.model: str | None = None
         self.voice: str | None = None
-        self.stt_models: dict[str, str] = STT_MODELS
-        self.stt_model: str | None = None
-        self.auto_language: bool | None = None
 
     async def async_step_init(
         self, user_input: dict[str, Any] | None = None
@@ -140,8 +126,6 @@ class ElevenLabsOptionsFlow(OptionsFlow):
         if user_input is not None:
             self.model = user_input[CONF_MODEL]
             self.voice = user_input[CONF_VOICE]
-            self.stt_model = user_input[CONF_STT_MODEL]
-            self.auto_language = user_input[CONF_STT_AUTO_LANGUAGE]
             configure_voice = user_input.pop(CONF_CONFIGURE_VOICE)
             if configure_voice:
                 return await self.async_step_voice_settings()
@@ -181,22 +165,6 @@ class ElevenLabsOptionsFlow(OptionsFlow):
                             ]
                         )
                     ),
-                    vol.Required(
-                        CONF_STT_MODEL,
-                    ): SelectSelector(
-                        SelectSelectorConfig(
-                            options=[
-                                SelectOptionDict(label=model_name, value=model_id)
-                                for model_id, model_name in self.stt_models.items()
-                            ]
-                        )
-                    ),
-                    vol.Required(
-                        CONF_STT_AUTO_LANGUAGE,
-                        default=self.config_entry.options.get(
-                            CONF_STT_AUTO_LANGUAGE, DEFAULT_STT_AUTO_LANGUAGE
-                        ),
-                    ): bool,
                     vol.Required(CONF_CONFIGURE_VOICE, default=False): bool,
                 }
             ),
@@ -211,8 +179,6 @@ class ElevenLabsOptionsFlow(OptionsFlow):
         if user_input is not None:
             user_input[CONF_MODEL] = self.model
             user_input[CONF_VOICE] = self.voice
-            user_input[CONF_STT_MODEL] = self.stt_model
-            user_input[CONF_STT_AUTO_LANGUAGE] = self.auto_language
             return self.async_create_entry(
                 title="ElevenLabs",
                 data=user_input,

homeassistant/components/elevenlabs/const.py

@@ -7,123 +7,12 @@ CONF_MODEL = "model"
 CONF_CONFIGURE_VOICE = "configure_voice"
 CONF_STABILITY = "stability"
 CONF_SIMILARITY = "similarity"
-CONF_STT_AUTO_LANGUAGE = "stt_auto_language"
-CONF_STT_MODEL = "stt_model"
 CONF_STYLE = "style"
 CONF_USE_SPEAKER_BOOST = "use_speaker_boost"
 DOMAIN = "elevenlabs"
 
-DEFAULT_TTS_MODEL = "eleven_multilingual_v2"
+DEFAULT_MODEL = "eleven_multilingual_v2"
 DEFAULT_STABILITY = 0.5
 DEFAULT_SIMILARITY = 0.75
-DEFAULT_STT_AUTO_LANGUAGE = False
-DEFAULT_STT_MODEL = "scribe_v1"
 DEFAULT_STYLE = 0
 DEFAULT_USE_SPEAKER_BOOST = True
-
-STT_LANGUAGES = [
-    "af-ZA",  # Afrikaans
-    "am-ET",  # Amharic
-    "ar-SA",  # Arabic
-    "hy-AM",  # Armenian
-    "as-IN",  # Assamese
-    "ast-ES",  # Asturian
-    "az-AZ",  # Azerbaijani
-    "be-BY",  # Belarusian
-    "bn-IN",  # Bengali
-    "bs-BA",  # Bosnian
-    "bg-BG",  # Bulgarian
-    "my-MM",  # Burmese
-    "yue-HK",  # Cantonese
-    "ca-ES",  # Catalan
-    "ceb-PH",  # Cebuano
-    "ny-MW",  # Chichewa
-    "hr-HR",  # Croatian
-    "cs-CZ",  # Czech
-    "da-DK",  # Danish
-    "nl-NL",  # Dutch
-    "en-US",  # English
-    "et-EE",  # Estonian
-    "fil-PH",  # Filipino
-    "fi-FI",  # Finnish
-    "fr-FR",  # French
-    "ff-SN",  # Fulah
-    "gl-ES",  # Galician
-    "lg-UG",  # Ganda
-    "ka-GE",  # Georgian
-    "de-DE",  # German
-    "el-GR",  # Greek
-    "gu-IN",  # Gujarati
-    "ha-NG",  # Hausa
-    "he-IL",  # Hebrew
-    "hi-IN",  # Hindi
-    "hu-HU",  # Hungarian
-    "is-IS",  # Icelandic
-    "ig-NG",  # Igbo
-    "id-ID",  # Indonesian
-    "ga-IE",  # Irish
-    "it-IT",  # Italian
-    "ja-JP",  # Japanese
-    "jv-ID",  # Javanese
-    "kea-CV",  # Kabuverdianu
-    "kn-IN",  # Kannada
-    "kk-KZ",  # Kazakh
-    "km-KH",  # Khmer
-    "ko-KR",  # Korean
-    "ku-TR",  # Kurdish
-    "ky-KG",  # Kyrgyz
-    "lo-LA",  # Lao
-    "lv-LV",  # Latvian
-    "ln-CD",  # Lingala
-    "lt-LT",  # Lithuanian
-    "luo-KE",  # Luo
-    "lb-LU",  # Luxembourgish
-    "mk-MK",  # Macedonian
-    "ms-MY",  # Malay
-    "ml-IN",  # Malayalam
-    "mt-MT",  # Maltese
-    "zh-CN",  # Mandarin Chinese
-    "mi-NZ",  # Māori
-    "mr-IN",  # Marathi
-    "mn-MN",  # Mongolian
-    "ne-NP",  # Nepali
-    "nso-ZA",  # Northern Sotho
-    "no-NO",  # Norwegian
-    "oc-FR",  # Occitan
-    "or-IN",  # Odia
-    "ps-AF",  # Pashto
-    "fa-IR",  # Persian
-    "pl-PL",  # Polish
-    "pt-PT",  # Portuguese
-    "pa-IN",  # Punjabi
-    "ro-RO",  # Romanian
-    "ru-RU",  # Russian
-    "sr-RS",  # Serbian
-    "sn-ZW",  # Shona
-    "sd-PK",  # Sindhi
-    "sk-SK",  # Slovak
-    "sl-SI",  # Slovenian
-    "so-SO",  # Somali
-    "es-ES",  # Spanish
-    "sw-KE",  # Swahili
-    "sv-SE",  # Swedish
-    "ta-IN",  # Tamil
-    "tg-TJ",  # Tajik
-    "te-IN",  # Telugu
-    "th-TH",  # Thai
-    "tr-TR",  # Turkish
-    "uk-UA",  # Ukrainian
-    "umb-AO",  # Umbundu
-    "ur-PK",  # Urdu
-    "uz-UZ",  # Uzbek
-    "vi-VN",  # Vietnamese
-    "cy-GB",  # Welsh
-    "wo-SN",  # Wolof
-    "xh-ZA",  # Xhosa
-    "zu-ZA",  # Zulu
-]
-
-STT_MODELS = {
-    "scribe_v1": "Scribe v1",
-    "scribe_v1_experimental": "Scribe v1 Experimental",
-}

homeassistant/components/elevenlabs/strings.json

@@ -21,15 +21,11 @@
         "data": {
           "voice": "Voice",
           "model": "Model",
-          "stt_model": "Speech-to-Text Model",
-          "stt_auto_language": "Auto-detect language",
           "configure_voice": "Configure advanced voice settings"
         },
         "data_description": {
-          "voice": "Voice to use for text-to-speech.",
+          "voice": "Voice to use for the TTS.",
           "model": "ElevenLabs model to use. Please note that not all models support all languages equally well.",
-          "stt_model": "Speech-to-Text model to use.",
-          "stt_auto_language": "Automatically detect the spoken language for speech-to-text.",
           "configure_voice": "Configure advanced voice settings. Find more information in the ElevenLabs documentation."
         }
       },
@@ -48,17 +44,5 @@
         }
       }
     }
-  },
-  "entity": {
-    "tts": {
-      "elevenlabs_tts": {
-        "name": "Text-to-Speech"
-      }
-    },
-    "stt": {
-      "elevenlabs_stt": {
-        "name": "Speech-to-Text"
-      }
-    }
   }
 }

homeassistant/components/elevenlabs/stt.py

@@ -1,207 +0,0 @@
-"""Support for the ElevenLabs speech-to-text service."""
-
-from __future__ import annotations
-
-from collections.abc import AsyncIterable
-from io import BytesIO
-import logging
-
-from elevenlabs import AsyncElevenLabs
-from elevenlabs.core import ApiError
-from elevenlabs.types import Model
-
-from homeassistant.components import stt
-from homeassistant.components.stt import (
-    AudioBitRates,
-    AudioChannels,
-    AudioCodecs,
-    AudioFormats,
-    AudioSampleRates,
-    SpeechMetadata,
-    SpeechResultState,
-    SpeechToTextEntity,
-)
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from . import ElevenLabsConfigEntry
-from .const import (
-    CONF_STT_AUTO_LANGUAGE,
-    DEFAULT_STT_AUTO_LANGUAGE,
-    DOMAIN,
-    STT_LANGUAGES,
-)
-
-_LOGGER = logging.getLogger(__name__)
-PARALLEL_UPDATES = 10
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config_entry: ElevenLabsConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up ElevenLabs stt platform via config entry."""
-    client = config_entry.runtime_data.client
-    auto_detect = config_entry.options.get(
-        CONF_STT_AUTO_LANGUAGE, DEFAULT_STT_AUTO_LANGUAGE
-    )
-
-    async_add_entities(
-        [
-            ElevenLabsSTTEntity(
-                client,
-                config_entry.runtime_data.model,
-                config_entry.runtime_data.stt_model,
-                config_entry.entry_id,
-                auto_detect_language=auto_detect,
-            )
-        ]
-    )
-
-
-class ElevenLabsSTTEntity(SpeechToTextEntity):
-    """The ElevenLabs STT API entity."""
-
-    _attr_has_entity_name = True
-    _attr_translation_key = "elevenlabs_stt"
-
-    def __init__(
-        self,
-        client: AsyncElevenLabs,
-        model: Model,
-        stt_model: str,
-        entry_id: str,
-        auto_detect_language: bool = False,
-    ) -> None:
-        """Init ElevenLabs TTS service."""
-        self._client = client
-        self._auto_detect_language = auto_detect_language
-        self._stt_model = stt_model
-
-        # Entity attributes
-        self._attr_unique_id = entry_id
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, entry_id)},
-            manufacturer="ElevenLabs",
-            model=model.name,
-            name="ElevenLabs",
-            entry_type=DeviceEntryType.SERVICE,
-        )
-
-    @property
-    def supported_languages(self) -> list[str]:
-        """Return a list of supported languages."""
-        return STT_LANGUAGES
-
-    @property
-    def supported_formats(self) -> list[AudioFormats]:
-        """Return a list of supported formats."""
-        return [AudioFormats.WAV, AudioFormats.OGG]
-
-    @property
-    def supported_codecs(self) -> list[AudioCodecs]:
-        """Return a list of supported codecs."""
-        return [AudioCodecs.PCM, AudioCodecs.OPUS]
-
-    @property
-    def supported_bit_rates(self) -> list[AudioBitRates]:
-        """Return a list of supported bit rates."""
-        return [AudioBitRates.BITRATE_16]
-
-    @property
-    def supported_sample_rates(self) -> list[AudioSampleRates]:
-        """Return a list of supported sample rates."""
-        return [AudioSampleRates.SAMPLERATE_16000]
-
-    @property
-    def supported_channels(self) -> list[AudioChannels]:
-        """Return a list of supported channels."""
-        return [
-            AudioChannels.CHANNEL_MONO,
-            AudioChannels.CHANNEL_STEREO,
-        ]
-
-    async def async_process_audio_stream(
-        self, metadata: SpeechMetadata, stream: AsyncIterable[bytes]
-    ) -> stt.SpeechResult:
-        """Process an audio stream to STT service."""
-        _LOGGER.debug(
-            "Processing audio stream for STT: model=%s, language=%s, format=%s, codec=%s, sample_rate=%s, channels=%s, bit_rate=%s",
-            self._stt_model,
-            metadata.language,
-            metadata.format,
-            metadata.codec,
-            metadata.sample_rate,
-            metadata.channel,
-            metadata.bit_rate,
-        )
-
-        if self._auto_detect_language:
-            lang_code = None
-        else:
-            language = metadata.language
-            if language.lower() not in [lang.lower() for lang in STT_LANGUAGES]:
-                _LOGGER.warning("Unsupported language: %s", language)
-                return stt.SpeechResult(None, SpeechResultState.ERROR)
-            lang_code = language.split("-")[0]
-
-        raw_pcm_compatible = (
-            metadata.codec == AudioCodecs.PCM
-            and metadata.sample_rate == AudioSampleRates.SAMPLERATE_16000
-            and metadata.channel == AudioChannels.CHANNEL_MONO
-            and metadata.bit_rate == AudioBitRates.BITRATE_16
-        )
-        if raw_pcm_compatible:
-            file_format = "pcm_s16le_16"
-        elif metadata.codec == AudioCodecs.PCM:
-            _LOGGER.warning("PCM input does not meet expected raw format requirements")
-            return stt.SpeechResult(None, SpeechResultState.ERROR)
-        else:
-            file_format = "other"
-
-        audio = b""
-        async for chunk in stream:
-            audio += chunk
-
-        _LOGGER.debug("Finished reading audio stream, total size: %d bytes", len(audio))
-        if not audio:
-            _LOGGER.warning("No audio received in stream")
-            return stt.SpeechResult(None, SpeechResultState.ERROR)
-
-        lang_display = lang_code if lang_code else "auto-detected"
-
-        _LOGGER.debug(
-            "Transcribing audio (%s), format: %s, size: %d bytes",
-            lang_display,
-            file_format,
-            len(audio),
-        )
-
-        try:
-            response = await self._client.speech_to_text.convert(
-                file=BytesIO(audio),
-                file_format=file_format,
-                model_id=self._stt_model,
-                language_code=lang_code,
-                tag_audio_events=False,
-                num_speakers=1,
-                diarize=False,
-            )
-        except ApiError as exc:
-            _LOGGER.error("Error during processing of STT request: %s", exc)
-            return stt.SpeechResult(None, SpeechResultState.ERROR)
-
-        text = response.text or ""
-        detected_lang_code = response.language_code or "?"
-        detected_lang_prob = response.language_probability or "?"
-
-        _LOGGER.debug(
-            "Transcribed text is in language %s (probability %s): %s",
-            detected_lang_code,
-            detected_lang_prob,
-            text,
-        )
-
-        return stt.SpeechResult(text, SpeechResultState.SUCCESS)

homeassistant/components/elevenlabs/tts.py

@@ -71,6 +71,7 @@ async def async_setup_entry(
                 voices,
                 default_voice_id,
                 config_entry.entry_id,
+                config_entry.title,
                 voice_settings,
             )
         ]
@@ -82,8 +83,6 @@ class ElevenLabsTTSEntity(TextToSpeechEntity):
 
     _attr_supported_options = [ATTR_VOICE, ATTR_MODEL]
     _attr_entity_category = EntityCategory.CONFIG
-    _attr_has_entity_name = True
-    _attr_translation_key = "elevenlabs_tts"
 
     def __init__(
         self,
@@ -92,6 +91,7 @@ class ElevenLabsTTSEntity(TextToSpeechEntity):
         voices: list[ElevenLabsVoice],
         default_voice_id: str,
         entry_id: str,
+        title: str,
         voice_settings: VoiceSettings,
     ) -> None:
         """Init ElevenLabs TTS service."""
@@ -112,11 +112,11 @@ class ElevenLabsTTSEntity(TextToSpeechEntity):
 
         # Entity attributes
         self._attr_unique_id = entry_id
+        self._attr_name = title
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, entry_id)},
             manufacturer="ElevenLabs",
             model=model.name,
-            name="ElevenLabs",
             entry_type=DeviceEntryType.SERVICE,
         )
         self._attr_supported_languages = [

homeassistant/components/elvia/importer.py

@@ -20,7 +20,6 @@ from homeassistant.components.recorder.statistics import (
 from homeassistant.components.recorder.util import get_instance
 from homeassistant.const import UnitOfEnergy
 from homeassistant.util import dt as dt_util
-from homeassistant.util.unit_conversion import EnergyConverter
 
 from .const import DOMAIN, LOGGER
 
@@ -154,7 +153,6 @@ class ElviaImporter:
                 name=f"{self.metering_point_id} Consumption",
                 source=DOMAIN,
                 statistic_id=statistic_id,
-                unit_class=EnergyConverter.UNIT_CLASS,
                 unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
             ),
             statistics=statistics,

homeassistant/components/environment_canada/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/environment_canada",
   "iot_class": "cloud_polling",
   "loggers": ["env_canada"],
-  "requirements": ["env-canada==0.11.3"]
+  "requirements": ["env-canada==0.11.2"]
 }

homeassistant/components/esphome/manifest.json

@@ -17,7 +17,7 @@
   "mqtt": ["esphome/discover/#"],
   "quality_scale": "platinum",
   "requirements": [
-    "aioesphomeapi==41.13.0",
+    "aioesphomeapi==41.12.0",
     "esphome-dashboard-api==1.3.0",
     "bleak-esphome==3.4.0"
   ],

homeassistant/components/evohome/climate.py

@@ -29,12 +29,7 @@ from homeassistant.components.climate import (
     ClimateEntityFeature,
     HVACMode,
 )
-from homeassistant.const import (
-    ATTR_MODE,
-    ATTR_TEMPERATURE,
-    PRECISION_TENTHS,
-    UnitOfTemperature,
-)
+from homeassistant.const import ATTR_MODE, PRECISION_TENTHS, UnitOfTemperature
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
@@ -248,7 +243,7 @@ class EvoZone(EvoChild, EvoClimateEntity):
     async def async_set_temperature(self, **kwargs: Any) -> None:
         """Set a new target temperature."""
 
-        temperature = kwargs[ATTR_TEMPERATURE]
+        temperature = kwargs["temperature"]
 
         if (until := kwargs.get("until")) is None:
             if self._evo_device.mode == EvoZoneMode.TEMPORARY_OVERRIDE:

homeassistant/components/fritzbox/climate.py

@@ -13,14 +13,27 @@ from homeassistant.components.climate import (
     ClimateEntityFeature,
     HVACMode,
 )
-from homeassistant.const import ATTR_TEMPERATURE, PRECISION_HALVES, UnitOfTemperature
+from homeassistant.const import (
+    ATTR_BATTERY_LEVEL,
+    ATTR_TEMPERATURE,
+    PRECISION_HALVES,
+    UnitOfTemperature,
+)
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import DOMAIN, LOGGER
+from .const import (
+    ATTR_STATE_BATTERY_LOW,
+    ATTR_STATE_HOLIDAY_MODE,
+    ATTR_STATE_SUMMER_MODE,
+    ATTR_STATE_WINDOW_OPEN,
+    DOMAIN,
+    LOGGER,
+)
 from .coordinator import FritzboxConfigEntry, FritzboxDataUpdateCoordinator
 from .entity import FritzBoxDeviceEntity
+from .model import ClimateExtraAttributes
 from .sensor import value_scheduled_preset
 
 HVAC_MODES = [HVACMode.HEAT, HVACMode.OFF]
@@ -189,6 +202,26 @@ class FritzboxThermostat(FritzBoxDeviceEntity, ClimateEntity):
         self.check_active_or_lock_mode()
         await self.async_set_hkr_state(PRESET_API_HKR_STATE_MAPPING[preset_mode])
 
+    @property
+    def extra_state_attributes(self) -> ClimateExtraAttributes:
+        """Return the device specific state attributes."""
+        # deprecated with #143394, can be removed in 2025.11
+        attrs: ClimateExtraAttributes = {
+            ATTR_STATE_BATTERY_LOW: self.data.battery_low,
+        }
+
+        # the following attributes are available since fritzos 7
+        if self.data.battery_level is not None:
+            attrs[ATTR_BATTERY_LEVEL] = self.data.battery_level
+        if self.data.holiday_active is not None:
+            attrs[ATTR_STATE_HOLIDAY_MODE] = self.data.holiday_active
+        if self.data.summer_active is not None:
+            attrs[ATTR_STATE_SUMMER_MODE] = self.data.summer_active
+        if self.data.window_open is not None:
+            attrs[ATTR_STATE_WINDOW_OPEN] = self.data.window_open
+
+        return attrs
+
     def check_active_or_lock_mode(self) -> None:
         """Check if in summer/vacation mode or lock enabled."""
         if self.data.holiday_active or self.data.summer_active:

homeassistant/components/frontend/manifest.json

@@ -20,5 +20,5 @@
   "documentation": "https://www.home-assistant.io/integrations/frontend",
   "integration_type": "system",
   "quality_scale": "internal",
-  "requirements": ["home-assistant-frontend==20251001.4"]
+  "requirements": ["home-assistant-frontend==20251001.0"]
 }

homeassistant/components/github/coordinator.py

@@ -167,6 +167,6 @@ class GitHubDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         )
         self.hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, self.unsubscribe)
 
-    def unsubscribe(self, *args: Any) -> None:
+    def unsubscribe(self, *args) -> None:
         """Unsubscribe to repository events."""
         self._client.repos.events.unsubscribe(subscription_id=self._subscription_id)

homeassistant/components/google_assistant/trait.py

@@ -182,10 +182,10 @@ FAN_SPEED_MAX_SPEED_COUNT = 5
 
 COVER_VALVE_STATES = {
     cover.DOMAIN: {
-        "closed": cover.CoverState.CLOSED.value,
-        "closing": cover.CoverState.CLOSING.value,
-        "open": cover.CoverState.OPEN.value,
-        "opening": cover.CoverState.OPENING.value,
+        "closed": cover.STATE_CLOSED,
+        "closing": cover.STATE_CLOSING,
+        "open": cover.STATE_OPEN,
+        "opening": cover.STATE_OPENING,
     },
     valve.DOMAIN: {
         "closed": valve.STATE_CLOSED,

homeassistant/components/google_assistant_sdk/config_flow.py

@@ -8,12 +8,7 @@ from typing import Any
 
 import voluptuous as vol
 
-from homeassistant.config_entries import (
-    SOURCE_REAUTH,
-    SOURCE_RECONFIGURE,
-    ConfigFlowResult,
-    OptionsFlow,
-)
+from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlowResult, OptionsFlow
 from homeassistant.core import callback
 from homeassistant.helpers import config_entry_oauth2_flow
 
@@ -45,12 +40,6 @@ class OAuth2FlowHandler(
             "prompt": "consent",
         }
 
-    async def async_step_reconfigure(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle a reconfiguration flow."""
-        return await self.async_step_user(user_input)
-
     async def async_step_reauth(
         self, entry_data: Mapping[str, Any]
     ) -> ConfigFlowResult:
@@ -71,10 +60,6 @@ class OAuth2FlowHandler(
             return self.async_update_reload_and_abort(
                 self._get_reauth_entry(), data=data
             )
-        if self.source == SOURCE_RECONFIGURE:
-            return self.async_update_reload_and_abort(
-                self._get_reconfigure_entry(), data=data
-            )
 
         return self.async_create_entry(
             title=DEFAULT_NAME,

homeassistant/components/google_assistant_sdk/strings.json

@@ -30,8 +30,7 @@
       "oauth_failed": "[%key:common::config_flow::abort::oauth2_failed%]",
       "already_configured": "[%key:common::config_flow::abort::already_configured_account%]",
       "already_in_progress": "[%key:common::config_flow::abort::already_in_progress%]",
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
-      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]"
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
     },
     "create_entry": {
       "default": "[%key:common::config_flow::create_entry::authenticated%]"

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.82", "babel==2.15.0"]
+  "requirements": ["holidays==0.81", "babel==2.15.0"]
 }

homeassistant/components/home_connect/const.py

@@ -99,20 +99,6 @@ CLEANING_MODE_OPTIONS = {
         "ConsumerProducts.CleaningRobot.EnumType.CleaningModes.Silent",
         "ConsumerProducts.CleaningRobot.EnumType.CleaningModes.Standard",
         "ConsumerProducts.CleaningRobot.EnumType.CleaningModes.Power",
-        "ConsumerProducts.CleaningRobot.EnumType.CleaningMode.IntelligentMode",
-        "ConsumerProducts.CleaningRobot.EnumType.CleaningMode.VacuumOnly",
-        "ConsumerProducts.CleaningRobot.EnumType.CleaningMode.MopOnly",
-        "ConsumerProducts.CleaningRobot.EnumType.CleaningMode.VacuumAndMop",
-        "ConsumerProducts.CleaningRobot.EnumType.CleaningMode.MopAfterVacuum",
-    )
-}
-
-SUCTION_POWER_OPTIONS = {
-    bsh_key_to_translation_key(option): option
-    for option in (
-        "ConsumerProducts.CleaningRobot.EnumType.SuctionPower.Silent",
-        "ConsumerProducts.CleaningRobot.EnumType.SuctionPower.Standard",
-        "ConsumerProducts.CleaningRobot.EnumType.SuctionPower.Max",
     )
 }
 
@@ -323,10 +309,6 @@ PROGRAM_ENUM_OPTIONS = {
             OptionKey.CONSUMER_PRODUCTS_CLEANING_ROBOT_CLEANING_MODE,
             CLEANING_MODE_OPTIONS,
         ),
-        (
-            OptionKey.CONSUMER_PRODUCTS_CLEANING_ROBOT_SUCTION_POWER,
-            SUCTION_POWER_OPTIONS,
-        ),
         (OptionKey.CONSUMER_PRODUCTS_COFFEE_MAKER_BEAN_AMOUNT, BEAN_AMOUNT_OPTIONS),
         (
             OptionKey.CONSUMER_PRODUCTS_COFFEE_MAKER_COFFEE_TEMPERATURE,

homeassistant/components/home_connect/select.py

@@ -30,7 +30,6 @@ from .const import (
     INTENSIVE_LEVEL_OPTIONS,
     PROGRAMS_TRANSLATION_KEYS_MAP,
     SPIN_SPEED_OPTIONS,
-    SUCTION_POWER_OPTIONS,
     TEMPERATURE_OPTIONS,
     TRANSLATION_KEYS_PROGRAMS_MAP,
     VARIO_PERFECT_OPTIONS,
@@ -169,16 +168,6 @@ PROGRAM_SELECT_OPTION_ENTITY_DESCRIPTIONS = (
             for translation_key, value in CLEANING_MODE_OPTIONS.items()
         },
     ),
-    HomeConnectSelectEntityDescription(
-        key=OptionKey.CONSUMER_PRODUCTS_CLEANING_ROBOT_SUCTION_POWER,
-        translation_key="suction_power",
-        options=list(SUCTION_POWER_OPTIONS),
-        translation_key_values=SUCTION_POWER_OPTIONS,
-        values_translation_key={
-            value: translation_key
-            for translation_key, value in SUCTION_POWER_OPTIONS.items()
-        },
-    ),
     HomeConnectSelectEntityDescription(
         key=OptionKey.CONSUMER_PRODUCTS_COFFEE_MAKER_BEAN_AMOUNT,
         translation_key="bean_amount",

homeassistant/components/home_connect/services.yaml

@@ -202,22 +202,6 @@ set_program_and_options:
                 - consumer_products_cleaning_robot_enum_type_cleaning_modes_silent
                 - consumer_products_cleaning_robot_enum_type_cleaning_modes_standard
                 - consumer_products_cleaning_robot_enum_type_cleaning_modes_power
-                - consumer_products_cleaning_robot_enum_type_cleaning_mode_intelligent_mode
-                - consumer_products_cleaning_robot_enum_type_cleaning_mode_vacuum_only
-                - consumer_products_cleaning_robot_enum_type_cleaning_mode_mop_only
-                - consumer_products_cleaning_robot_enum_type_cleaning_mode_vacuum_and_mop
-                - consumer_products_cleaning_robot_enum_type_cleaning_mode_mop_after_vacuum
-        consumer_products_cleaning_robot_option_suction_power:
-          example: consumer_products_cleaning_robot_enum_type_suction_power_standard
-          required: false
-          selector:
-            select:
-              mode: dropdown
-              translation_key: suction_power
-              options:
-                - consumer_products_cleaning_robot_enum_type_suction_power_silent
-                - consumer_products_cleaning_robot_enum_type_suction_power_standard
-                - consumer_products_cleaning_robot_enum_type_suction_power_max
     coffee_maker_options:
       collapsed: true
       fields:

homeassistant/components/home_connect/strings.json

@@ -324,19 +324,7 @@
       "options": {
         "consumer_products_cleaning_robot_enum_type_cleaning_modes_silent": "Silent",
         "consumer_products_cleaning_robot_enum_type_cleaning_modes_standard": "Standard",
-        "consumer_products_cleaning_robot_enum_type_cleaning_modes_power": "Power",
-        "consumer_products_cleaning_robot_enum_type_cleaning_mode_intelligent_mode": "Intelligent mode",
-        "consumer_products_cleaning_robot_enum_type_cleaning_mode_vacuum_only": "Vacuum only",
-        "consumer_products_cleaning_robot_enum_type_cleaning_mode_mop_only": "Mop only",
-        "consumer_products_cleaning_robot_enum_type_cleaning_mode_vacuum_and_mop": "Vacuum and mop",
-        "consumer_products_cleaning_robot_enum_type_cleaning_mode_mop_after_vacuum": "Mop after vacuum"
-      }
-    },
-    "suction_power": {
-      "options": {
-        "consumer_products_cleaning_robot_enum_type_suction_power_silent": "Silent",
-        "consumer_products_cleaning_robot_enum_type_suction_power_standard": "Standard",
-        "consumer_products_cleaning_robot_enum_type_suction_power_max": "Max"
+        "consumer_products_cleaning_robot_enum_type_cleaning_modes_power": "Power"
       }
     },
     "bean_amount": {
@@ -531,10 +519,6 @@
           "name": "Cleaning mode",
           "description": "Defines the favored cleaning mode."
         },
-        "consumer_products_cleaning_robot_option_suction_power": {
-          "name": "Suction power",
-          "description": "Defines the suction power."
-        },
         "consumer_products_coffee_maker_option_bean_amount": {
           "name": "Bean amount",
           "description": "Describes the amount of coffee beans used in a coffee machine program."
@@ -1212,20 +1196,7 @@
         "state": {
           "consumer_products_cleaning_robot_enum_type_cleaning_modes_silent": "[%key:component::home_connect::selector::cleaning_mode::options::consumer_products_cleaning_robot_enum_type_cleaning_modes_silent%]",
           "consumer_products_cleaning_robot_enum_type_cleaning_modes_standard": "[%key:component::home_connect::selector::cleaning_mode::options::consumer_products_cleaning_robot_enum_type_cleaning_modes_standard%]",
-          "consumer_products_cleaning_robot_enum_type_cleaning_modes_power": "[%key:component::home_connect::selector::cleaning_mode::options::consumer_products_cleaning_robot_enum_type_cleaning_modes_power%]",
-          "consumer_products_cleaning_robot_enum_type_cleaning_mode_intelligent_mode": "[%key:component::home_connect::selector::cleaning_mode::options::consumer_products_cleaning_robot_enum_type_cleaning_mode_intelligent_mode%]",
-          "consumer_products_cleaning_robot_enum_type_cleaning_mode_vacuum_only": "[%key:component::home_connect::selector::cleaning_mode::options::consumer_products_cleaning_robot_enum_type_cleaning_mode_vacuum_only%]",
-          "consumer_products_cleaning_robot_enum_type_cleaning_mode_mop_only": "[%key:component::home_connect::selector::cleaning_mode::options::consumer_products_cleaning_robot_enum_type_cleaning_mode_mop_only%]",
-          "consumer_products_cleaning_robot_enum_type_cleaning_mode_vacuum_and_mop": "[%key:component::home_connect::selector::cleaning_mode::options::consumer_products_cleaning_robot_enum_type_cleaning_mode_vacuum_and_mop%]",
-          "consumer_products_cleaning_robot_enum_type_cleaning_mode_mop_after_vacuum": "[%key:component::home_connect::selector::cleaning_mode::options::consumer_products_cleaning_robot_enum_type_cleaning_mode_mop_after_vacuum%]"
-        }
-      },
-      "suction_power": {
-        "name": "[%key:component::home_connect::services::set_program_and_options::fields::consumer_products_cleaning_robot_option_suction_power::name%]",
-        "state": {
-          "consumer_products_cleaning_robot_enum_type_suction_power_silent": "[%key:component::home_connect::selector::suction_power::options::consumer_products_cleaning_robot_enum_type_suction_power_silent%]",
-          "consumer_products_cleaning_robot_enum_type_suction_power_standard": "[%key:component::home_connect::selector::suction_power::options::consumer_products_cleaning_robot_enum_type_suction_power_standard%]",
-          "consumer_products_cleaning_robot_enum_type_suction_power_max": "[%key:component::home_connect::selector::suction_power::options::consumer_products_cleaning_robot_enum_type_suction_power_max%]"
+          "consumer_products_cleaning_robot_enum_type_cleaning_modes_power": "[%key:component::home_connect::selector::cleaning_mode::options::consumer_products_cleaning_robot_enum_type_cleaning_modes_power%]"
         }
       },
       "bean_amount": {

homeassistant/components/homeassistant_connect_zbt2/manifest.json

@@ -13,12 +13,6 @@
       "pid": "4001",
       "description": "*zbt-2*",
       "known_devices": ["ZBT-2"]
-    },
-    {
-      "vid": "303A",
-      "pid": "831A",
-      "description": "*zbt-2*",
-      "known_devices": ["ZBT-2"]
     }
   ]
 }

homeassistant/components/homeassistant_hardware/helpers.py

@@ -1,20 +1,15 @@
 """Home Assistant Hardware integration helpers."""
 
-from __future__ import annotations
-
 from collections import defaultdict
 from collections.abc import AsyncIterator, Awaitable, Callable
-from contextlib import asynccontextmanager
 import logging
-from typing import TYPE_CHECKING, Protocol
+from typing import Protocol
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback as hass_callback
 
 from . import DATA_COMPONENT
-
-if TYPE_CHECKING:
-    from .util import FirmwareInfo
+from .util import FirmwareInfo
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -56,7 +51,6 @@ class HardwareInfoDispatcher:
         self._notification_callbacks: defaultdict[
             str, set[Callable[[FirmwareInfo], None]]
         ] = defaultdict(set)
-        self._active_firmware_updates: dict[str, str] = {}
 
     def register_firmware_info_provider(
         self, domain: str, platform: HardwareFirmwareInfoModule
@@ -124,36 +118,6 @@ class HardwareInfoDispatcher:
                 if fw_info is not None:
                     yield fw_info
 
-    def register_firmware_update_in_progress(
-        self, device: str, source_domain: str
-    ) -> None:
-        """Register that a firmware update is in progress for a device."""
-        if device in self._active_firmware_updates:
-            current_domain = self._active_firmware_updates[device]
-            raise ValueError(
-                f"Firmware update already in progress for {device} by {current_domain}"
-            )
-        self._active_firmware_updates[device] = source_domain
-
-    def unregister_firmware_update_in_progress(
-        self, device: str, source_domain: str
-    ) -> None:
-        """Unregister a firmware update for a device."""
-        if device not in self._active_firmware_updates:
-            raise ValueError(f"No firmware update in progress for {device}")
-
-        if self._active_firmware_updates[device] != source_domain:
-            current_domain = self._active_firmware_updates[device]
-            raise ValueError(
-                f"Firmware update for {device} is owned by {current_domain}, not {source_domain}"
-            )
-
-        del self._active_firmware_updates[device]
-
-    def is_firmware_update_in_progress(self, device: str) -> bool:
-        """Check if a firmware update is in progress for a device."""
-        return device in self._active_firmware_updates
-
 
 @hass_callback
 def async_register_firmware_info_provider(
@@ -177,42 +141,3 @@ def async_notify_firmware_info(
 ) -> Awaitable[None]:
     """Notify the dispatcher of new firmware information."""
     return hass.data[DATA_COMPONENT].notify_firmware_info(domain, firmware_info)
-
-
-@hass_callback
-def async_register_firmware_update_in_progress(
-    hass: HomeAssistant, device: str, source_domain: str
-) -> None:
-    """Register that a firmware update is in progress for a device."""
-    return hass.data[DATA_COMPONENT].register_firmware_update_in_progress(
-        device, source_domain
-    )
-
-
-@hass_callback
-def async_unregister_firmware_update_in_progress(
-    hass: HomeAssistant, device: str, source_domain: str
-) -> None:
-    """Unregister a firmware update for a device."""
-    return hass.data[DATA_COMPONENT].unregister_firmware_update_in_progress(
-        device, source_domain
-    )
-
-
-@hass_callback
-def async_is_firmware_update_in_progress(hass: HomeAssistant, device: str) -> bool:
-    """Check if a firmware update is in progress for a device."""
-    return hass.data[DATA_COMPONENT].is_firmware_update_in_progress(device)
-
-
-@asynccontextmanager
-async def async_firmware_update_context(
-    hass: HomeAssistant, device: str, source_domain: str
-) -> AsyncIterator[None]:
-    """Register a device as having its firmware being actively updated."""
-    async_register_firmware_update_in_progress(hass, device, source_domain)
-
-    try:
-        yield
-    finally:
-        async_unregister_firmware_update_in_progress(hass, device, source_domain)

homeassistant/components/homeassistant_hardware/strings.json

@@ -67,7 +67,7 @@
         }
       },
       "abort": {
-        "not_hassio_thread": "The OpenThread Border Router add-on can only be installed with Home Assistant OS. If you would like to use the {model} as a Thread border router, please manually set up OpenThread Border Router to communicate with it.",
+        "not_hassio_thread": "The OpenThread Border Router add-on can only be installed with Home Assistant OS. If you would like to use the {model} as a Thread border router, please flash the firmware manually using the [web flasher]({docs_web_flasher_url}) and set up OpenThread Border Router to communicate with it.",
         "otbr_addon_already_running": "The OpenThread Border Router add-on is already running, it cannot be installed again.",
         "zha_still_using_stick": "This {model} is in use by the Zigbee Home Automation integration. Please migrate your Zigbee network to another adapter or delete the integration and try again.",
         "otbr_still_using_stick": "This {model} is in use by the OpenThread Border Router add-on. If you use the Thread network, make sure you have alternative border routers. Uninstall the add-on and try again.",

homeassistant/components/homeassistant_hardware/update.py

@@ -275,7 +275,6 @@ class BaseFirmwareUpdateEntity(
                 expected_installed_firmware_type=self.entity_description.expected_firmware_type,
                 bootloader_reset_methods=self.bootloader_reset_methods,
                 progress_callback=self._update_progress,
-                domain=self._config_entry.domain,
             )
         finally:
             self._attr_in_progress = False

homeassistant/components/homeassistant_hardware/util.py

@@ -26,7 +26,6 @@ from homeassistant.helpers.singleton import singleton
 
 from . import DATA_COMPONENT
 from .const import (
-    DOMAIN,
     OTBR_ADDON_MANAGER_DATA,
     OTBR_ADDON_NAME,
     OTBR_ADDON_SLUG,
@@ -34,7 +33,6 @@ from .const import (
     ZIGBEE_FLASHER_ADDON_NAME,
     ZIGBEE_FLASHER_ADDON_SLUG,
 )
-from .helpers import async_firmware_update_context
 from .silabs_multiprotocol_addon import (
     WaitingAddonManager,
     get_multiprotocol_addon_manager,
@@ -361,50 +359,45 @@ async def async_flash_silabs_firmware(
     expected_installed_firmware_type: ApplicationType,
     bootloader_reset_methods: Sequence[ResetTarget] = (),
     progress_callback: Callable[[int, int], None] | None = None,
-    *,
-    domain: str = DOMAIN,
 ) -> FirmwareInfo:
     """Flash firmware to the SiLabs device."""
-    async with async_firmware_update_context(hass, device, domain):
-        firmware_info = await guess_firmware_info(hass, device)
-        _LOGGER.debug("Identified firmware info: %s", firmware_info)
+    firmware_info = await guess_firmware_info(hass, device)
+    _LOGGER.debug("Identified firmware info: %s", firmware_info)
 
-        fw_image = await hass.async_add_executor_job(parse_firmware_image, fw_data)
+    fw_image = await hass.async_add_executor_job(parse_firmware_image, fw_data)
 
-        flasher = Flasher(
-            device=device,
-            probe_methods=(
-                ApplicationType.GECKO_BOOTLOADER.as_flasher_application_type(),
-                ApplicationType.EZSP.as_flasher_application_type(),
-                ApplicationType.SPINEL.as_flasher_application_type(),
-                ApplicationType.CPC.as_flasher_application_type(),
-            ),
-            bootloader_reset=tuple(
-                m.as_flasher_reset_target() for m in bootloader_reset_methods
-            ),
+    flasher = Flasher(
+        device=device,
+        probe_methods=(
+            ApplicationType.GECKO_BOOTLOADER.as_flasher_application_type(),
+            ApplicationType.EZSP.as_flasher_application_type(),
+            ApplicationType.SPINEL.as_flasher_application_type(),
+            ApplicationType.CPC.as_flasher_application_type(),
+        ),
+        bootloader_reset=tuple(
+            m.as_flasher_reset_target() for m in bootloader_reset_methods
+        ),
+    )
+
+    async with AsyncExitStack() as stack:
+        for owner in firmware_info.owners:
+            await stack.enter_async_context(owner.temporarily_stop(hass))
+
+        try:
+            # Enter the bootloader with indeterminate progress
+            await flasher.enter_bootloader()
+
+            # Flash the firmware, with progress
+            await flasher.flash_firmware(fw_image, progress_callback=progress_callback)
+        except Exception as err:
+            raise HomeAssistantError("Failed to flash firmware") from err
+
+        probed_firmware_info = await probe_silabs_firmware_info(
+            device,
+            probe_methods=(expected_installed_firmware_type,),
         )
 
-        async with AsyncExitStack() as stack:
-            for owner in firmware_info.owners:
-                await stack.enter_async_context(owner.temporarily_stop(hass))
+    if probed_firmware_info is None:
+        raise HomeAssistantError("Failed to probe the firmware after flashing")
 
-            try:
-                # Enter the bootloader with indeterminate progress
-                await flasher.enter_bootloader()
-
-                # Flash the firmware, with progress
-                await flasher.flash_firmware(
-                    fw_image, progress_callback=progress_callback
-                )
-            except Exception as err:
-                raise HomeAssistantError("Failed to flash firmware") from err
-
-            probed_firmware_info = await probe_silabs_firmware_info(
-                device,
-                probe_methods=(expected_installed_firmware_type,),
-            )
-
-        if probed_firmware_info is None:
-            raise HomeAssistantError("Failed to probe the firmware after flashing")
-
-        return probed_firmware_info
+    return probed_firmware_info

homeassistant/components/homekit/accessories.py

@@ -456,7 +456,7 @@ class HomeAccessory(Accessory):  # type: ignore[misc]
         return self._available
 
     @ha_callback
-    @pyhap_callback  # type: ignore[untyped-decorator]
+    @pyhap_callback  # type: ignore[misc]
     def run(self) -> None:
         """Handle accessory driver started event."""
         if state := self.hass.states.get(self.entity_id):
@@ -725,7 +725,7 @@ class HomeDriver(AccessoryDriver):  # type: ignore[misc]
         self._entry_title = entry_title
         self.iid_storage = iid_storage
 
-    @pyhap_callback  # type: ignore[untyped-decorator]
+    @pyhap_callback  # type: ignore[misc]
     def pair(
         self, client_username_bytes: bytes, client_public: str, client_permissions: int
     ) -> bool:
@@ -735,7 +735,7 @@ class HomeDriver(AccessoryDriver):  # type: ignore[misc]
             async_dismiss_setup_message(self.hass, self.entry_id)
         return cast(bool, success)
 
-    @pyhap_callback  # type: ignore[untyped-decorator]
+    @pyhap_callback  # type: ignore[misc]
     def unpair(self, client_uuid: UUID) -> None:
         """Override super function to show setup message if unpaired."""
         super().unpair(client_uuid)

homeassistant/components/homekit/doorbell.py

@@ -71,7 +71,7 @@ class HomeDoorbellAccessory(HomeAccessory):
         self.async_update_doorbell_state(None, state)
 
     @ha_callback
-    @pyhap_callback  # type: ignore[untyped-decorator]
+    @pyhap_callback  # type: ignore[misc]
     def run(self) -> None:
         """Handle doorbell event."""
         if self._char_doorbell_detected:

homeassistant/components/homekit/type_air_purifiers.py

@@ -219,7 +219,7 @@ class AirPurifier(Fan):
         return preset_mode.lower() != "auto"
 
     @callback
-    @pyhap_callback  # type: ignore[untyped-decorator]
+    @pyhap_callback  # type: ignore[misc]
     def run(self) -> None:
         """Handle accessory driver started event.
 

homeassistant/components/homekit/type_cameras.py

@@ -229,7 +229,7 @@ class Camera(HomeDoorbellAccessory, PyhapCamera):  # type: ignore[misc]
                 )
                 self._async_update_motion_state(None, state)
 
-    @pyhap_callback  # type: ignore[untyped-decorator]
+    @pyhap_callback  # type: ignore[misc]
     @callback
     def run(self) -> None:
         """Handle accessory driver started event.

homeassistant/components/homekit/type_covers.py

@@ -127,7 +127,7 @@ class GarageDoorOpener(HomeAccessory):
         self.async_update_state(state)
 
     @callback
-    @pyhap_callback  # type: ignore[untyped-decorator]
+    @pyhap_callback  # type: ignore[misc]
     def run(self) -> None:
         """Handle accessory driver started event.
 

homeassistant/components/homekit/type_humidifiers.py

@@ -178,7 +178,7 @@ class HumidifierDehumidifier(HomeAccessory):
                 self._async_update_current_humidity(humidity_state)
 
     @callback
-    @pyhap_callback  # type: ignore[untyped-decorator]
+    @pyhap_callback  # type: ignore[misc]
     def run(self) -> None:
         """Handle accessory driver started event.
 

homeassistant/components/homekit/type_triggers.py

@@ -108,7 +108,7 @@ class DeviceTriggerAccessory(HomeAccessory):
             _LOGGER.log,
         )
 
-    @pyhap_callback  # type: ignore[untyped-decorator]
+    @pyhap_callback  # type: ignore[misc]
     @callback
     def run(self) -> None:
         """Run the accessory."""

homeassistant/components/idasen_desk/coordinator.py

@@ -41,12 +41,16 @@ class IdasenDeskCoordinator(DataUpdateCoordinator[int | None]):
         self._expected_connected = False
         self._height: int | None = None
 
+        @callback
+        def async_update_data() -> None:
+            self.async_set_updated_data(self._height)
+
         self._debouncer = Debouncer(
             hass=self.hass,
             logger=_LOGGER,
             cooldown=UPDATE_DEBOUNCE_TIME,
             immediate=True,
-            function=callback(lambda: self.async_set_updated_data(self._height)),
+            function=async_update_data,
         )
 
     async def async_connect(self) -> bool:

homeassistant/components/imgw_pib/manifest.json

@@ -5,6 +5,6 @@
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/imgw_pib",
   "iot_class": "cloud_polling",
-  "quality_scale": "platinum",
+  "quality_scale": "silver",
   "requirements": ["imgw_pib==1.5.6"]
 }

homeassistant/components/imgw_pib/quality_scale.yaml

@@ -50,17 +50,17 @@ rules:
   discovery:
     status: exempt
     comment: The integration is a cloud service and thus does not support discovery.
-  docs-data-update: done
-  docs-examples: done
-  docs-known-limitations: done
+  docs-data-update: todo
+  docs-examples: todo
+  docs-known-limitations: todo
   docs-supported-devices:
     status: exempt
     comment: This is a service, which doesn't integrate with any devices.
-  docs-supported-functions: done
+  docs-supported-functions: todo
   docs-troubleshooting:
     status: exempt
     comment: No known issues that could be resolved by the user.
-  docs-use-cases: done
+  docs-use-cases: todo
   dynamic-devices:
     status: exempt
     comment: This integration has a fixed single service.

homeassistant/components/iometer/manifest.json

@@ -1,12 +1,12 @@
 {
   "domain": "iometer",
   "name": "IOmeter",
-  "codeowners": ["@jukrebs"],
+  "codeowners": ["@MaestroOnICe"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/iometer",
   "integration_type": "device",
   "iot_class": "local_polling",
   "quality_scale": "bronze",
-  "requirements": ["iometer==0.2.0"],
+  "requirements": ["iometer==0.1.0"],
   "zeroconf": ["_iometer._tcp.local."]
 }

homeassistant/components/ista_ecotrend/sensor.py

@@ -34,7 +34,6 @@ from homeassistant.helpers.device_registry import (
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
-from homeassistant.util.unit_conversion import EnergyConverter, VolumeConverter
 
 from .const import DOMAIN
 from .coordinator import IstaConfigEntry, IstaCoordinator
@@ -50,7 +49,6 @@ class IstaSensorEntityDescription(SensorEntityDescription):
     """Ista EcoTrend Sensor Description."""
 
     consumption_type: IstaConsumptionType
-    unit_class: str | None = None
     value_type: IstaValueType | None = None
 
 
@@ -86,7 +84,6 @@ SENSOR_DESCRIPTIONS: tuple[IstaSensorEntityDescription, ...] = (
         suggested_display_precision=1,
         consumption_type=IstaConsumptionType.HEATING,
         value_type=IstaValueType.ENERGY,
-        unit_class=EnergyConverter.UNIT_CLASS,
     ),
     IstaSensorEntityDescription(
         key=IstaSensorEntity.HEATING_COST,
@@ -107,7 +104,6 @@ SENSOR_DESCRIPTIONS: tuple[IstaSensorEntityDescription, ...] = (
         state_class=SensorStateClass.TOTAL,
         suggested_display_precision=1,
         consumption_type=IstaConsumptionType.HOT_WATER,
-        unit_class=VolumeConverter.UNIT_CLASS,
     ),
     IstaSensorEntityDescription(
         key=IstaSensorEntity.HOT_WATER_ENERGY,
@@ -118,7 +114,6 @@ SENSOR_DESCRIPTIONS: tuple[IstaSensorEntityDescription, ...] = (
         suggested_display_precision=1,
         consumption_type=IstaConsumptionType.HOT_WATER,
         value_type=IstaValueType.ENERGY,
-        unit_class=EnergyConverter.UNIT_CLASS,
     ),
     IstaSensorEntityDescription(
         key=IstaSensorEntity.HOT_WATER_COST,
@@ -140,7 +135,6 @@ SENSOR_DESCRIPTIONS: tuple[IstaSensorEntityDescription, ...] = (
         suggested_display_precision=1,
         entity_registry_enabled_default=False,
         consumption_type=IstaConsumptionType.WATER,
-        unit_class=VolumeConverter.UNIT_CLASS,
     ),
     IstaSensorEntityDescription(
         key=IstaSensorEntity.WATER_COST,
@@ -282,7 +276,6 @@ class IstaSensor(CoordinatorEntity[IstaCoordinator], SensorEntity):
                 "name": f"{self.device_entry.name} {self.name}",
                 "source": DOMAIN,
                 "statistic_id": statistic_id,
-                "unit_class": self.entity_description.unit_class,
                 "unit_of_measurement": self.entity_description.native_unit_of_measurement,
             }
             if statistics:

homeassistant/components/kegtron/manifest.json

@@ -12,5 +12,5 @@
   "dependencies": ["bluetooth_adapters"],
   "documentation": "https://www.home-assistant.io/integrations/kegtron",
   "iot_class": "local_push",
-  "requirements": ["kegtron-ble==1.0.2"]
+  "requirements": ["kegtron-ble==0.4.0"]
 }

homeassistant/components/kitchen_sink/__init__.py

@@ -36,11 +36,6 @@ from homeassistant.helpers.device_registry import DeviceEntry
 from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
 from homeassistant.helpers.typing import ConfigType
 from homeassistant.util import dt as dt_util
-from homeassistant.util.unit_conversion import (
-    EnergyConverter,
-    TemperatureConverter,
-    VolumeConverter,
-)
 
 from .const import DATA_BACKUP_AGENT_LISTENERS, DOMAIN
 
@@ -259,7 +254,6 @@ async def _insert_statistics(hass: HomeAssistant) -> None:
         "source": DOMAIN,
         "name": "Outdoor temperature",
         "statistic_id": f"{DOMAIN}:temperature_outdoor",
-        "unit_class": TemperatureConverter.UNIT_CLASS,
         "unit_of_measurement": UnitOfTemperature.CELSIUS,
         "mean_type": StatisticMeanType.ARITHMETIC,
         "has_sum": False,
@@ -273,7 +267,6 @@ async def _insert_statistics(hass: HomeAssistant) -> None:
         "source": DOMAIN,
         "name": "Energy consumption 1",
         "statistic_id": f"{DOMAIN}:energy_consumption_kwh",
-        "unit_class": EnergyConverter.UNIT_CLASS,
         "unit_of_measurement": UnitOfEnergy.KILO_WATT_HOUR,
         "mean_type": StatisticMeanType.NONE,
         "has_sum": True,
@@ -286,7 +279,6 @@ async def _insert_statistics(hass: HomeAssistant) -> None:
         "source": DOMAIN,
         "name": "Energy consumption 2",
         "statistic_id": f"{DOMAIN}:energy_consumption_mwh",
-        "unit_class": EnergyConverter.UNIT_CLASS,
         "unit_of_measurement": UnitOfEnergy.MEGA_WATT_HOUR,
         "mean_type": StatisticMeanType.NONE,
         "has_sum": True,
@@ -301,7 +293,6 @@ async def _insert_statistics(hass: HomeAssistant) -> None:
         "source": DOMAIN,
         "name": "Gas consumption 1",
         "statistic_id": f"{DOMAIN}:gas_consumption_m3",
-        "unit_class": VolumeConverter.UNIT_CLASS,
         "unit_of_measurement": UnitOfVolume.CUBIC_METERS,
         "mean_type": StatisticMeanType.NONE,
         "has_sum": True,
@@ -316,7 +307,6 @@ async def _insert_statistics(hass: HomeAssistant) -> None:
         "source": DOMAIN,
         "name": "Gas consumption 2",
         "statistic_id": f"{DOMAIN}:gas_consumption_ft3",
-        "unit_class": VolumeConverter.UNIT_CLASS,
         "unit_of_measurement": UnitOfVolume.CUBIC_FEET,
         "mean_type": StatisticMeanType.NONE,
         "has_sum": True,
@@ -329,7 +319,6 @@ async def _insert_statistics(hass: HomeAssistant) -> None:
         "source": RECORDER_DOMAIN,
         "name": None,
         "statistic_id": "sensor.statistics_issues_issue_1",
-        "unit_class": VolumeConverter.UNIT_CLASS,
         "unit_of_measurement": UnitOfVolume.CUBIC_METERS,
         "mean_type": StatisticMeanType.ARITHMETIC,
         "has_sum": False,
@@ -342,7 +331,6 @@ async def _insert_statistics(hass: HomeAssistant) -> None:
         "source": RECORDER_DOMAIN,
         "name": None,
         "statistic_id": "sensor.statistics_issues_issue_2",
-        "unit_class": None,
         "unit_of_measurement": "cats",
         "mean_type": StatisticMeanType.ARITHMETIC,
         "has_sum": False,
@@ -355,7 +343,6 @@ async def _insert_statistics(hass: HomeAssistant) -> None:
         "source": RECORDER_DOMAIN,
         "name": None,
         "statistic_id": "sensor.statistics_issues_issue_3",
-        "unit_class": VolumeConverter.UNIT_CLASS,
         "unit_of_measurement": UnitOfVolume.CUBIC_METERS,
         "mean_type": StatisticMeanType.ARITHMETIC,
         "has_sum": False,
@@ -368,7 +355,6 @@ async def _insert_statistics(hass: HomeAssistant) -> None:
         "source": RECORDER_DOMAIN,
         "name": None,
         "statistic_id": "sensor.statistics_issues_issue_4",
-        "unit_class": VolumeConverter.UNIT_CLASS,
         "unit_of_measurement": UnitOfVolume.CUBIC_METERS,
         "mean_type": StatisticMeanType.ARITHMETIC,
         "has_sum": False,
@@ -389,7 +375,6 @@ async def _insert_wrong_wind_direction_statistics(hass: HomeAssistant) -> None:
         "source": RECORDER_DOMAIN,
         "name": None,
         "statistic_id": "sensor.statistics_issues_issue_5",
-        "unit_class": None,
         "unit_of_measurement": DEGREE,
         "mean_type": StatisticMeanType.ARITHMETIC,
         "has_sum": False,

homeassistant/components/knx/manifest.json

@@ -11,9 +11,9 @@
   "loggers": ["xknx", "xknxproject"],
   "quality_scale": "silver",
   "requirements": [
-    "xknx==3.9.1",
+    "xknx==3.9.0",
     "xknxproject==3.8.2",
-    "knx-frontend==2025.10.9.185845"
+    "knx-frontend==2025.8.24.205840"
   ],
   "single_config_entry": true
 }

homeassistant/components/knx/sensor.py

@@ -136,7 +136,7 @@ def _create_sensor(xknx: XKNX, config: ConfigType) -> XknxSensor:
         name=config[CONF_NAME],
         group_address_state=config[SensorSchema.CONF_STATE_ADDRESS],
         sync_state=config[SensorSchema.CONF_SYNC_STATE],
-        always_callback=True,
+        always_callback=config[SensorSchema.CONF_ALWAYS_CALLBACK],
         value_type=config[CONF_TYPE],
     )
 
@@ -159,7 +159,7 @@ class KNXSensor(KnxYamlEntity, SensorEntity):
                 SensorDeviceClass, self._device.ha_device_class()
             )
 
-        self._attr_force_update = config[SensorSchema.CONF_ALWAYS_CALLBACK]
+        self._attr_force_update = self._device.always_callback
         self._attr_entity_category = config.get(CONF_ENTITY_CATEGORY)
         self._attr_unique_id = str(self._device.sensor_value.group_address_state)
         self._attr_native_unit_of_measurement = self._device.unit_of_measurement()

homeassistant/components/lamarzocco/manifest.json

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

homeassistant/components/london_underground/__init__.py

@@ -1,36 +1 @@
 """The london_underground component."""
-
-from __future__ import annotations
-
-from homeassistant.const import Platform
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-
-from .const import DOMAIN as DOMAIN
-from .coordinator import LondonTubeCoordinator, LondonUndergroundConfigEntry, TubeData
-
-PLATFORMS: list[Platform] = [Platform.SENSOR]
-
-
-async def async_setup_entry(
-    hass: HomeAssistant, entry: LondonUndergroundConfigEntry
-) -> bool:
-    """Set up London Underground from a config entry."""
-
-    session = async_get_clientsession(hass)
-    data = TubeData(session)
-    coordinator = LondonTubeCoordinator(hass, data, config_entry=entry)
-    await coordinator.async_config_entry_first_refresh()
-
-    entry.runtime_data = coordinator
-    # Forward the setup to the sensor platform
-    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
-
-    return True
-
-
-async def async_unload_entry(
-    hass: HomeAssistant, entry: LondonUndergroundConfigEntry
-) -> bool:
-    """Unload a config entry."""
-    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/london_underground/config_flow.py

@@ -1,152 +0,0 @@
-"""Config flow for London Underground integration."""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-from typing import Any
-
-from london_tube_status import TubeData
-import voluptuous as vol
-
-from homeassistant.config_entries import (
-    ConfigEntry,
-    ConfigFlow,
-    ConfigFlowResult,
-    OptionsFlowWithReload,
-)
-from homeassistant.core import callback
-from homeassistant.helpers import selector
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.typing import ConfigType
-
-from .const import CONF_LINE, DEFAULT_LINES, DOMAIN, TUBE_LINES
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class LondonUndergroundConfigFlow(ConfigFlow, domain=DOMAIN):
-    """Handle a config flow for London Underground."""
-
-    VERSION = 1
-    MINOR_VERSION = 1
-
-    @staticmethod
-    @callback
-    def async_get_options_flow(
-        _: ConfigEntry,
-    ) -> LondonUndergroundOptionsFlow:
-        """Get the options flow for this handler."""
-        return LondonUndergroundOptionsFlow()
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the initial step."""
-        errors: dict[str, str] = {}
-
-        if user_input is not None:
-            session = async_get_clientsession(self.hass)
-            data = TubeData(session)
-            try:
-                async with asyncio.timeout(10):
-                    await data.update()
-            except TimeoutError:
-                errors["base"] = "timeout_connect"
-            except Exception:
-                _LOGGER.exception("Unexpected error")
-                errors["base"] = "cannot_connect"
-            else:
-                return self.async_create_entry(
-                    title="London Underground",
-                    data={},
-                    options={CONF_LINE: user_input.get(CONF_LINE, DEFAULT_LINES)},
-                )
-
-        return self.async_show_form(
-            step_id="user",
-            data_schema=vol.Schema(
-                {
-                    vol.Optional(
-                        CONF_LINE,
-                        default=DEFAULT_LINES,
-                    ): selector.SelectSelector(
-                        selector.SelectSelectorConfig(
-                            options=TUBE_LINES,
-                            multiple=True,
-                            mode=selector.SelectSelectorMode.DROPDOWN,
-                        )
-                    ),
-                }
-            ),
-            errors=errors,
-        )
-
-    async def async_step_import(self, import_data: ConfigType) -> ConfigFlowResult:
-        """Handle import from configuration.yaml."""
-        session = async_get_clientsession(self.hass)
-        data = TubeData(session)
-        try:
-            async with asyncio.timeout(10):
-                await data.update()
-        except Exception:
-            _LOGGER.exception(
-                "Unexpected error trying to connect before importing config, aborting import "
-            )
-            return self.async_abort(reason="cannot_connect")
-
-        _LOGGER.warning(
-            "Importing London Underground config from configuration.yaml: %s",
-            import_data,
-        )
-        # Extract lines from the sensor platform config
-        lines = import_data.get(CONF_LINE, DEFAULT_LINES)
-        if "London Overground" in lines:
-            _LOGGER.warning(
-                "London Overground was removed from the configuration as the line has been divided and renamed"
-            )
-            lines.remove("London Overground")
-        return self.async_create_entry(
-            title="London Underground",
-            data={},
-            options={CONF_LINE: import_data.get(CONF_LINE, DEFAULT_LINES)},
-        )
-
-
-class LondonUndergroundOptionsFlow(OptionsFlowWithReload):
-    """Handle options."""
-
-    async def async_step_init(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Manage the options."""
-        if user_input is not None:
-            _LOGGER.debug(
-                "Updating london underground with options flow user_input: %s",
-                user_input,
-            )
-            return self.async_create_entry(
-                title="",
-                data={CONF_LINE: user_input[CONF_LINE]},
-            )
-
-        return self.async_show_form(
-            step_id="init",
-            data_schema=vol.Schema(
-                {
-                    vol.Optional(
-                        CONF_LINE,
-                        default=self.config_entry.options.get(
-                            CONF_LINE,
-                            self.config_entry.data.get(CONF_LINE, DEFAULT_LINES),
-                        ),
-                    ): selector.SelectSelector(
-                        selector.SelectSelectorConfig(
-                            options=TUBE_LINES,
-                            multiple=True,
-                            mode=selector.SelectSelectorMode.DROPDOWN,
-                        )
-                    ),
-                }
-            ),
-        )

homeassistant/components/london_underground/const.py

@@ -6,6 +6,7 @@ DOMAIN = "london_underground"
 
 CONF_LINE = "line"
 
+
 SCAN_INTERVAL = timedelta(seconds=30)
 
 TUBE_LINES = [
@@ -17,7 +18,7 @@ TUBE_LINES = [
     "Elizabeth line",
     "Hammersmith & City",
     "Jubilee",
-    "London Overground",  # no longer supported
+    "London Overground",
     "Metropolitan",
     "Northern",
     "Piccadilly",
@@ -30,20 +31,3 @@ TUBE_LINES = [
     "Weaver",
     "Windrush",
 ]
-
-# Default lines to monitor if none selected
-DEFAULT_LINES = [
-    "Bakerloo",
-    "Central",
-    "Circle",
-    "District",
-    "DLR",
-    "Elizabeth line",
-    "Hammersmith & City",
-    "Jubilee",
-    "Metropolitan",
-    "Northern",
-    "Piccadilly",
-    "Victoria",
-    "Waterloo & City",
-]

homeassistant/components/london_underground/coordinator.py

@@ -8,7 +8,6 @@ from typing import cast
 
 from london_tube_status import TubeData
 
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 
@@ -16,23 +15,16 @@ from .const import DOMAIN, SCAN_INTERVAL
 
 _LOGGER = logging.getLogger(__name__)
 
-type LondonUndergroundConfigEntry = ConfigEntry[LondonTubeCoordinator]
-
 
 class LondonTubeCoordinator(DataUpdateCoordinator[dict[str, dict[str, str]]]):
     """London Underground sensor coordinator."""
 
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        data: TubeData,
-        config_entry: LondonUndergroundConfigEntry,
-    ) -> None:
+    def __init__(self, hass: HomeAssistant, data: TubeData) -> None:
         """Initialize coordinator."""
         super().__init__(
             hass,
             _LOGGER,
-            config_entry=config_entry,
+            config_entry=None,
             name=DOMAIN,
             update_interval=SCAN_INTERVAL,
         )

homeassistant/components/london_underground/manifest.json

@@ -2,12 +2,9 @@
   "domain": "london_underground",
   "name": "London Underground",
   "codeowners": ["@jpbede"],
-  "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/london_underground",
-  "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["london_tube_status"],
   "quality_scale": "legacy",
-  "requirements": ["london-tube-status==0.5"],
-  "single_config_entry": true
+  "requirements": ["london-tube-status==0.5"]
 }

homeassistant/components/london_underground/sensor.py

@@ -5,26 +5,23 @@ from __future__ import annotations
 import logging
 from typing import Any
 
+from london_tube_status import TubeData
 import voluptuous as vol
 
 from homeassistant.components.sensor import (
     PLATFORM_SCHEMA as SENSOR_PLATFORM_SCHEMA,
     SensorEntity,
 )
-from homeassistant.config_entries import SOURCE_IMPORT
-from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant
-from homeassistant.data_entry_flow import FlowResultType
-from homeassistant.helpers import config_validation as cv, issue_registry as ir
-from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
-from homeassistant.helpers.entity_platform import (
-    AddConfigEntryEntitiesCallback,
-    AddEntitiesCallback,
-)
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import PlatformNotReady
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from .const import CONF_LINE, DOMAIN, TUBE_LINES
-from .coordinator import LondonTubeCoordinator, LondonUndergroundConfigEntry
+from .const import CONF_LINE, TUBE_LINES
+from .coordinator import LondonTubeCoordinator
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -41,54 +38,18 @@ async def async_setup_platform(
 ) -> None:
     """Set up the Tube sensor."""
 
-    # If configuration.yaml config exists, trigger the import flow.
-    # If the config entry already exists, this will not be triggered as only one config is allowed.
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN, context={"source": SOURCE_IMPORT}, data=config
-    )
-    if (
-        result.get("type") is FlowResultType.ABORT
-        and result.get("reason") != "already_configured"
-    ):
-        ir.async_create_issue(
-            hass,
-            DOMAIN,
-            f"deprecated_yaml_import_issue_{result.get('reason')}",
-            is_fixable=False,
-            issue_domain=DOMAIN,
-            severity=ir.IssueSeverity.WARNING,
-            translation_key="deprecated_yaml_import_issue",
-            translation_placeholders={
-                "domain": DOMAIN,
-                "integration_title": "London Underground",
-            },
-        )
-        return
+    session = async_get_clientsession(hass)
 
-    ir.async_create_issue(
-        hass,
-        HOMEASSISTANT_DOMAIN,
-        "deprecated_yaml",
-        is_fixable=False,
-        issue_domain=DOMAIN,
-        severity=ir.IssueSeverity.WARNING,
-        translation_key="deprecated_yaml",
-        translation_placeholders={
-            "domain": DOMAIN,
-            "integration_title": "London Underground",
-        },
-    )
+    data = TubeData(session)
+    coordinator = LondonTubeCoordinator(hass, data)
 
+    await coordinator.async_refresh()
 
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: LondonUndergroundConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up the London Underground sensor from config entry."""
+    if not coordinator.last_update_success:
+        raise PlatformNotReady
 
     async_add_entities(
-        LondonTubeSensor(entry.runtime_data, line) for line in entry.options[CONF_LINE]
+        LondonTubeSensor(coordinator, line) for line in config[CONF_LINE]
     )
 
 
@@ -97,21 +58,11 @@ class LondonTubeSensor(CoordinatorEntity[LondonTubeCoordinator], SensorEntity):
 
     _attr_attribution = "Powered by TfL Open Data"
     _attr_icon = "mdi:subway"
-    _attr_has_entity_name = True  # Use modern entity naming
 
     def __init__(self, coordinator: LondonTubeCoordinator, name: str) -> None:
         """Initialize the London Underground sensor."""
         super().__init__(coordinator)
         self._name = name
-        # Add unique_id for proper entity registry
-        self._attr_unique_id = f"tube_{name.lower().replace(' ', '_')}"
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, DOMAIN)},
-            name="London Underground",
-            manufacturer="Transport for London",
-            model="Tube Status",
-            entry_type=DeviceEntryType.SERVICE,
-        )
 
     @property
     def name(self) -> str:

homeassistant/components/london_underground/strings.json

@@ -1,38 +0,0 @@
-{
-  "config": {
-    "step": {
-      "user": {
-        "title": "Set up London Underground",
-        "description": "Select which tube lines you want to monitor",
-        "data": {
-          "line": "Tube lines"
-        }
-      }
-    },
-    "error": {
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "timeout_connect": "[%key:common::config_flow::error::timeout_connect%]",
-      "unknown": "[%key:common::config_flow::error::unknown%]"
-    },
-    "abort": {
-      "single_instance_allowed": "[%key:common::config_flow::abort::single_instance_allowed%]"
-    }
-  },
-  "options": {
-    "step": {
-      "init": {
-        "title": "Configure London Underground",
-        "description": "[%key:component::london_underground::config::step::user::description%]",
-        "data": {
-          "line": "[%key:component::london_underground::config::step::user::data::line%]"
-        }
-      }
-    }
-  },
-  "issues": {
-    "deprecated_yaml_import_issue": {
-      "title": "London Underground YAML configuration deprecated",
-      "description": "Configuring London Underground using YAML sensor platform is deprecated.\n\nWhile importing your configuration, an error occurred when trying to connect to the Transport for London API. Please restart Home Assistant to try again, or remove the existing YAML configuration and set the integration up via the UI."
-    }
-  }
-}

homeassistant/components/matter/climate.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
 from enum import IntEnum
 from typing import Any
 
@@ -27,7 +26,7 @@ from homeassistant.const import ATTR_TEMPERATURE, Platform, UnitOfTemperature
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .entity import MatterEntity, MatterEntityDescription
+from .entity import MatterEntity
 from .helpers import get_matter
 from .models import MatterDiscoverySchema
 
@@ -183,11 +182,6 @@ async def async_setup_entry(
     matter.register_platform_handler(Platform.CLIMATE, async_add_entities)
 
 
-@dataclass(frozen=True)
-class MatterClimateEntityDescription(ClimateEntityDescription, MatterEntityDescription):
-    """Describe Matter Climate entities."""
-
-
 class MatterClimate(MatterEntity, ClimateEntity):
     """Representation of a Matter climate entity."""
 
@@ -429,7 +423,7 @@ class MatterClimate(MatterEntity, ClimateEntity):
 DISCOVERY_SCHEMAS = [
     MatterDiscoverySchema(
         platform=Platform.CLIMATE,
-        entity_description=MatterClimateEntityDescription(
+        entity_description=ClimateEntityDescription(
             key="MatterThermostat",
             name=None,
         ),

homeassistant/components/matter/cover.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
 from enum import IntEnum
 from math import floor
 from typing import Any
@@ -23,7 +22,7 @@ from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .const import LOGGER
-from .entity import MatterEntity, MatterEntityDescription
+from .entity import MatterEntity
 from .helpers import get_matter
 from .models import MatterDiscoverySchema
 
@@ -62,15 +61,10 @@ async def async_setup_entry(
     matter.register_platform_handler(Platform.COVER, async_add_entities)
 
 
-@dataclass(frozen=True)
-class MatterCoverEntityDescription(CoverEntityDescription, MatterEntityDescription):
-    """Describe Matter Cover entities."""
-
-
 class MatterCover(MatterEntity, CoverEntity):
     """Representation of a Matter Cover."""
 
-    entity_description: MatterCoverEntityDescription
+    entity_description: CoverEntityDescription
 
     @property
     def is_closed(self) -> bool | None:
@@ -204,7 +198,7 @@ class MatterCover(MatterEntity, CoverEntity):
 DISCOVERY_SCHEMAS = [
     MatterDiscoverySchema(
         platform=Platform.COVER,
-        entity_description=MatterCoverEntityDescription(
+        entity_description=CoverEntityDescription(
             key="MatterCover",
             name=None,
         ),
@@ -220,7 +214,7 @@ DISCOVERY_SCHEMAS = [
     ),
     MatterDiscoverySchema(
         platform=Platform.COVER,
-        entity_description=MatterCoverEntityDescription(
+        entity_description=CoverEntityDescription(
             key="MatterCoverPositionAwareLift", name=None
         ),
         entity_class=MatterCover,
@@ -235,7 +229,7 @@ DISCOVERY_SCHEMAS = [
     ),
     MatterDiscoverySchema(
         platform=Platform.COVER,
-        entity_description=MatterCoverEntityDescription(
+        entity_description=CoverEntityDescription(
             key="MatterCoverPositionAwareTilt", name=None
         ),
         entity_class=MatterCover,
@@ -250,7 +244,7 @@ DISCOVERY_SCHEMAS = [
     ),
     MatterDiscoverySchema(
         platform=Platform.COVER,
-        entity_description=MatterCoverEntityDescription(
+        entity_description=CoverEntityDescription(
             key="MatterCoverPositionAwareLiftAndTilt", name=None
         ),
         entity_class=MatterCover,

homeassistant/components/matter/event.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
 from typing import Any
 
 from chip.clusters import Objects as clusters
@@ -19,7 +18,7 @@ from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .entity import MatterEntity, MatterEntityDescription
+from .entity import MatterEntity
 from .helpers import get_matter
 from .models import MatterDiscoverySchema
 
@@ -47,11 +46,6 @@ async def async_setup_entry(
     matter.register_platform_handler(Platform.EVENT, async_add_entities)
 
 
-@dataclass(frozen=True)
-class MatterEventEntityDescription(EventEntityDescription, MatterEntityDescription):
-    """Describe Matter Event entities."""
-
-
 class MatterEventEntity(MatterEntity, EventEntity):
     """Representation of a Matter Event entity."""
 
@@ -138,7 +132,7 @@ class MatterEventEntity(MatterEntity, EventEntity):
 DISCOVERY_SCHEMAS = [
     MatterDiscoverySchema(
         platform=Platform.EVENT,
-        entity_description=MatterEventEntityDescription(
+        entity_description=EventEntityDescription(
             key="GenericSwitch",
             device_class=EventDeviceClass.BUTTON,
             translation_key="button",

homeassistant/components/matter/fan.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
 from chip.clusters import Objects as clusters
@@ -19,7 +18,7 @@ from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .entity import MatterEntity, MatterEntityDescription
+from .entity import MatterEntity
 from .helpers import get_matter
 from .models import MatterDiscoverySchema
 
@@ -53,11 +52,6 @@ async def async_setup_entry(
     matter.register_platform_handler(Platform.FAN, async_add_entities)
 
 
-@dataclass(frozen=True)
-class MatterFanEntityDescription(FanEntityDescription, MatterEntityDescription):
-    """Describe Matter Fan entities."""
-
-
 class MatterFan(MatterEntity, FanEntity):
     """Representation of a Matter fan."""
 
@@ -314,7 +308,7 @@ class MatterFan(MatterEntity, FanEntity):
 DISCOVERY_SCHEMAS = [
     MatterDiscoverySchema(
         platform=Platform.FAN,
-        entity_description=MatterFanEntityDescription(
+        entity_description=FanEntityDescription(
             key="MatterFan",
             name=None,
         ),

homeassistant/components/matter/light.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
 from typing import Any
 
 from chip.clusters import Objects as clusters
@@ -30,7 +29,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import color as color_util
 
 from .const import LOGGER
-from .entity import MatterEntity, MatterEntityDescription
+from .entity import MatterEntity
 from .helpers import get_matter
 from .models import MatterDiscoverySchema
 from .util import (
@@ -86,15 +85,10 @@ async def async_setup_entry(
     matter.register_platform_handler(Platform.LIGHT, async_add_entities)
 
 
-@dataclass(frozen=True)
-class MatterLightEntityDescription(LightEntityDescription, MatterEntityDescription):
-    """Describe Matter Light entities."""
-
-
 class MatterLight(MatterEntity, LightEntity):
     """Representation of a Matter light."""
 
-    entity_description: MatterLightEntityDescription
+    entity_description: LightEntityDescription
     _supports_brightness = False
     _supports_color = False
     _supports_color_temperature = False
@@ -464,7 +458,7 @@ class MatterLight(MatterEntity, LightEntity):
 DISCOVERY_SCHEMAS = [
     MatterDiscoverySchema(
         platform=Platform.LIGHT,
-        entity_description=MatterLightEntityDescription(
+        entity_description=LightEntityDescription(
             key="MatterLight",
             name=None,
         ),
@@ -493,7 +487,7 @@ DISCOVERY_SCHEMAS = [
     # Additional schema to match (HS Color) lights with incorrect/missing device type
     MatterDiscoverySchema(
         platform=Platform.LIGHT,
-        entity_description=MatterLightEntityDescription(
+        entity_description=LightEntityDescription(
             key="MatterHSColorLightFallback",
             name=None,
         ),
@@ -514,7 +508,7 @@ DISCOVERY_SCHEMAS = [
     # Additional schema to match (XY Color) lights with incorrect/missing device type
     MatterDiscoverySchema(
         platform=Platform.LIGHT,
-        entity_description=MatterLightEntityDescription(
+        entity_description=LightEntityDescription(
             key="MatterXYColorLightFallback",
             name=None,
         ),
@@ -535,7 +529,7 @@ DISCOVERY_SCHEMAS = [
     # Additional schema to match (color temperature) lights with incorrect/missing device type
     MatterDiscoverySchema(
         platform=Platform.LIGHT,
-        entity_description=MatterLightEntityDescription(
+        entity_description=LightEntityDescription(
             key="MatterColorTemperatureLightFallback",
             name=None,
         ),

homeassistant/components/matter/lock.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import asyncio
-from dataclasses import dataclass
 from typing import Any
 
 from chip.clusters import Objects as clusters
@@ -20,7 +19,7 @@ from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .const import LOGGER
-from .entity import MatterEntity, MatterEntityDescription
+from .entity import MatterEntity
 from .helpers import get_matter
 from .models import MatterDiscoverySchema
 
@@ -53,11 +52,6 @@ async def async_setup_entry(
     matter.register_platform_handler(Platform.LOCK, async_add_entities)
 
 
-@dataclass(frozen=True)
-class MatterLockEntityDescription(LockEntityDescription, MatterEntityDescription):
-    """Describe Matter Lock entities."""
-
-
 class MatterLock(MatterEntity, LockEntity):
     """Representation of a Matter lock."""
 
@@ -260,7 +254,7 @@ class MatterLock(MatterEntity, LockEntity):
 DISCOVERY_SCHEMAS = [
     MatterDiscoverySchema(
         platform=Platform.LOCK,
-        entity_description=MatterLockEntityDescription(
+        entity_description=LockEntityDescription(
             key="MatterLock",
             name=None,
         ),

homeassistant/components/matter/models.py

@@ -11,8 +11,7 @@ from matter_server.client.models.device_types import DeviceType
 from matter_server.client.models.node import MatterEndpoint
 
 from homeassistant.const import Platform
-
-from .entity import MatterEntityDescription
+from homeassistant.helpers.entity import EntityDescription
 
 type SensorValueTypes = type[
     clusters.uint | int | clusters.Nullable | clusters.float32 | float
@@ -55,7 +54,7 @@ class MatterEntityInfo:
     attributes_to_watch: list[type[ClusterAttributeDescriptor]]
 
     # the entity description to use
-    entity_description: MatterEntityDescription
+    entity_description: EntityDescription
 
     # entity class to use to instantiate the entity
     entity_class: type
@@ -81,7 +80,7 @@ class MatterDiscoverySchema:
     platform: Platform
 
     # platform-specific entity description
-    entity_description: MatterEntityDescription
+    entity_description: EntityDescription
 
     # entity class to use to instantiate the entity
     entity_class: type

homeassistant/components/matter/switch.py

@@ -42,11 +42,6 @@ async def async_setup_entry(
     matter.register_platform_handler(Platform.SWITCH, async_add_entities)
 
 
-@dataclass(frozen=True)
-class MatterSwitchEntityDescription(SwitchEntityDescription, MatterEntityDescription):
-    """Describe Matter Switch entities."""
-
-
 class MatterSwitch(MatterEntity, SwitchEntity):
     """Representation of a Matter switch."""
 
@@ -173,7 +168,7 @@ class MatterNumericSwitch(MatterSwitch):
 DISCOVERY_SCHEMAS = [
     MatterDiscoverySchema(
         platform=Platform.SWITCH,
-        entity_description=MatterSwitchEntityDescription(
+        entity_description=SwitchEntityDescription(
             key="MatterPlug",
             device_class=SwitchDeviceClass.OUTLET,
             name=None,
@@ -184,7 +179,7 @@ DISCOVERY_SCHEMAS = [
     ),
     MatterDiscoverySchema(
         platform=Platform.SWITCH,
-        entity_description=MatterSwitchEntityDescription(
+        entity_description=SwitchEntityDescription(
             key="MatterPowerToggle",
             device_class=SwitchDeviceClass.SWITCH,
             translation_key="power",
@@ -212,7 +207,7 @@ DISCOVERY_SCHEMAS = [
     ),
     MatterDiscoverySchema(
         platform=Platform.SWITCH,
-        entity_description=MatterSwitchEntityDescription(
+        entity_description=SwitchEntityDescription(
             key="MatterSwitch",
             device_class=SwitchDeviceClass.OUTLET,
             name=None,

homeassistant/components/matter/update.py

@@ -25,7 +25,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.event import async_call_later
 from homeassistant.helpers.restore_state import ExtraStoredData
 
-from .entity import MatterEntity, MatterEntityDescription
+from .entity import MatterEntity
 from .helpers import get_matter
 from .models import MatterDiscoverySchema
 
@@ -67,11 +67,6 @@ async def async_setup_entry(
     matter.register_platform_handler(Platform.UPDATE, async_add_entities)
 
 
-@dataclass(frozen=True)
-class MatterUpdateEntityDescription(UpdateEntityDescription, MatterEntityDescription):
-    """Describe Matter Update entities."""
-
-
 class MatterUpdate(MatterEntity, UpdateEntity):
     """Representation of a Matter node capable of updating."""
 
@@ -255,7 +250,7 @@ class MatterUpdate(MatterEntity, UpdateEntity):
 DISCOVERY_SCHEMAS = [
     MatterDiscoverySchema(
         platform=Platform.UPDATE,
-        entity_description=MatterUpdateEntityDescription(
+        entity_description=UpdateEntityDescription(
             key="MatterUpdate", device_class=UpdateDeviceClass.FIRMWARE
         ),
         entity_class=MatterUpdate,

homeassistant/components/matter/vacuum.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
 from enum import IntEnum
 from typing import TYPE_CHECKING, Any
 
@@ -21,7 +20,7 @@ from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .entity import MatterEntity, MatterEntityDescription
+from .entity import MatterEntity
 from .helpers import get_matter
 from .models import MatterDiscoverySchema
 
@@ -59,13 +58,6 @@ async def async_setup_entry(
     matter.register_platform_handler(Platform.VACUUM, async_add_entities)
 
 
-@dataclass(frozen=True)
-class MatterStateVacuumEntityDescription(
-    StateVacuumEntityDescription, MatterEntityDescription
-):
-    """Describe Matter Vacuum entities."""
-
-
 class MatterVacuum(MatterEntity, StateVacuumEntity):
     """Representation of a Matter Vacuum cleaner entity."""
 
@@ -73,7 +65,7 @@ class MatterVacuum(MatterEntity, StateVacuumEntity):
     _supported_run_modes: (
         dict[int, clusters.RvcRunMode.Structs.ModeOptionStruct] | None
     ) = None
-    entity_description: MatterStateVacuumEntityDescription
+    entity_description: StateVacuumEntityDescription
     _platform_translation_key = "vacuum"
 
     def _get_run_mode_by_tag(
@@ -220,7 +212,7 @@ class MatterVacuum(MatterEntity, StateVacuumEntity):
 DISCOVERY_SCHEMAS = [
     MatterDiscoverySchema(
         platform=Platform.VACUUM,
-        entity_description=MatterStateVacuumEntityDescription(
+        entity_description=StateVacuumEntityDescription(
             key="MatterVacuumCleaner", name=None
         ),
         entity_class=MatterVacuum,

homeassistant/components/matter/valve.py

@@ -2,8 +2,6 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
-
 from chip.clusters import Objects as clusters
 from matter_server.client.models import device_types
 
@@ -18,7 +16,7 @@ from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .entity import MatterEntity, MatterEntityDescription
+from .entity import MatterEntity
 from .helpers import get_matter
 from .models import MatterDiscoverySchema
 
@@ -36,16 +34,11 @@ async def async_setup_entry(
     matter.register_platform_handler(Platform.VALVE, async_add_entities)
 
 
-@dataclass(frozen=True)
-class MatterValveEntityDescription(ValveEntityDescription, MatterEntityDescription):
-    """Describe Matter Valve entities."""
-
-
 class MatterValve(MatterEntity, ValveEntity):
     """Representation of a Matter Valve."""
 
     _feature_map: int | None = None
-    entity_description: MatterValveEntityDescription
+    entity_description: ValveEntityDescription
     _platform_translation_key = "valve"
 
     async def async_open_valve(self) -> None:
@@ -135,7 +128,7 @@ class MatterValve(MatterEntity, ValveEntity):
 DISCOVERY_SCHEMAS = [
     MatterDiscoverySchema(
         platform=Platform.VALVE,
-        entity_description=MatterValveEntityDescription(
+        entity_description=ValveEntityDescription(
             key="MatterValve",
             device_class=ValveDeviceClass.WATER,
             name=None,

homeassistant/components/matter/water_heater.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
 from typing import Any, cast
 
 from chip.clusters import Objects as clusters
@@ -27,7 +26,7 @@ from homeassistant.const import (
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .entity import MatterEntity, MatterEntityDescription
+from .entity import MatterEntity
 from .helpers import get_matter
 from .models import MatterDiscoverySchema
 
@@ -51,13 +50,6 @@ async def async_setup_entry(
     matter.register_platform_handler(Platform.WATER_HEATER, async_add_entities)
 
 
-@dataclass(frozen=True)
-class MatterWaterHeaterEntityDescription(
-    WaterHeaterEntityDescription, MatterEntityDescription
-):
-    """Describe Matter Water Heater entities."""
-
-
 class MatterWaterHeater(MatterEntity, WaterHeaterEntity):
     """Representation of a Matter WaterHeater entity."""
 
@@ -179,7 +171,7 @@ class MatterWaterHeater(MatterEntity, WaterHeaterEntity):
 DISCOVERY_SCHEMAS = [
     MatterDiscoverySchema(
         platform=Platform.WATER_HEATER,
-        entity_description=MatterWaterHeaterEntityDescription(
+        entity_description=WaterHeaterEntityDescription(
             key="MatterWaterHeater",
             name=None,
         ),

homeassistant/components/mcp/config_flow.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 from collections.abc import Mapping
-from dataclasses import dataclass
 import logging
 from typing import Any, cast
 
@@ -24,13 +23,7 @@ from homeassistant.helpers.config_entry_oauth2_flow import (
 
 from . import async_get_config_entry_implementation
 from .application_credentials import authorization_server_context
-from .const import (
-    CONF_ACCESS_TOKEN,
-    CONF_AUTHORIZATION_URL,
-    CONF_SCOPE,
-    CONF_TOKEN_URL,
-    DOMAIN,
-)
+from .const import CONF_ACCESS_TOKEN, CONF_AUTHORIZATION_URL, CONF_TOKEN_URL, DOMAIN
 from .coordinator import TokenManager, mcp_client
 
 _LOGGER = logging.getLogger(__name__)
@@ -48,17 +41,9 @@ MCP_DISCOVERY_HEADERS = {
 }
 
 
-@dataclass
-class OAuthConfig:
-    """Class to hold OAuth configuration."""
-
-    authorization_server: AuthorizationServer
-    scopes: list[str] | None = None
-
-
 async def async_discover_oauth_config(
     hass: HomeAssistant, mcp_server_url: str
-) -> OAuthConfig:
+) -> AuthorizationServer:
     """Discover the OAuth configuration for the MCP server.
 
     This implements the functionality in the MCP spec for discovery. If the MCP server URL
@@ -80,11 +65,9 @@ async def async_discover_oauth_config(
     except httpx.HTTPStatusError as error:
         if error.response.status_code == 404:
             _LOGGER.info("Authorization Server Metadata not found, using default paths")
-            return OAuthConfig(
-                authorization_server=AuthorizationServer(
-                    authorize_url=str(parsed_url.with_path("/authorize")),
-                    token_url=str(parsed_url.with_path("/token")),
-                )
+            return AuthorizationServer(
+                authorize_url=str(parsed_url.with_path("/authorize")),
+                token_url=str(parsed_url.with_path("/token")),
             )
         raise CannotConnect from error
     except httpx.HTTPError as error:
@@ -98,15 +81,9 @@ async def async_discover_oauth_config(
         authorize_url = str(parsed_url.with_path(authorize_url))
     if token_url.startswith("/"):
         token_url = str(parsed_url.with_path(token_url))
-    # We have no way to know the minimum set of scopes needed, so request
-    # all of them and let the user limit during the authorization step.
-    scopes = data.get("scopes_supported")
-    return OAuthConfig(
-        authorization_server=AuthorizationServer(
-            authorize_url=authorize_url,
-            token_url=token_url,
-        ),
-        scopes=scopes,
+    return AuthorizationServer(
+        authorize_url=authorize_url,
+        token_url=token_url,
     )
 
 
@@ -153,7 +130,6 @@ class ModelContextProtocolConfigFlow(AbstractOAuth2FlowHandler, domain=DOMAIN):
         """Initialize the config flow."""
         super().__init__()
         self.data: dict[str, Any] = {}
-        self.oauth_config: OAuthConfig | None = None
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
@@ -194,7 +170,7 @@ class ModelContextProtocolConfigFlow(AbstractOAuth2FlowHandler, domain=DOMAIN):
         to find the OAuth medata then run the OAuth authentication flow.
         """
         try:
-            oauth_config = await async_discover_oauth_config(
+            authorization_server = await async_discover_oauth_config(
                 self.hass, self.data[CONF_URL]
             )
         except TimeoutConnectError:
@@ -205,13 +181,11 @@ class ModelContextProtocolConfigFlow(AbstractOAuth2FlowHandler, domain=DOMAIN):
             _LOGGER.exception("Unexpected exception")
             return self.async_abort(reason="unknown")
         else:
-            _LOGGER.info("OAuth configuration: %s", oauth_config)
-            self.oauth_config = oauth_config
+            _LOGGER.info("OAuth configuration: %s", authorization_server)
             self.data.update(
                 {
-                    CONF_AUTHORIZATION_URL: oauth_config.authorization_server.authorize_url,
-                    CONF_TOKEN_URL: oauth_config.authorization_server.token_url,
-                    CONF_SCOPE: oauth_config.scopes,
+                    CONF_AUTHORIZATION_URL: authorization_server.authorize_url,
+                    CONF_TOKEN_URL: authorization_server.token_url,
                 }
             )
             return await self.async_step_credentials_choice()
@@ -223,15 +197,6 @@ class ModelContextProtocolConfigFlow(AbstractOAuth2FlowHandler, domain=DOMAIN):
             self.data[CONF_TOKEN_URL],
         )
 
-    @property
-    def extra_authorize_data(self) -> dict:
-        """Extra data that needs to be appended to the authorize url."""
-        data = {}
-        if self.data and (scopes := self.data[CONF_SCOPE]) is not None:
-            data[CONF_SCOPE] = " ".join(scopes)
-        data.update(super().extra_authorize_data)
-        return data
-
     async def async_step_credentials_choice(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult: