Update snapshots

.github/workflows/builder.yml

@@ -235,7 +235,6 @@ jobs:
           build-args: |
             BUILD_FROM=${{ steps.vars.outputs.base_image }}
           tags: ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:${{ needs.init.outputs.version }}
-          outputs: type=image,push=true,compression=zstd,compression-level=9,force-compression=true,oci-mediatypes=true
           labels: |
             io.hass.arch=${{ matrix.arch }}
             io.hass.version=${{ needs.init.outputs.version }}

.github/workflows/codeql.yml

@@ -24,11 +24,11 @@ jobs:
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@45cbd0c69e560cd9e7cd7f8c32362050c9b7ded2 # v4.32.2
+        uses: github/codeql-action/init@b20883b0cd1f46c72ae0ba6d1090936928f9fa30 # v4.32.0
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@45cbd0c69e560cd9e7cd7f8c32362050c9b7ded2 # v4.32.2
+        uses: github/codeql-action/analyze@b20883b0cd1f46c72ae0ba6d1090936928f9fa30 # v4.32.0
         with:
           category: "/language:python"

.strict-typing

@@ -221,7 +221,6 @@ homeassistant.components.generic_hygrostat.*
 homeassistant.components.generic_thermostat.*
 homeassistant.components.geo_location.*
 homeassistant.components.geocaching.*
-homeassistant.components.ghost.*
 homeassistant.components.gios.*
 homeassistant.components.github.*
 homeassistant.components.glances.*
@@ -436,7 +435,6 @@ homeassistant.components.raspberry_pi.*
 homeassistant.components.rdw.*
 homeassistant.components.recollect_waste.*
 homeassistant.components.recorder.*
-homeassistant.components.redgtech.*
 homeassistant.components.remember_the_milk.*
 homeassistant.components.remote.*
 homeassistant.components.remote_calendar.*

CODEOWNERS

@@ -595,8 +595,6 @@ build.json @home-assistant/supervisor
 /tests/components/geonetnz_quakes/ @exxamalte
 /homeassistant/components/geonetnz_volcano/ @exxamalte
 /tests/components/geonetnz_volcano/ @exxamalte
-/homeassistant/components/ghost/ @johnonolan
-/tests/components/ghost/ @johnonolan
 /homeassistant/components/gios/ @bieniu
 /tests/components/gios/ @bieniu
 /homeassistant/components/github/ @timmo001 @ludeeus
@@ -1357,8 +1355,6 @@ build.json @home-assistant/supervisor
 /tests/components/recorder/ @home-assistant/core
 /homeassistant/components/recovery_mode/ @home-assistant/core
 /tests/components/recovery_mode/ @home-assistant/core
-/homeassistant/components/redgtech/ @jonhsady @luan-nvg
-/tests/components/redgtech/ @jonhsady @luan-nvg
 /homeassistant/components/refoss/ @ashionky
 /tests/components/refoss/ @ashionky
 /homeassistant/components/rehlko/ @bdraco @peterager

homeassistant/brands/heatit.json

@@ -1,5 +0,0 @@
-{
-  "domain": "heatit",
-  "name": "Heatit",
-  "iot_standards": ["zwave"]
-}

homeassistant/brands/heiman.json

@@ -1,5 +0,0 @@
-{
-  "domain": "heiman",
-  "name": "Heiman",
-  "iot_standards": ["matter", "zigbee"]
-}

homeassistant/components/abode/config_flow.py

@@ -64,7 +64,7 @@ class AbodeFlowHandler(ConfigFlow, domain=DOMAIN):
             else:
                 errors = {"base": "cannot_connect"}
 
-        except ConnectTimeout, HTTPError:
+        except (ConnectTimeout, HTTPError):
             errors = {"base": "cannot_connect"}
 
         if errors:

homeassistant/components/abode/light.py

@@ -99,7 +99,7 @@ class AbodeLight(AbodeDevice, LightEntity):
         return _hs
 
     @property
-    def color_mode(self) -> ColorMode:
+    def color_mode(self) -> ColorMode | None:
         """Return the color mode of the light."""
         if self._device.is_dimmable and self._device.is_color_capable:
             if self.hs_color is not None:
@@ -110,7 +110,7 @@ class AbodeLight(AbodeDevice, LightEntity):
         return ColorMode.ONOFF
 
     @property
-    def supported_color_modes(self) -> set[ColorMode]:
+    def supported_color_modes(self) -> set[ColorMode] | None:
         """Flag supported color modes."""
         if self._device.is_dimmable and self._device.is_color_capable:
             return {ColorMode.COLOR_TEMP, ColorMode.HS}

homeassistant/components/accuweather/config_flow.py

@@ -43,7 +43,7 @@ class AccuWeatherFlowHandler(ConfigFlow, domain=DOMAIN):
                         longitude=user_input[CONF_LONGITUDE],
                     )
                     await accuweather.async_get_location()
-            except ApiError, ClientConnectorError, TimeoutError, ClientError:
+            except (ApiError, ClientConnectorError, TimeoutError, ClientError):
                 errors["base"] = "cannot_connect"
             except InvalidApiKeyError:
                 errors[CONF_API_KEY] = "invalid_api_key"
@@ -104,7 +104,7 @@ class AccuWeatherFlowHandler(ConfigFlow, domain=DOMAIN):
                         longitude=self._longitude,
                     )
                     await accuweather.async_get_location()
-            except ApiError, ClientConnectorError, TimeoutError, ClientError:
+            except (ApiError, ClientConnectorError, TimeoutError, ClientError):
                 errors["base"] = "cannot_connect"
             except InvalidApiKeyError:
                 errors["base"] = "invalid_api_key"

homeassistant/components/actron_air/switch.py

@@ -29,42 +29,30 @@ SWITCHES: tuple[ActronAirSwitchEntityDescription, ...] = (
         key="away_mode",
         translation_key="away_mode",
         is_on_fn=lambda coordinator: coordinator.data.user_aircon_settings.away_mode,
-        set_fn=lambda coordinator, enabled: (
-            coordinator.data.user_aircon_settings.set_away_mode(enabled)
-        ),
+        set_fn=lambda coordinator,
+        enabled: coordinator.data.user_aircon_settings.set_away_mode(enabled),
     ),
     ActronAirSwitchEntityDescription(
         key="continuous_fan",
         translation_key="continuous_fan",
-        is_on_fn=lambda coordinator: (
-            coordinator.data.user_aircon_settings.continuous_fan_enabled
-        ),
-        set_fn=lambda coordinator, enabled: (
-            coordinator.data.user_aircon_settings.set_continuous_mode(enabled)
-        ),
+        is_on_fn=lambda coordinator: coordinator.data.user_aircon_settings.continuous_fan_enabled,
+        set_fn=lambda coordinator,
+        enabled: coordinator.data.user_aircon_settings.set_continuous_mode(enabled),
     ),
     ActronAirSwitchEntityDescription(
         key="quiet_mode",
         translation_key="quiet_mode",
-        is_on_fn=lambda coordinator: (
-            coordinator.data.user_aircon_settings.quiet_mode_enabled
-        ),
-        set_fn=lambda coordinator, enabled: (
-            coordinator.data.user_aircon_settings.set_quiet_mode(enabled)
-        ),
+        is_on_fn=lambda coordinator: coordinator.data.user_aircon_settings.quiet_mode_enabled,
+        set_fn=lambda coordinator,
+        enabled: coordinator.data.user_aircon_settings.set_quiet_mode(enabled),
     ),
     ActronAirSwitchEntityDescription(
         key="turbo_mode",
         translation_key="turbo_mode",
-        is_on_fn=lambda coordinator: (
-            coordinator.data.user_aircon_settings.turbo_enabled
-        ),
-        set_fn=lambda coordinator, enabled: (
-            coordinator.data.user_aircon_settings.set_turbo_mode(enabled)
-        ),
-        is_supported_fn=lambda coordinator: (
-            coordinator.data.user_aircon_settings.turbo_supported
-        ),
+        is_on_fn=lambda coordinator: coordinator.data.user_aircon_settings.turbo_enabled,
+        set_fn=lambda coordinator,
+        enabled: coordinator.data.user_aircon_settings.set_turbo_mode(enabled),
+        is_supported_fn=lambda coordinator: coordinator.data.user_aircon_settings.turbo_supported,
     ),
 )
 

homeassistant/components/airgradient/select.py

@@ -133,9 +133,8 @@ CONTROL_ENTITIES: tuple[AirGradientSelectEntityDescription, ...] = (
         value_fn=lambda config: _get_value(
             config.co2_automatic_baseline_calibration_days, ABC_DAYS
         ),
-        set_value_fn=lambda client, value: (
-            client.set_co2_automatic_baseline_calibration(int(value))
-        ),
+        set_value_fn=lambda client,
+        value: client.set_co2_automatic_baseline_calibration(int(value)),
     ),
 )
 

homeassistant/components/airobot/button.py

@@ -85,7 +85,7 @@ class AirobotButton(AirobotEntity, ButtonEntity):
         """Handle the button press."""
         try:
             await self.entity_description.press_fn(self.coordinator)
-        except AirobotConnectionError, AirobotTimeoutError:
+        except (AirobotConnectionError, AirobotTimeoutError):
             # Connection errors during reboot are expected as device restarts
             pass
         except AirobotError as err:

homeassistant/components/airos/config_flow.py

@@ -114,7 +114,7 @@ class AirOSConfigFlow(ConfigFlow, domain=DOMAIN):
             AirOSDeviceConnectionError,
         ):
             self.errors["base"] = "cannot_connect"
-        except AirOSConnectionAuthenticationError, AirOSDataMissingError:
+        except (AirOSConnectionAuthenticationError, AirOSDataMissingError):
             self.errors["base"] = "invalid_auth"
         except AirOSKeyDataMissingError:
             self.errors["base"] = "key_data_missing"

homeassistant/components/airvisual/config_flow.py

@@ -130,7 +130,7 @@ class AirVisualFlowHandler(ConfigFlow, domain=DOMAIN):
 
                 try:
                     await coro
-                except InvalidKeyError, KeyExpiredError, UnauthorizedError:
+                except (InvalidKeyError, KeyExpiredError, UnauthorizedError):
                     errors[CONF_API_KEY] = "invalid_api_key"
                 except NotFoundError:
                     errors[CONF_CITY] = "location_not_found"

homeassistant/components/airzone_cloud/config_flow.py

@@ -100,7 +100,7 @@ class AirZoneCloudConfigFlow(ConfigFlow, domain=DOMAIN):
 
             try:
                 await self.airzone.login()
-            except AirzoneCloudError, LoginError:
+            except (AirzoneCloudError, LoginError):
                 errors["base"] = "cannot_connect"
             else:
                 return await self.async_step_inst_pick()

homeassistant/components/alexa/auth.py

@@ -123,7 +123,7 @@ class Auth:
                     allow_redirects=True,
                 )
 
-        except TimeoutError, aiohttp.ClientError:
+        except (TimeoutError, aiohttp.ClientError):
             _LOGGER.error("Timeout calling LWA to get auth token")
             return None
 

homeassistant/components/alexa/state_report.py

@@ -358,7 +358,7 @@ async def async_send_changereport_message(
     """
     try:
         token = await config.async_get_access_token()
-    except RequireRelink, NoTokenAvailable:
+    except (RequireRelink, NoTokenAvailable):
         await config.set_authorized(False)
         _LOGGER.error(
             "Error when sending ChangeReport to Alexa, could not get access token"
@@ -392,7 +392,7 @@ async def async_send_changereport_message(
                 allow_redirects=True,
             )
 
-    except TimeoutError, aiohttp.ClientError:
+    except (TimeoutError, aiohttp.ClientError):
         _LOGGER.error("Timeout sending report to Alexa for %s", alexa_entity.entity_id)
         return
 
@@ -549,7 +549,7 @@ async def async_send_doorbell_event_message(
                 allow_redirects=True,
             )
 
-    except TimeoutError, aiohttp.ClientError:
+    except (TimeoutError, aiohttp.ClientError):
         _LOGGER.error("Timeout sending report to Alexa for %s", alexa_entity.entity_id)
         return
 

homeassistant/components/alexa_devices/manifest.json

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

homeassistant/components/alexa_devices/sensor.py

@@ -28,7 +28,6 @@ from homeassistant.helpers.typing import StateType
 from .const import CATEGORY_NOTIFICATIONS, CATEGORY_SENSORS
 from .coordinator import AmazonConfigEntry
 from .entity import AmazonEntity
-from .utils import async_remove_unsupported_notification_sensors
 
 # Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
@@ -106,9 +105,6 @@ async def async_setup_entry(
 
     coordinator = entry.runtime_data
 
-    # Remove notification sensors from unsupported devices
-    await async_remove_unsupported_notification_sensors(hass, coordinator)
-
     known_devices: set[str] = set()
 
     def _check_device() -> None:
@@ -126,7 +122,6 @@ async def async_setup_entry(
                 AmazonSensorEntity(coordinator, serial_num, notification_desc)
                 for notification_desc in NOTIFICATIONS
                 for serial_num in new_devices
-                if coordinator.data[serial_num].notifications_supported
             ]
             async_add_entities(sensors_list + notifications_list)
 

homeassistant/components/alexa_devices/strings.json

@@ -90,9 +90,6 @@
     "cannot_retrieve_data_with_error": {
       "message": "Error retrieving data: {error}"
     },
-    "config_entry_not_found": {
-      "message": "Config entry not found: {device_id}"
-    },
     "device_serial_number_missing": {
       "message": "Device serial number missing: {device_id}"
     },

homeassistant/components/alexa_devices/switch.py

@@ -59,15 +59,13 @@ async def async_setup_entry(
 
     coordinator = entry.runtime_data
 
-    # DND keys
-    old_key = "do_not_disturb"
-    new_key = "dnd"
+    # Replace unique id for "DND" switch and remove from Speaker Group
+    await async_update_unique_id(
+        hass, coordinator, SWITCH_DOMAIN, "do_not_disturb", "dnd"
+    )
 
-    # Remove old DND switch from virtual groups
-    await async_remove_dnd_from_virtual_group(hass, coordinator, old_key)
-
-    # Replace unique id for DND switch
-    await async_update_unique_id(hass, coordinator, SWITCH_DOMAIN, old_key, new_key)
+    # Remove DND switch from virtual groups
+    await async_remove_dnd_from_virtual_group(hass, coordinator)
 
     known_devices: set[str] = set()
 

homeassistant/components/alexa_devices/utils.py

@@ -5,14 +5,8 @@ from functools import wraps
 from typing import Any, Concatenate
 
 from aioamazondevices.const.devices import SPEAKER_GROUP_FAMILY
-from aioamazondevices.const.schedules import (
-    NOTIFICATION_ALARM,
-    NOTIFICATION_REMINDER,
-    NOTIFICATION_TIMER,
-)
 from aioamazondevices.exceptions import CannotConnect, CannotRetrieveData
 
-from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
 from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
@@ -54,7 +48,7 @@ def alexa_api_call[_T: AmazonEntity, **_P](
 async def async_update_unique_id(
     hass: HomeAssistant,
     coordinator: AmazonDevicesCoordinator,
-    platform: str,
+    domain: str,
     old_key: str,
     new_key: str,
 ) -> None:
@@ -63,9 +57,7 @@ async def async_update_unique_id(
 
     for serial_num in coordinator.data:
         unique_id = f"{serial_num}-{old_key}"
-        if entity_id := entity_registry.async_get_entity_id(
-            DOMAIN, platform, unique_id
-        ):
+        if entity_id := entity_registry.async_get_entity_id(domain, DOMAIN, unique_id):
             _LOGGER.debug("Updating unique_id for %s", entity_id)
             new_unique_id = unique_id.replace(old_key, new_key)
 
@@ -76,13 +68,12 @@ async def async_update_unique_id(
 async def async_remove_dnd_from_virtual_group(
     hass: HomeAssistant,
     coordinator: AmazonDevicesCoordinator,
-    key: str,
 ) -> None:
     """Remove entity DND from virtual group."""
     entity_registry = er.async_get(hass)
 
     for serial_num in coordinator.data:
-        unique_id = f"{serial_num}-{key}"
+        unique_id = f"{serial_num}-do_not_disturb"
         entity_id = entity_registry.async_get_entity_id(
             DOMAIN, SWITCH_DOMAIN, unique_id
         )
@@ -90,27 +81,3 @@ async def async_remove_dnd_from_virtual_group(
         if entity_id and is_group:
             entity_registry.async_remove(entity_id)
             _LOGGER.debug("Removed DND switch from virtual group %s", entity_id)
-
-
-async def async_remove_unsupported_notification_sensors(
-    hass: HomeAssistant,
-    coordinator: AmazonDevicesCoordinator,
-) -> None:
-    """Remove notification sensors from unsupported devices."""
-    entity_registry = er.async_get(hass)
-
-    for serial_num in coordinator.data:
-        for notification_key in (
-            NOTIFICATION_ALARM,
-            NOTIFICATION_REMINDER,
-            NOTIFICATION_TIMER,
-        ):
-            unique_id = f"{serial_num}-{notification_key}"
-            entity_id = entity_registry.async_get_entity_id(
-                DOMAIN, SENSOR_DOMAIN, unique_id=unique_id
-            )
-            is_unsupported = not coordinator.data[serial_num].notifications_supported
-
-            if entity_id and is_unsupported:
-                entity_registry.async_remove(entity_id)
-                _LOGGER.debug("Removed unsupported notification sensor %s", entity_id)

homeassistant/components/ambient_network/config_flow.py

@@ -77,11 +77,9 @@ class AmbientNetworkConfigFlow(ConfigFlow, domain=DOMAIN):
             # Filter out indoor stations
             self._stations = dict(
                 filter(
-                    lambda item: (
-                        not item[1]
-                        .get(API_STATION_INFO, {})
-                        .get(API_STATION_INDOOR, False)
-                    ),
+                    lambda item: not item[1]
+                    .get(API_STATION_INFO, {})
+                    .get(API_STATION_INDOOR, False),
                     self._stations.items(),
                 )
             )
@@ -115,7 +113,7 @@ class AmbientNetworkConfigFlow(ConfigFlow, domain=DOMAIN):
         )
 
         return self.async_show_form(
-            step_id=CONF_USER, data_schema=schema, errors=errors or {}
+            step_id=CONF_USER, data_schema=schema, errors=errors if errors else {}
         )
 
     async def async_step_station(

homeassistant/components/ambient_station/config_flow.py

@@ -31,7 +31,7 @@ class AmbientStationFlowHandler(ConfigFlow, domain=DOMAIN):
         return self.async_show_form(
             step_id="user",
             data_schema=self.data_schema,
-            errors=errors or {},
+            errors=errors if errors else {},
         )
 
     async def async_step_user(

homeassistant/components/ambient_station/sensor.py

@@ -26,9 +26,10 @@ from homeassistant.const import (
     UnitOfVolumetricFlux,
 )
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.entity import EntityDescription
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from . import AmbientStationConfigEntry
+from . import AmbientStation, AmbientStationConfigEntry
 from .const import ATTR_LAST_DATA, TYPE_SOLARRADIATION, TYPE_SOLARRADIATION_LX
 from .entity import AmbientWeatherEntity
 
@@ -682,6 +683,22 @@ async def async_setup_entry(
 class AmbientWeatherSensor(AmbientWeatherEntity, SensorEntity):
     """Define an Ambient sensor."""
 
+    def __init__(
+        self,
+        ambient: AmbientStation,
+        mac_address: str,
+        station_name: str,
+        description: EntityDescription,
+    ) -> None:
+        """Initialize the sensor."""
+        super().__init__(ambient, mac_address, station_name, description)
+
+        if description.key == TYPE_SOLARRADIATION_LX:
+            # Since TYPE_SOLARRADIATION and TYPE_SOLARRADIATION_LX will have the same
+            # name in the UI, we influence the entity ID of TYPE_SOLARRADIATION_LX here
+            # to differentiate them:
+            self.entity_id = f"sensor.{station_name}_solar_rad_lx"
+
     @callback
     def update_from_latest_data(self) -> None:
         """Fetch new state data for the sensor."""

homeassistant/components/amcrest/__init__.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import asyncio
-from collections.abc import AsyncGenerator, Callable
+from collections.abc import AsyncIterator, Callable
 from contextlib import asynccontextmanager, suppress
 from dataclasses import dataclass
 from datetime import datetime, timedelta
@@ -202,7 +202,7 @@ class AmcrestChecker(ApiWrapper):
     @asynccontextmanager
     async def async_stream_command(
         self, *args: Any, **kwargs: Any
-    ) -> AsyncGenerator[httpx.Response]:
+    ) -> AsyncIterator[httpx.Response]:
         """amcrest.ApiWrapper.command wrapper to catch errors."""
         async with (
             self._async_command_wrapper(),
@@ -211,7 +211,7 @@ class AmcrestChecker(ApiWrapper):
             yield ret
 
     @asynccontextmanager
-    async def _async_command_wrapper(self) -> AsyncGenerator[None]:
+    async def _async_command_wrapper(self) -> AsyncIterator[None]:
         try:
             yield
         except LoginError as ex:

homeassistant/components/analytics/manifest.json

@@ -10,7 +10,6 @@
   "preview_features": {
     "snapshots": {
       "feedback_url": "https://forms.gle/GqvRmgmghSDco8M46",
-      "learn_more_url": "https://www.home-assistant.io/blog/2026/02/02/about-device-database/",
       "report_issue_url": "https://github.com/OHF-Device-Database/device-database/issues/new"
     }
   },

homeassistant/components/analytics/strings.json

@@ -1,7 +1,7 @@
 {
   "preview_features": {
     "snapshots": {
-      "description": "We're creating the [Open Home Foundation Device Database](https://www.home-assistant.io/blog/2026/02/02/about-device-database/): a free, open source community-powered resource to help users find practical information about how smart home devices perform in real installations.\n\nYou can help us build it by opting in to share anonymized data about your devices. This data will only ever include device-specific details (like model or manufacturer) – never personally identifying information (like the names you assign).\n\nFind out how we process your data (should you choose to contribute) in our [Data Use Statement](https://www.openhomefoundation.org/device-database-data-use-statement).",
+      "description": "This free, open source device database of the Open Home Foundation helps users find useful information about smart home devices used in real installations.\n\nYou can help build it by anonymously sharing data about your devices. Only device-specific details (like model or manufacturer) are shared — never personally identifying information (like the names you assign).\n\nLearn more about the device database and how we process your data in our [Data Use Statement](https://www.openhomefoundation.org/device-database-data-use-statement), which you accept by opting in.",
       "disable_confirmation": "Your data will no longer be shared with the Open Home Foundation's device database.",
       "enable_confirmation": "This feature is still in development and may change. The device database is being refined based on user feedback and is not yet complete.",
       "name": "Device database"

homeassistant/components/androidtv_remote/config_flow.py

@@ -93,7 +93,7 @@ class AndroidTVRemoteConfigFlow(ConfigFlow, domain=DOMAIN):
                 self._abort_if_unique_id_configured(updates={CONF_HOST: self.host})
                 try:
                     return await self._async_start_pair()
-                except CannotConnect, ConnectionClosed:
+                except (CannotConnect, ConnectionClosed):
                     errors["base"] = "cannot_connect"
         else:
             user_input = {}
@@ -135,7 +135,7 @@ class AndroidTVRemoteConfigFlow(ConfigFlow, domain=DOMAIN):
                 # Attempt to pair again.
                 try:
                     return await self._async_start_pair()
-                except CannotConnect, ConnectionClosed:
+                except (CannotConnect, ConnectionClosed):
                     # Device doesn't respond to the specified host. Abort.
                     # If we are in the user flow we could go back to the user step to allow
                     # them to enter a new IP address but we cannot do that for the zeroconf
@@ -203,7 +203,7 @@ class AndroidTVRemoteConfigFlow(ConfigFlow, domain=DOMAIN):
         if user_input is not None:
             try:
                 return await self._async_start_pair()
-            except CannotConnect, ConnectionClosed:
+            except (CannotConnect, ConnectionClosed):
                 # Device became network unreachable after discovery.
                 # Abort and let discovery find it again later.
                 return self.async_abort(reason="cannot_connect")
@@ -229,7 +229,7 @@ class AndroidTVRemoteConfigFlow(ConfigFlow, domain=DOMAIN):
         if user_input is not None:
             try:
                 return await self._async_start_pair()
-            except CannotConnect, ConnectionClosed:
+            except (CannotConnect, ConnectionClosed):
                 # Device is network unreachable. Abort.
                 errors["base"] = "cannot_connect"
         return self.async_show_form(

homeassistant/components/anglian_water/config_flow.py

@@ -73,7 +73,7 @@ async def validate_account(auth: MSOB2CAuth, account_number: str) -> str | MSOB2
     _aw = AnglianWater(authenticator=auth)
     try:
         await _aw.validate_smart_meter(account_number)
-    except InvalidAccountIdError, SmartMeterUnavailableError:
+    except (InvalidAccountIdError, SmartMeterUnavailableError):
         return "smart_meter_unavailable"
     return auth
 

homeassistant/components/anthropic/__init__.py

@@ -14,18 +14,10 @@ from homeassistant.helpers import (
     config_validation as cv,
     device_registry as dr,
     entity_registry as er,
-    issue_registry as ir,
 )
 from homeassistant.helpers.typing import ConfigType
 
-from .const import (
-    CONF_CHAT_MODEL,
-    DATA_REPAIR_DEFER_RELOAD,
-    DEFAULT_CONVERSATION_NAME,
-    DEPRECATED_MODELS,
-    DOMAIN,
-    LOGGER,
-)
+from .const import DEFAULT_CONVERSATION_NAME, DOMAIN, LOGGER
 
 PLATFORMS = (Platform.AI_TASK, Platform.CONVERSATION)
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
@@ -35,7 +27,6 @@ type AnthropicConfigEntry = ConfigEntry[anthropic.AsyncClient]
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up Anthropic."""
-    hass.data.setdefault(DOMAIN, {}).setdefault(DATA_REPAIR_DEFER_RELOAD, set())
     await async_migrate_integration(hass)
     return True
 
@@ -59,22 +50,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: AnthropicConfigEntry) ->
 
     entry.async_on_unload(entry.add_update_listener(async_update_options))
 
-    for subentry in entry.subentries.values():
-        if (model := subentry.data.get(CONF_CHAT_MODEL)) and model.startswith(
-            tuple(DEPRECATED_MODELS)
-        ):
-            ir.async_create_issue(
-                hass,
-                DOMAIN,
-                "model_deprecated",
-                is_fixable=True,
-                is_persistent=False,
-                learn_more_url="https://platform.claude.com/docs/en/about-claude/model-deprecations",
-                severity=ir.IssueSeverity.WARNING,
-                translation_key="model_deprecated",
-            )
-            break
-
     return True
 
 
@@ -87,11 +62,6 @@ async def async_update_options(
     hass: HomeAssistant, entry: AnthropicConfigEntry
 ) -> None:
     """Update options."""
-    defer_reload_entries: set[str] = hass.data.setdefault(DOMAIN, {}).setdefault(
-        DATA_REPAIR_DEFER_RELOAD, set()
-    )
-    if entry.entry_id in defer_reload_entries:
-        return
     await hass.config_entries.async_reload(entry.entry_id)
 
 

homeassistant/components/anthropic/config_flow.py

@@ -36,7 +36,6 @@ from homeassistant.helpers.selector import (
     SelectOptionDict,
     SelectSelector,
     SelectSelectorConfig,
-    SelectSelectorMode,
     TemplateSelector,
 )
 from homeassistant.helpers.typing import VolDictType
@@ -48,7 +47,6 @@ from .const import (
     CONF_RECOMMENDED,
     CONF_TEMPERATURE,
     CONF_THINKING_BUDGET,
-    CONF_THINKING_EFFORT,
     CONF_WEB_SEARCH,
     CONF_WEB_SEARCH_CITY,
     CONF_WEB_SEARCH_COUNTRY,
@@ -60,7 +58,6 @@ from .const import (
     DEFAULT_AI_TASK_NAME,
     DEFAULT_CONVERSATION_NAME,
     DOMAIN,
-    NON_ADAPTIVE_THINKING_MODELS,
     NON_THINKING_MODELS,
     WEB_SEARCH_UNSUPPORTED_MODELS,
 )
@@ -95,41 +92,6 @@ async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> None:
     await client.models.list(timeout=10.0)
 
 
-async def get_model_list(client: anthropic.AsyncAnthropic) -> list[SelectOptionDict]:
-    """Get list of available models."""
-    try:
-        models = (await client.models.list()).data
-    except anthropic.AnthropicError:
-        models = []
-    _LOGGER.debug("Available models: %s", models)
-    model_options: list[SelectOptionDict] = []
-    short_form = re.compile(r"[^\d]-\d$")
-    for model_info in models:
-        # Resolve alias from versioned model name:
-        model_alias = (
-            model_info.id[:-9]
-            if model_info.id
-            not in (
-                "claude-3-haiku-20240307",
-                "claude-3-5-haiku-20241022",
-                "claude-3-opus-20240229",
-            )
-            and model_info.id[-2:-1] != "-"
-            else model_info.id
-        )
-        if short_form.search(model_alias):
-            model_alias += "-0"
-        if model_alias.endswith(("haiku", "opus", "sonnet")):
-            model_alias += "-latest"
-        model_options.append(
-            SelectOptionDict(
-                label=model_info.display_name,
-                value=model_alias,
-            )
-        )
-    return model_options
-
-
 class AnthropicConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Anthropic."""
 
@@ -358,9 +320,7 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
 
         model = self.options[CONF_CHAT_MODEL]
 
-        if not model.startswith(tuple(NON_THINKING_MODELS)) and model.startswith(
-            tuple(NON_ADAPTIVE_THINKING_MODELS)
-        ):
+        if not model.startswith(tuple(NON_THINKING_MODELS)):
             step_schema[
                 vol.Optional(
                     CONF_THINKING_BUDGET, default=DEFAULT[CONF_THINKING_BUDGET]
@@ -377,22 +337,6 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
         else:
             self.options.pop(CONF_THINKING_BUDGET, None)
 
-        if not model.startswith(tuple(NON_ADAPTIVE_THINKING_MODELS)):
-            step_schema[
-                vol.Optional(
-                    CONF_THINKING_EFFORT,
-                    default=DEFAULT[CONF_THINKING_EFFORT],
-                )
-            ] = SelectSelector(
-                SelectSelectorConfig(
-                    options=["none", "low", "medium", "high", "max"],
-                    translation_key=CONF_THINKING_EFFORT,
-                    mode=SelectSelectorMode.DROPDOWN,
-                )
-            )
-        else:
-            self.options.pop(CONF_THINKING_EFFORT, None)
-
         if not model.startswith(tuple(WEB_SEARCH_UNSUPPORTED_MODELS)):
             step_schema.update(
                 {
@@ -457,13 +401,38 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
 
     async def _get_model_list(self) -> list[SelectOptionDict]:
         """Get list of available models."""
-        client = await self.hass.async_add_executor_job(
-            partial(
-                anthropic.AsyncAnthropic,
-                api_key=self._get_entry().data[CONF_API_KEY],
+        try:
+            client = await self.hass.async_add_executor_job(
+                partial(
+                    anthropic.AsyncAnthropic,
+                    api_key=self._get_entry().data[CONF_API_KEY],
+                )
             )
-        )
-        return await get_model_list(client)
+            models = (await client.models.list()).data
+        except anthropic.AnthropicError:
+            models = []
+        _LOGGER.debug("Available models: %s", models)
+        model_options: list[SelectOptionDict] = []
+        short_form = re.compile(r"[^\d]-\d$")
+        for model_info in models:
+            # Resolve alias from versioned model name:
+            model_alias = (
+                model_info.id[:-9]
+                if model_info.id
+                not in ("claude-3-haiku-20240307", "claude-3-opus-20240229")
+                else model_info.id
+            )
+            if short_form.search(model_alias):
+                model_alias += "-0"
+            if model_alias.endswith(("haiku", "opus", "sonnet")):
+                model_alias += "-latest"
+            model_options.append(
+                SelectOptionDict(
+                    label=model_info.display_name,
+                    value=model_alias,
+                )
+            )
+        return model_options
 
     async def _get_location_data(self) -> dict[str, str]:
         """Get approximate location data of the user."""

homeassistant/components/anthropic/const.py

@@ -14,7 +14,6 @@ CONF_CHAT_MODEL = "chat_model"
 CONF_MAX_TOKENS = "max_tokens"
 CONF_TEMPERATURE = "temperature"
 CONF_THINKING_BUDGET = "thinking_budget"
-CONF_THINKING_EFFORT = "thinking_effort"
 CONF_WEB_SEARCH = "web_search"
 CONF_WEB_SEARCH_USER_LOCATION = "user_location"
 CONF_WEB_SEARCH_MAX_USES = "web_search_max_uses"
@@ -23,14 +22,11 @@ CONF_WEB_SEARCH_REGION = "region"
 CONF_WEB_SEARCH_COUNTRY = "country"
 CONF_WEB_SEARCH_TIMEZONE = "timezone"
 
-DATA_REPAIR_DEFER_RELOAD = "repair_defer_reload"
-
 DEFAULT = {
-    CONF_CHAT_MODEL: "claude-haiku-4-5",
+    CONF_CHAT_MODEL: "claude-3-5-haiku-latest",
     CONF_MAX_TOKENS: 3000,
     CONF_TEMPERATURE: 1.0,
     CONF_THINKING_BUDGET: 0,
-    CONF_THINKING_EFFORT: "low",
     CONF_WEB_SEARCH: False,
     CONF_WEB_SEARCH_USER_LOCATION: False,
     CONF_WEB_SEARCH_MAX_USES: 5,
@@ -44,28 +40,9 @@ NON_THINKING_MODELS = [
     "claude-3-haiku",
 ]
 
-NON_ADAPTIVE_THINKING_MODELS = [
-    "claude-opus-4-5",
-    "claude-sonnet-4-5",
-    "claude-haiku-4-5",
-    "claude-opus-4-1",
-    "claude-opus-4-0",
-    "claude-opus-4-20250514",
-    "claude-sonnet-4-0",
-    "claude-sonnet-4-20250514",
-    "claude-3",
-]
-
 WEB_SEARCH_UNSUPPORTED_MODELS = [
     "claude-3-haiku",
     "claude-3-opus",
     "claude-3-5-sonnet-20240620",
     "claude-3-5-sonnet-20241022",
 ]
-
-DEPRECATED_MODELS = [
-    "claude-3-5-haiku",
-    "claude-3-7-sonnet",
-    "claude-3-5-sonnet",
-    "claude-3-opus",
-]

homeassistant/components/anthropic/entity.py

@@ -23,7 +23,6 @@ from anthropic.types import (
     MessageDeltaUsage,
     MessageParam,
     MessageStreamEvent,
-    OutputConfigParam,
     RawContentBlockDeltaEvent,
     RawContentBlockStartEvent,
     RawContentBlockStopEvent,
@@ -42,7 +41,6 @@ from anthropic.types import (
     TextDelta,
     ThinkingBlock,
     ThinkingBlockParam,
-    ThinkingConfigAdaptiveParam,
     ThinkingConfigDisabledParam,
     ThinkingConfigEnabledParam,
     ThinkingDelta,
@@ -80,7 +78,6 @@ from .const import (
     CONF_MAX_TOKENS,
     CONF_TEMPERATURE,
     CONF_THINKING_BUDGET,
-    CONF_THINKING_EFFORT,
     CONF_WEB_SEARCH,
     CONF_WEB_SEARCH_CITY,
     CONF_WEB_SEARCH_COUNTRY,
@@ -92,7 +89,6 @@ from .const import (
     DOMAIN,
     LOGGER,
     MIN_THINKING_BUDGET,
-    NON_ADAPTIVE_THINKING_MODELS,
     NON_THINKING_MODELS,
 )
 
@@ -626,34 +622,21 @@ class AnthropicBaseLLMEntity(Entity):
             stream=True,
         )
 
-        if not model.startswith(tuple(NON_ADAPTIVE_THINKING_MODELS)):
-            thinking_effort = options.get(
-                CONF_THINKING_EFFORT, DEFAULT[CONF_THINKING_EFFORT]
+        thinking_budget = options.get(
+            CONF_THINKING_BUDGET, DEFAULT[CONF_THINKING_BUDGET]
+        )
+        if (
+            not model.startswith(tuple(NON_THINKING_MODELS))
+            and thinking_budget >= MIN_THINKING_BUDGET
+        ):
+            model_args["thinking"] = ThinkingConfigEnabledParam(
+                type="enabled", budget_tokens=thinking_budget
             )
-            if thinking_effort != "none":
-                model_args["thinking"] = ThinkingConfigAdaptiveParam(type="adaptive")
-                model_args["output_config"] = OutputConfigParam(effort=thinking_effort)
-            else:
-                model_args["thinking"] = ThinkingConfigDisabledParam(type="disabled")
-                model_args["temperature"] = options.get(
-                    CONF_TEMPERATURE, DEFAULT[CONF_TEMPERATURE]
-                )
         else:
-            thinking_budget = options.get(
-                CONF_THINKING_BUDGET, DEFAULT[CONF_THINKING_BUDGET]
+            model_args["thinking"] = ThinkingConfigDisabledParam(type="disabled")
+            model_args["temperature"] = options.get(
+                CONF_TEMPERATURE, DEFAULT[CONF_TEMPERATURE]
             )
-            if (
-                not model.startswith(tuple(NON_THINKING_MODELS))
-                and thinking_budget >= MIN_THINKING_BUDGET
-            ):
-                model_args["thinking"] = ThinkingConfigEnabledParam(
-                    type="enabled", budget_tokens=thinking_budget
-                )
-            else:
-                model_args["thinking"] = ThinkingConfigDisabledParam(type="disabled")
-                model_args["temperature"] = options.get(
-                    CONF_TEMPERATURE, DEFAULT[CONF_TEMPERATURE]
-                )
 
         tools: list[ToolUnionParam] = []
         if chat_log.llm_api:

homeassistant/components/anthropic/manifest.json

@@ -8,5 +8,5 @@
   "documentation": "https://www.home-assistant.io/integrations/anthropic",
   "integration_type": "service",
   "iot_class": "cloud_polling",
-  "requirements": ["anthropic==0.78.0"]
+  "requirements": ["anthropic==0.75.0"]
 }

homeassistant/components/anthropic/repairs.py

@@ -1,275 +0,0 @@
-"""Issue repair flow for Anthropic."""
-
-from __future__ import annotations
-
-from collections.abc import Iterator
-from typing import cast
-
-import voluptuous as vol
-
-from homeassistant import data_entry_flow
-from homeassistant.components.repairs import RepairsFlow
-from homeassistant.config_entries import ConfigEntry, ConfigEntryState, ConfigSubentry
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.selector import SelectSelector, SelectSelectorConfig
-
-from .config_flow import get_model_list
-from .const import (
-    CONF_CHAT_MODEL,
-    DATA_REPAIR_DEFER_RELOAD,
-    DEFAULT,
-    DEPRECATED_MODELS,
-    DOMAIN,
-)
-
-
-class ModelDeprecatedRepairFlow(RepairsFlow):
-    """Handler for an issue fixing flow."""
-
-    _subentry_iter: Iterator[tuple[str, str]] | None
-    _current_entry_id: str | None
-    _current_subentry_id: str | None
-    _reload_pending: set[str]
-    _pending_updates: dict[str, dict[str, str]]
-
-    def __init__(self) -> None:
-        """Initialize the flow."""
-        super().__init__()
-        self._subentry_iter = None
-        self._current_entry_id = None
-        self._current_subentry_id = None
-        self._reload_pending = set()
-        self._pending_updates = {}
-
-    async def async_step_init(
-        self, user_input: dict[str, str] | None = None
-    ) -> data_entry_flow.FlowResult:
-        """Handle the first step of a fix flow."""
-        previous_entry_id: str | None = None
-        if user_input is not None:
-            previous_entry_id = self._async_update_current_subentry(user_input)
-            self._clear_current_target()
-
-        target = await self._async_next_target()
-        next_entry_id = target[0].entry_id if target else None
-        if previous_entry_id and previous_entry_id != next_entry_id:
-            await self._async_apply_pending_updates(previous_entry_id)
-        if target is None:
-            await self._async_apply_all_pending_updates()
-            return self.async_create_entry(data={})
-
-        entry, subentry, model = target
-        client = entry.runtime_data
-        model_list = [
-            model_option
-            for model_option in await get_model_list(client)
-            if not model_option["value"].startswith(tuple(DEPRECATED_MODELS))
-        ]
-
-        if "opus" in model:
-            suggested_model = "claude-opus-4-5"
-        elif "haiku" in model:
-            suggested_model = "claude-haiku-4-5"
-        elif "sonnet" in model:
-            suggested_model = "claude-sonnet-4-5"
-        else:
-            suggested_model = cast(str, DEFAULT[CONF_CHAT_MODEL])
-
-        schema = vol.Schema(
-            {
-                vol.Required(
-                    CONF_CHAT_MODEL,
-                    default=suggested_model,
-                ): SelectSelector(
-                    SelectSelectorConfig(options=model_list, custom_value=True)
-                ),
-            }
-        )
-
-        return self.async_show_form(
-            step_id="init",
-            data_schema=schema,
-            description_placeholders={
-                "entry_name": entry.title,
-                "model": model,
-                "subentry_name": subentry.title,
-                "subentry_type": self._format_subentry_type(subentry.subentry_type),
-            },
-        )
-
-    def _iter_deprecated_subentries(self) -> Iterator[tuple[str, str]]:
-        """Yield entry/subentry pairs that use deprecated models."""
-        for entry in self.hass.config_entries.async_entries(DOMAIN):
-            if entry.state is not ConfigEntryState.LOADED:
-                continue
-            for subentry in entry.subentries.values():
-                model = subentry.data.get(CONF_CHAT_MODEL)
-                if model and model.startswith(tuple(DEPRECATED_MODELS)):
-                    yield entry.entry_id, subentry.subentry_id
-
-    async def _async_next_target(
-        self,
-    ) -> tuple[ConfigEntry, ConfigSubentry, str] | None:
-        """Return the next deprecated subentry target."""
-        if self._subentry_iter is None:
-            self._subentry_iter = self._iter_deprecated_subentries()
-
-        while True:
-            try:
-                entry_id, subentry_id = next(self._subentry_iter)
-            except StopIteration:
-                return None
-
-            entry = self.hass.config_entries.async_get_entry(entry_id)
-            if entry is None:
-                continue
-
-            subentry = entry.subentries.get(subentry_id)
-            if subentry is None:
-                continue
-
-            model = self._pending_model(entry_id, subentry_id)
-            if model is None:
-                model = subentry.data.get(CONF_CHAT_MODEL)
-            if not model or not model.startswith(tuple(DEPRECATED_MODELS)):
-                continue
-
-            self._current_entry_id = entry_id
-            self._current_subentry_id = subentry_id
-            return entry, subentry, model
-
-    def _async_update_current_subentry(self, user_input: dict[str, str]) -> str | None:
-        """Update the currently selected subentry."""
-        if not self._current_entry_id or not self._current_subentry_id:
-            return None
-
-        entry = self.hass.config_entries.async_get_entry(self._current_entry_id)
-        if entry is None:
-            return None
-
-        subentry = entry.subentries.get(self._current_subentry_id)
-        if subentry is None:
-            return None
-
-        updated_data = {
-            **subentry.data,
-            CONF_CHAT_MODEL: user_input[CONF_CHAT_MODEL],
-        }
-        if updated_data == subentry.data:
-            return entry.entry_id
-        self._queue_pending_update(
-            entry.entry_id,
-            subentry.subentry_id,
-            updated_data[CONF_CHAT_MODEL],
-        )
-        return entry.entry_id
-
-    def _clear_current_target(self) -> None:
-        """Clear current target tracking."""
-        self._current_entry_id = None
-        self._current_subentry_id = None
-
-    def _format_subentry_type(self, subentry_type: str) -> str:
-        """Return a user-friendly subentry type label."""
-        if subentry_type == "conversation":
-            return "Conversation agent"
-        if subentry_type in ("ai_task", "ai_task_data"):
-            return "AI task"
-        return subentry_type
-
-    def _queue_pending_update(
-        self, entry_id: str, subentry_id: str, model: str
-    ) -> None:
-        """Store a pending model update for a subentry."""
-        self._pending_updates.setdefault(entry_id, {})[subentry_id] = model
-
-    def _pending_model(self, entry_id: str, subentry_id: str) -> str | None:
-        """Return a pending model update if one exists."""
-        return self._pending_updates.get(entry_id, {}).get(subentry_id)
-
-    def _mark_entry_for_reload(self, entry_id: str) -> None:
-        """Prevent reload until repairs are complete for the entry."""
-        self._reload_pending.add(entry_id)
-        defer_reload_entries: set[str] = self.hass.data.setdefault(
-            DOMAIN, {}
-        ).setdefault(DATA_REPAIR_DEFER_RELOAD, set())
-        defer_reload_entries.add(entry_id)
-
-    async def _async_reload_entry(self, entry_id: str) -> None:
-        """Reload an entry once all repairs are completed."""
-        if entry_id not in self._reload_pending:
-            return
-
-        entry = self.hass.config_entries.async_get_entry(entry_id)
-        if entry is not None and entry.state is not ConfigEntryState.LOADED:
-            self._clear_defer_reload(entry_id)
-            self._reload_pending.discard(entry_id)
-            return
-
-        if entry is not None:
-            await self.hass.config_entries.async_reload(entry_id)
-
-        self._clear_defer_reload(entry_id)
-        self._reload_pending.discard(entry_id)
-
-    def _clear_defer_reload(self, entry_id: str) -> None:
-        """Remove entry from the deferred reload set."""
-        defer_reload_entries: set[str] = self.hass.data.setdefault(
-            DOMAIN, {}
-        ).setdefault(DATA_REPAIR_DEFER_RELOAD, set())
-        defer_reload_entries.discard(entry_id)
-
-    async def _async_apply_pending_updates(self, entry_id: str) -> None:
-        """Apply pending subentry updates for a single entry."""
-        updates = self._pending_updates.pop(entry_id, None)
-        if not updates:
-            return
-
-        entry = self.hass.config_entries.async_get_entry(entry_id)
-        if entry is None or entry.state is not ConfigEntryState.LOADED:
-            return
-
-        changed = False
-        for subentry_id, model in updates.items():
-            subentry = entry.subentries.get(subentry_id)
-            if subentry is None:
-                continue
-
-            updated_data = {
-                **subentry.data,
-                CONF_CHAT_MODEL: model,
-            }
-            if updated_data == subentry.data:
-                continue
-
-            if not changed:
-                self._mark_entry_for_reload(entry_id)
-                changed = True
-
-            self.hass.config_entries.async_update_subentry(
-                entry,
-                subentry,
-                data=updated_data,
-            )
-
-        if not changed:
-            return
-
-        await self._async_reload_entry(entry_id)
-
-    async def _async_apply_all_pending_updates(self) -> None:
-        """Apply all pending updates across entries."""
-        for entry_id in list(self._pending_updates):
-            await self._async_apply_pending_updates(entry_id)
-
-
-async def async_create_fix_flow(
-    hass: HomeAssistant,
-    issue_id: str,
-    data: dict[str, str | int | float | None] | None,
-) -> RepairsFlow:
-    """Create flow."""
-    if issue_id == "model_deprecated":
-        return ModelDeprecatedRepairFlow()
-    raise HomeAssistantError("Unknown issue ID")

homeassistant/components/anthropic/strings.json

@@ -47,14 +47,12 @@
         "model": {
           "data": {
             "thinking_budget": "[%key:component::anthropic::config_subentries::conversation::step::model::data::thinking_budget%]",
-            "thinking_effort": "[%key:component::anthropic::config_subentries::conversation::step::model::data::thinking_effort%]",
             "user_location": "[%key:component::anthropic::config_subentries::conversation::step::model::data::user_location%]",
             "web_search": "[%key:component::anthropic::config_subentries::conversation::step::model::data::web_search%]",
             "web_search_max_uses": "[%key:component::anthropic::config_subentries::conversation::step::model::data::web_search_max_uses%]"
           },
           "data_description": {
             "thinking_budget": "[%key:component::anthropic::config_subentries::conversation::step::model::data_description::thinking_budget%]",
-            "thinking_effort": "[%key:component::anthropic::config_subentries::conversation::step::model::data_description::thinking_effort%]",
             "user_location": "[%key:component::anthropic::config_subentries::conversation::step::model::data_description::user_location%]",
             "web_search": "[%key:component::anthropic::config_subentries::conversation::step::model::data_description::web_search%]",
             "web_search_max_uses": "[%key:component::anthropic::config_subentries::conversation::step::model::data_description::web_search_max_uses%]"
@@ -97,14 +95,12 @@
         "model": {
           "data": {
             "thinking_budget": "Thinking budget",
-            "thinking_effort": "Thinking effort",
             "user_location": "Include home location",
             "web_search": "Enable web search",
             "web_search_max_uses": "Maximum web searches"
           },
           "data_description": {
             "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.",
-            "thinking_effort": "Control how many tokens Claude uses when responding, trading off between response thoroughness and token efficiency",
             "user_location": "Localize search results based on home location",
             "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"
@@ -113,32 +109,5 @@
         }
       }
     }
-  },
-  "issues": {
-    "model_deprecated": {
-      "fix_flow": {
-        "step": {
-          "init": {
-            "data": {
-              "chat_model": "[%key:common::generic::model%]"
-            },
-            "description": "You are updating {subentry_name} ({subentry_type}) in {entry_name}. The current model {model} is deprecated. Select a supported model to continue.",
-            "title": "Update model"
-          }
-        }
-      },
-      "title": "Model deprecated"
-    }
-  },
-  "selector": {
-    "thinking_effort": {
-      "options": {
-        "high": "[%key:common::state::high%]",
-        "low": "[%key:common::state::low%]",
-        "max": "Max",
-        "medium": "[%key:common::state::medium%]",
-        "none": "None"
-      }
-    }
   }
 }

homeassistant/components/aosmith/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/aosmith",
   "integration_type": "hub",
   "iot_class": "cloud_polling",
-  "requirements": ["py-aosmith==1.0.16"]
+  "requirements": ["py-aosmith==1.0.15"]
 }

homeassistant/components/apcupsd/config_flow.py

@@ -50,7 +50,7 @@ class ConfigFlowHandler(ConfigFlow, domain=DOMAIN):
         try:
             async with asyncio.timeout(CONNECTION_TIMEOUT):
                 data = APCUPSdData(await aioapcaccess.request_status(host, port))
-        except OSError, asyncio.IncompleteReadError, TimeoutError:
+        except (OSError, asyncio.IncompleteReadError, TimeoutError):
             errors = {"base": "cannot_connect"}
             return self.async_show_form(
                 step_id="user", data_schema=_SCHEMA, errors=errors
@@ -77,7 +77,7 @@ class ConfigFlowHandler(ConfigFlow, domain=DOMAIN):
         try:
             async with asyncio.timeout(CONNECTION_TIMEOUT):
                 data = APCUPSdData(await aioapcaccess.request_status(host, port))
-        except OSError, asyncio.IncompleteReadError, TimeoutError:
+        except (OSError, asyncio.IncompleteReadError, TimeoutError):
             errors = {"base": "cannot_connect"}
             return self.async_show_form(
                 step_id="reconfigure", data_schema=_SCHEMA, errors=errors

homeassistant/components/apcupsd/sensor.py

@@ -547,7 +547,7 @@ class APCUPSdSensor(APCUPSdEntity, SensorEntity):
 
             try:
                 self._attr_native_value = dateutil.parser.parse(data)
-            except dateutil.parser.ParserError, OverflowError:
+            except (dateutil.parser.ParserError, OverflowError):
                 # If parsing fails we should mark it as unknown, with a log for further debugging.
                 _LOGGER.warning('Failed to parse date for %s: "%s"', key, data)
                 self._attr_native_value = None

homeassistant/components/apple_tv/binary_sensor.py

@@ -2,16 +2,15 @@
 
 from __future__ import annotations
 
-from pyatv.const import FeatureName, FeatureState, KeyboardFocusState
+from pyatv.const import KeyboardFocusState
 from pyatv.interface import AppleTV, KeyboardListener
 
 from homeassistant.components.binary_sensor import BinarySensorEntity
 from homeassistant.const import CONF_NAME
-from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback
-from homeassistant.helpers.dispatcher import async_dispatcher_connect
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from . import SIGNAL_CONNECTED, AppleTvConfigEntry
+from . import AppleTvConfigEntry
 from .entity import AppleTVEntity
 
 
@@ -22,22 +21,10 @@ async def async_setup_entry(
 ) -> None:
     """Load Apple TV binary sensor based on a config entry."""
     # apple_tv config entries always have a unique id
+    assert config_entry.unique_id is not None
+    name: str = config_entry.data[CONF_NAME]
     manager = config_entry.runtime_data
-    cb: CALLBACK_TYPE
-
-    def setup_entities(atv: AppleTV) -> None:
-        if atv.features.in_state(FeatureState.Available, FeatureName.TextFocusState):
-            assert config_entry.unique_id is not None
-            name: str = config_entry.data[CONF_NAME]
-            async_add_entities(
-                [AppleTVKeyboardFocused(name, config_entry.unique_id, manager)]
-            )
-            cb()
-
-    cb = async_dispatcher_connect(
-        hass, f"{SIGNAL_CONNECTED}_{config_entry.unique_id}", setup_entities
-    )
-    config_entry.async_on_unload(cb)
+    async_add_entities([AppleTVKeyboardFocused(name, config_entry.unique_id, manager)])
 
 
 class AppleTVKeyboardFocused(AppleTVEntity, BinarySensorEntity, KeyboardListener):

homeassistant/components/application_credentials/__init__.py

@@ -181,9 +181,9 @@ async def async_import_client_credential(
         CONF_DOMAIN: domain,
         CONF_CLIENT_ID: credential.client_id,
         CONF_CLIENT_SECRET: credential.client_secret,
-        CONF_AUTH_DOMAIN: auth_domain or domain,
+        CONF_AUTH_DOMAIN: auth_domain if auth_domain else domain,
     }
-    item[CONF_NAME] = credential.name or DEFAULT_IMPORT_NAME
+    item[CONF_NAME] = credential.name if credential.name else DEFAULT_IMPORT_NAME
     await hass.data[DATA_COMPONENT].async_import_item(item)
 
 

homeassistant/components/aprilaire/coordinator.py

@@ -168,7 +168,7 @@ class AprilaireCoordinator(BaseDataUpdateCoordinatorProtocol):
 
         name = data.get(Attribute.NAME) if data else None
 
-        return name or "Aprilaire"
+        return name if name else "Aprilaire"
 
     def get_hw_version(self, data: dict[str, Any]) -> str:
         """Get the hardware version."""

homeassistant/components/apsystems/config_flow.py

@@ -41,7 +41,7 @@ class APsystemsLocalAPIFlow(ConfigFlow, domain=DOMAIN):
             )
             try:
                 device_info = await api.get_device_info()
-            except TimeoutError, ClientConnectionError:
+            except (TimeoutError, ClientConnectionError):
                 errors["base"] = "cannot_connect"
             else:
                 await self.async_set_unique_id(device_info.deviceId)

homeassistant/components/apsystems/coordinator.py

@@ -64,7 +64,7 @@ class ApSystemsDataCoordinator(DataUpdateCoordinator[ApSystemsSensorData]):
     async def _async_setup(self) -> None:
         try:
             device_info = await self.api.get_device_info()
-        except ConnectionError, TimeoutError:
+        except (ConnectionError, TimeoutError):
             raise UpdateFailed from None
         self.api.max_power = device_info.maxPower
         self.api.min_power = device_info.minPower

homeassistant/components/apsystems/number.py

@@ -49,7 +49,7 @@ class ApSystemsMaxOutputNumber(ApSystemsEntity, NumberEntity):
         """Set the state with the value fetched from the inverter."""
         try:
             status = await self._api.get_max_power()
-        except TimeoutError, ClientConnectorError:
+        except (TimeoutError, ClientConnectorError):
             self._attr_available = False
         else:
             self._attr_available = True

homeassistant/components/apsystems/switch.py

@@ -43,7 +43,7 @@ class ApSystemsInverterSwitch(ApSystemsEntity, SwitchEntity):
         """Update switch status and availability."""
         try:
             status = await self._api.get_device_power_status()
-        except TimeoutError, ClientConnectionError, InverterReturnedError:
+        except (TimeoutError, ClientConnectionError, InverterReturnedError):
             self._attr_available = False
         else:
             self._attr_available = True

homeassistant/components/aquacell/config_flow.py

@@ -56,7 +56,7 @@ class AquaCellConfigFlow(ConfigFlow, domain=DOMAIN):
                 refresh_token = await api.authenticate(
                     user_input[CONF_EMAIL], user_input[CONF_PASSWORD]
                 )
-            except ApiException, TimeoutError:
+            except (ApiException, TimeoutError):
                 errors["base"] = "cannot_connect"
             except AuthenticationFailed:
                 errors["base"] = "invalid_auth"

homeassistant/components/aquostv/media_player.py

@@ -94,7 +94,7 @@ def _retry[_SharpAquosTVDeviceT: SharpAquosTVDevice, **_P](
             try:
                 func(obj, *args, **kwargs)
                 break
-            except OSError, TypeError, ValueError:
+            except (OSError, TypeError, ValueError):
                 update_retries -= 1
                 if update_retries == 0:
                     obj.set_state(MediaPlayerState.OFF)

homeassistant/components/arwn/sensor.py

@@ -201,5 +201,5 @@ class ArwnSensor(SensorEntity):
         ev: dict[str, Any] = {}
         ev.update(event)
         self._attr_extra_state_attributes = ev
-        self._attr_native_value = ev.get(self._state_key)
+        self._attr_native_value = ev.get(self._state_key, None)
         self.async_write_ha_state()

homeassistant/components/assist_pipeline/pipeline.py

@@ -969,7 +969,7 @@ class PipelineRun:
                 metadata,
                 self._speech_to_text_stream(audio_stream=stream, stt_vad=stt_vad),
             )
-        except asyncio.CancelledError, TimeoutError:
+        except (asyncio.CancelledError, TimeoutError):
             raise  # expected
         except hass_nabucasa.auth.Unauthenticated as src_error:
             raise SpeechToTextError(

homeassistant/components/asuswrt/config_flow.py

@@ -189,7 +189,7 @@ class AsusWrtFlowHandler(ConfigFlow, domain=DOMAIN):
         try:
             await api.async_connect()
 
-        except AsusRouterError, OSError:
+        except (AsusRouterError, OSError):
             _LOGGER.error(
                 "Error connecting to the AsusWrt router at %s using protocol %s",
                 host,

homeassistant/components/atag/config_flow.py

@@ -51,5 +51,5 @@ class AtagConfigFlow(ConfigFlow, domain=DOMAIN):
         return self.async_show_form(
             step_id="user",
             data_schema=vol.Schema(DATA_SCHEMA),
-            errors=errors or {},
+            errors=errors if errors else {},
         )

homeassistant/components/automation/config.py

@@ -304,7 +304,7 @@ async def _try_async_validate_config_item(
     """Validate config item."""
     try:
         return await _async_validate_config_item(hass, config, False, True)
-    except vol.Invalid, HomeAssistantError:
+    except (vol.Invalid, HomeAssistantError):
         return None
 
 

homeassistant/components/axis/config_flow.py

@@ -52,7 +52,7 @@ from .const import (
 from .errors import AuthenticationRequired, CannotConnect
 from .hub import AxisHub, get_axis_api
 
-AXIS_OUI = {"00:40:8c", "ac:cc:8e", "b8:a4:4f", "e8:27:25"}
+AXIS_OUI = {"00:40:8c", "ac:cc:8e", "b8:a4:4f"}
 DEFAULT_PORT = 443
 DEFAULT_PROTOCOL = "https"
 PROTOCOL_CHOICES = ["https", "http"]

homeassistant/components/backblaze_b2/diagnostics.py

@@ -44,7 +44,7 @@ async def async_get_config_entry_diagnostics(
                 account_data["allowed"], TO_REDACT_ACCOUNT_DATA_ALLOWED
             )
 
-    except AttributeError, TypeError, ValueError, KeyError:
+    except (AttributeError, TypeError, ValueError, KeyError):
         bucket_info = {"name": "unknown", "id": "unknown"}
         account_data = {"error": "Failed to retrieve detailed account information"}
 

homeassistant/components/backup/const.py

@@ -26,7 +26,6 @@ EXCLUDE_FROM_BACKUP = [
     "tmp_backups/*.tar",
     "OZW_Log.txt",
     "tts/*",
-    ".cache/*",
 ]
 
 EXCLUDE_DATABASE_FROM_BACKUP = [

homeassistant/components/baidu/tts.py

@@ -1,7 +1,6 @@
 """Support for Baidu speech service."""
 
 import logging
-from typing import Any
 
 from aip import AipSpeech
 import voluptuous as vol
@@ -10,7 +9,6 @@ from homeassistant.components.tts import (
     CONF_LANG,
     PLATFORM_SCHEMA as TTS_PLATFORM_SCHEMA,
     Provider,
-    TtsAudioType,
 )
 from homeassistant.const import CONF_API_KEY
 from homeassistant.helpers import config_validation as cv
@@ -87,17 +85,17 @@ class BaiduTTSProvider(Provider):
         }
 
     @property
-    def default_language(self) -> str:
+    def default_language(self):
         """Return the default language."""
         return self._lang
 
     @property
-    def supported_languages(self) -> list[str]:
+    def supported_languages(self):
         """Return a list of supported languages."""
         return SUPPORTED_LANGUAGES
 
     @property
-    def default_options(self) -> dict[str, Any]:
+    def default_options(self):
         """Return a dict including default options."""
         return {
             CONF_PERSON: self._speech_conf_data[_OPTIONS[CONF_PERSON]],
@@ -107,16 +105,11 @@ class BaiduTTSProvider(Provider):
         }
 
     @property
-    def supported_options(self) -> list[str]:
+    def supported_options(self):
         """Return a list of supported options."""
         return SUPPORTED_OPTIONS
 
-    def get_tts_audio(
-        self,
-        message: str,
-        language: str,
-        options: dict[str, Any],
-    ) -> TtsAudioType:
+    def get_tts_audio(self, message, language, options):
         """Load TTS from BaiduTTS."""
 
         aip_speech = AipSpeech(

homeassistant/components/bang_olufsen/config_flow.py

@@ -145,7 +145,7 @@ class BeoConfigFlowHandler(ConfigFlow, domain=DOMAIN):
         async with self._client:
             try:
                 await self._client.get_beolink_self(_request_timeout=3)
-            except ClientConnectorError, TimeoutError:
+            except (ClientConnectorError, TimeoutError):
                 return self.async_abort(reason="invalid_address")
 
         self._model = discovery_info.hostname[:-16].replace("-", " ")

homeassistant/components/blue_current/switch.py

@@ -80,16 +80,18 @@ SWITCHES = (
         key=PLUG_AND_CHARGE,
         translation_key=PLUG_AND_CHARGE,
         function=set_plug_and_charge,
-        turn_on_off_fn=lambda evse_id, connector: update_on_value_and_activity(
-            PLUG_AND_CHARGE, evse_id, connector
+        turn_on_off_fn=lambda evse_id, connector: (
+            update_on_value_and_activity(PLUG_AND_CHARGE, evse_id, connector)
         ),
     ),
     BlueCurrentSwitchEntityDescription(
         key=LINKED_CHARGE_CARDS,
         translation_key=LINKED_CHARGE_CARDS,
         function=set_linked_charge_cards,
-        turn_on_off_fn=lambda evse_id, connector: update_on_value_and_activity(
-            PUBLIC_CHARGING, evse_id, connector, reverse_is_on=True
+        turn_on_off_fn=lambda evse_id, connector: (
+            update_on_value_and_activity(
+                PUBLIC_CHARGING, evse_id, connector, reverse_is_on=True
+            )
         ),
     ),
     BlueCurrentSwitchEntityDescription(

homeassistant/components/bmw_connected_drive/binary_sensor.py

@@ -148,10 +148,8 @@ SENSOR_TYPES: tuple[BMWBinarySensorEntityDescription, ...] = (
         device_class=BinarySensorDeviceClass.LOCK,
         # device class lock: On means unlocked, Off means locked
         # Possible values: LOCKED, SECURED, SELECTIVE_LOCKED, UNLOCKED
-        value_fn=lambda v: (
-            v.doors_and_windows.door_lock_state
-            not in {LockState.LOCKED, LockState.SECURED}
-        ),
+        value_fn=lambda v: v.doors_and_windows.door_lock_state
+        not in {LockState.LOCKED, LockState.SECURED},
         attr_fn=lambda v, u: {
             "door_lock_state": v.doors_and_windows.door_lock_state.value
         },
@@ -191,11 +189,9 @@ SENSOR_TYPES: tuple[BMWBinarySensorEntityDescription, ...] = (
     BMWBinarySensorEntityDescription(
         key="is_pre_entry_climatization_enabled",
         translation_key="is_pre_entry_climatization_enabled",
-        value_fn=lambda v: (
-            v.charging_profile.is_pre_entry_climatization_enabled
-            if v.charging_profile
-            else False
-        ),
+        value_fn=lambda v: v.charging_profile.is_pre_entry_climatization_enabled
+        if v.charging_profile
+        else False,
         is_available=lambda v: v.has_electric_drivetrain,
     ),
 )

homeassistant/components/bmw_connected_drive/button.py

@@ -40,9 +40,7 @@ BUTTON_TYPES: tuple[BMWButtonEntityDescription, ...] = (
     BMWButtonEntityDescription(
         key="light_flash",
         translation_key="light_flash",
-        remote_function=lambda vehicle: (
-            vehicle.remote_services.trigger_remote_light_flash()
-        ),
+        remote_function=lambda vehicle: vehicle.remote_services.trigger_remote_light_flash(),
     ),
     BMWButtonEntityDescription(
         key="sound_horn",
@@ -52,24 +50,18 @@ BUTTON_TYPES: tuple[BMWButtonEntityDescription, ...] = (
     BMWButtonEntityDescription(
         key="activate_air_conditioning",
         translation_key="activate_air_conditioning",
-        remote_function=lambda vehicle: (
-            vehicle.remote_services.trigger_remote_air_conditioning()
-        ),
+        remote_function=lambda vehicle: vehicle.remote_services.trigger_remote_air_conditioning(),
     ),
     BMWButtonEntityDescription(
         key="deactivate_air_conditioning",
         translation_key="deactivate_air_conditioning",
-        remote_function=lambda vehicle: (
-            vehicle.remote_services.trigger_remote_air_conditioning_stop()
-        ),
+        remote_function=lambda vehicle: vehicle.remote_services.trigger_remote_air_conditioning_stop(),
         is_available=lambda vehicle: vehicle.is_remote_climate_stop_enabled,
     ),
     BMWButtonEntityDescription(
         key="find_vehicle",
         translation_key="find_vehicle",
-        remote_function=lambda vehicle: (
-            vehicle.remote_services.trigger_remote_vehicle_finder()
-        ),
+        remote_function=lambda vehicle: vehicle.remote_services.trigger_remote_vehicle_finder(),
     ),
 )
 

homeassistant/components/bmw_connected_drive/switch.py

@@ -50,9 +50,7 @@ NUMBER_TYPES: list[BMWSwitchEntityDescription] = [
         is_available=lambda v: v.is_remote_climate_stop_enabled,
         value_fn=lambda v: v.climate.is_climate_on,
         remote_service_on=lambda v: v.remote_services.trigger_remote_air_conditioning(),
-        remote_service_off=lambda v: (
-            v.remote_services.trigger_remote_air_conditioning_stop()
-        ),
+        remote_service_off=lambda v: v.remote_services.trigger_remote_air_conditioning_stop(),
     ),
     BMWSwitchEntityDescription(
         key="charging",

homeassistant/components/bond/__init__.py

@@ -16,17 +16,14 @@ from homeassistant.const import (
 )
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import ConfigEntryNotReady
-from homeassistant.helpers import config_validation as cv, device_registry as dr
+from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.entity import SLOW_UPDATE_WARNING
-from homeassistant.helpers.typing import ConfigType
 
 from .const import BRIDGE_MAKE, DOMAIN
 from .models import BondData
-from .services import async_setup_services
 from .utils import BondHub
 
-CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 PLATFORMS = [
     Platform.BUTTON,
     Platform.COVER,
@@ -41,12 +38,6 @@ _LOGGER = logging.getLogger(__name__)
 type BondConfigEntry = ConfigEntry[BondData]
 
 
-async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up the component."""
-    async_setup_services(hass)
-    return True
-
-
 async def async_setup_entry(hass: HomeAssistant, entry: BondConfigEntry) -> bool:
     """Set up Bond from a config entry."""
     host = entry.data[CONF_HOST]

homeassistant/components/bond/const.py

@@ -5,3 +5,10 @@ BRIDGE_MAKE = "Olibra"
 DOMAIN = "bond"
 
 CONF_BOND_ID: str = "bond_id"
+
+
+SERVICE_SET_FAN_SPEED_TRACKED_STATE = "set_fan_speed_tracked_state"
+SERVICE_SET_POWER_TRACKED_STATE = "set_switch_power_tracked_state"
+SERVICE_SET_LIGHT_POWER_TRACKED_STATE = "set_light_power_tracked_state"
+SERVICE_SET_LIGHT_BRIGHTNESS_TRACKED_STATE = "set_light_brightness_tracked_state"
+ATTR_POWER_STATE = "power_state"

homeassistant/components/bond/fan.py

@@ -8,6 +8,7 @@ from typing import Any
 
 from aiohttp.client_exceptions import ClientResponseError
 from bond_async import Action, DeviceType, Direction
+import voluptuous as vol
 
 from homeassistant.components.fan import (
     DIRECTION_FORWARD,
@@ -17,6 +18,7 @@ from homeassistant.components.fan import (
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import entity_platform
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util.percentage import (
     percentage_to_ranged_value,
@@ -25,6 +27,7 @@ from homeassistant.util.percentage import (
 from homeassistant.util.scaling import int_states_in_range
 
 from . import BondConfigEntry
+from .const import SERVICE_SET_FAN_SPEED_TRACKED_STATE
 from .entity import BondEntity
 from .models import BondData
 from .utils import BondDevice
@@ -41,6 +44,12 @@ async def async_setup_entry(
 ) -> None:
     """Set up Bond fan devices."""
     data = entry.runtime_data
+    platform = entity_platform.async_get_current_platform()
+    platform.async_register_entity_service(
+        SERVICE_SET_FAN_SPEED_TRACKED_STATE,
+        {vol.Required("speed"): vol.All(vol.Number(scale=0), vol.Range(0, 100))},
+        "async_set_speed_belief",
+    )
 
     async_add_entities(
         BondFan(data, device)

homeassistant/components/bond/light.py

@@ -7,20 +7,37 @@ from typing import Any
 
 from aiohttp.client_exceptions import ClientResponseError
 from bond_async import Action, DeviceType
+import voluptuous as vol
 
 from homeassistant.components.light import ATTR_BRIGHTNESS, ColorMode, LightEntity
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import config_validation as cv, entity_platform
 from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import BondConfigEntry
+from .const import (
+    ATTR_POWER_STATE,
+    SERVICE_SET_LIGHT_BRIGHTNESS_TRACKED_STATE,
+    SERVICE_SET_LIGHT_POWER_TRACKED_STATE,
+)
 from .entity import BondEntity
 from .models import BondData
 from .utils import BondDevice
 
 _LOGGER = logging.getLogger(__name__)
 
+SERVICE_START_INCREASING_BRIGHTNESS = "start_increasing_brightness"
+SERVICE_START_DECREASING_BRIGHTNESS = "start_decreasing_brightness"
+SERVICE_STOP = "stop"
+
+ENTITY_SERVICES = [
+    SERVICE_START_INCREASING_BRIGHTNESS,
+    SERVICE_START_DECREASING_BRIGHTNESS,
+    SERVICE_STOP,
+]
+
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -31,6 +48,14 @@ async def async_setup_entry(
     data = entry.runtime_data
     hub = data.hub
 
+    platform = entity_platform.async_get_current_platform()
+    for service in ENTITY_SERVICES:
+        platform.async_register_entity_service(
+            service,
+            None,
+            f"async_{service}",
+        )
+
     fan_lights: list[Entity] = [
         BondLight(data, device)
         for device in hub.devices
@@ -69,6 +94,22 @@ async def async_setup_entry(
         if DeviceType.is_light(device.type)
     ]
 
+    platform.async_register_entity_service(
+        SERVICE_SET_LIGHT_BRIGHTNESS_TRACKED_STATE,
+        {
+            vol.Required(ATTR_BRIGHTNESS): vol.All(
+                vol.Number(scale=0), vol.Range(0, 255)
+            )
+        },
+        "async_set_brightness_belief",
+    )
+
+    platform.async_register_entity_service(
+        SERVICE_SET_LIGHT_POWER_TRACKED_STATE,
+        {vol.Required(ATTR_POWER_STATE): vol.All(cv.boolean)},
+        "async_set_power_belief",
+    )
+
     async_add_entities(
         fan_lights + fan_up_lights + fan_down_lights + fireplaces + fp_lights + lights,
     )

homeassistant/components/bond/services.py

@@ -1,101 +0,0 @@
-"""Support for Bond services."""
-
-from __future__ import annotations
-
-import voluptuous as vol
-
-from homeassistant.components.fan import DOMAIN as FAN_DOMAIN
-from homeassistant.components.light import ATTR_BRIGHTNESS, DOMAIN as LIGHT_DOMAIN
-from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import config_validation as cv, service
-
-from .const import DOMAIN
-
-ATTR_POWER_STATE = "power_state"
-
-# Fan
-SERVICE_SET_FAN_SPEED_TRACKED_STATE = "set_fan_speed_tracked_state"
-
-# Switch
-SERVICE_SET_POWER_TRACKED_STATE = "set_switch_power_tracked_state"
-
-# Light
-SERVICE_SET_LIGHT_POWER_TRACKED_STATE = "set_light_power_tracked_state"
-SERVICE_SET_LIGHT_BRIGHTNESS_TRACKED_STATE = "set_light_brightness_tracked_state"
-SERVICE_START_INCREASING_BRIGHTNESS = "start_increasing_brightness"
-SERVICE_START_DECREASING_BRIGHTNESS = "start_decreasing_brightness"
-SERVICE_STOP = "stop"
-
-
-@callback
-def async_setup_services(hass: HomeAssistant) -> None:
-    """Home Assistant services."""
-
-    # Fan entity services
-    service.async_register_platform_entity_service(
-        hass,
-        DOMAIN,
-        SERVICE_SET_FAN_SPEED_TRACKED_STATE,
-        entity_domain=FAN_DOMAIN,
-        schema={vol.Required("speed"): vol.All(vol.Number(scale=0), vol.Range(0, 100))},
-        func="async_set_speed_belief",
-    )
-
-    # Light entity services
-    service.async_register_platform_entity_service(
-        hass,
-        DOMAIN,
-        SERVICE_START_INCREASING_BRIGHTNESS,
-        entity_domain=LIGHT_DOMAIN,
-        schema=None,
-        func="async_start_increasing_brightness",
-    )
-    service.async_register_platform_entity_service(
-        hass,
-        DOMAIN,
-        SERVICE_START_DECREASING_BRIGHTNESS,
-        entity_domain=LIGHT_DOMAIN,
-        schema=None,
-        func="async_start_decreasing_brightness",
-    )
-    service.async_register_platform_entity_service(
-        hass,
-        DOMAIN,
-        SERVICE_STOP,
-        entity_domain=LIGHT_DOMAIN,
-        schema=None,
-        func="async_stop",
-    )
-
-    service.async_register_platform_entity_service(
-        hass,
-        DOMAIN,
-        SERVICE_SET_LIGHT_BRIGHTNESS_TRACKED_STATE,
-        entity_domain=LIGHT_DOMAIN,
-        schema={
-            vol.Required(ATTR_BRIGHTNESS): vol.All(
-                vol.Number(scale=0), vol.Range(0, 255)
-            )
-        },
-        func="async_set_brightness_belief",
-    )
-
-    service.async_register_platform_entity_service(
-        hass,
-        DOMAIN,
-        SERVICE_SET_LIGHT_POWER_TRACKED_STATE,
-        entity_domain=LIGHT_DOMAIN,
-        schema={vol.Required(ATTR_POWER_STATE): vol.All(cv.boolean)},
-        func="async_set_power_belief",
-    )
-
-    # Switch entity services
-    service.async_register_platform_entity_service(
-        hass,
-        DOMAIN,
-        SERVICE_SET_POWER_TRACKED_STATE,
-        entity_domain=SWITCH_DOMAIN,
-        schema={vol.Required(ATTR_POWER_STATE): cv.boolean},
-        func="async_set_power_belief",
-    )

homeassistant/components/bond/switch.py

@@ -6,13 +6,16 @@ from typing import Any
 
 from aiohttp.client_exceptions import ClientResponseError
 from bond_async import Action, DeviceType
+import voluptuous as vol
 
 from homeassistant.components.switch import SwitchEntity
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import config_validation as cv, entity_platform
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import BondConfigEntry
+from .const import ATTR_POWER_STATE, SERVICE_SET_POWER_TRACKED_STATE
 from .entity import BondEntity
 
 
@@ -23,6 +26,12 @@ async def async_setup_entry(
 ) -> None:
     """Set up Bond generic devices."""
     data = entry.runtime_data
+    platform = entity_platform.async_get_current_platform()
+    platform.async_register_entity_service(
+        SERVICE_SET_POWER_TRACKED_STATE,
+        {vol.Required(ATTR_POWER_STATE): cv.boolean},
+        "async_set_power_belief",
+    )
 
     async_add_entities(
         BondSwitch(data, device)

homeassistant/components/braviatv/coordinator.py

@@ -200,7 +200,7 @@ class BraviaTVCoordinator(DataUpdateCoordinator[None]):
                     "device": self.config_entry.title,
                 },
             ) from err
-        except BraviaConnectionError, BraviaConnectionTimeout, BraviaTurnedOff:
+        except (BraviaConnectionError, BraviaConnectionTimeout, BraviaTurnedOff):
             self.is_on = False
             self.connected = False
             _LOGGER.debug(

homeassistant/components/bring/const.py

@@ -1,3 +1,14 @@
 """Constants for the Bring! integration."""
 
+from typing import Final
+
 DOMAIN = "bring"
+
+ATTR_SENDER: Final = "sender"
+ATTR_ITEM_NAME: Final = "item"
+ATTR_NOTIFICATION_TYPE: Final = "message"
+ATTR_REACTION: Final = "reaction"
+ATTR_ACTIVITY: Final = "uuid"
+ATTR_RECEIVER: Final = "publicUserUuid"
+SERVICE_PUSH_NOTIFICATION = "send_message"
+SERVICE_ACTIVITY_STREAM_REACTION = "send_reaction"

homeassistant/components/bring/sensor.py

@@ -63,9 +63,9 @@ SENSOR_DESCRIPTIONS: tuple[BringSensorEntityDescription, ...] = (
         key=BringSensor.LIST_LANGUAGE,
         translation_key=BringSensor.LIST_LANGUAGE,
         value_fn=(
-            lambda lst, settings: (
-                x.lower() if (x := list_language(lst.lst.listUuid, settings)) else None
-            )
+            lambda lst, settings: x.lower()
+            if (x := list_language(lst.lst.listUuid, settings))
+            else None
         ),
         entity_category=EntityCategory.DIAGNOSTIC,
         options=[x.lower() for x in BRING_SUPPORTED_LOCALES],

homeassistant/components/bring/services.py

@@ -1,5 +1,6 @@
 """Actions for Bring! integration."""
 
+import logging
 from typing import TYPE_CHECKING
 
 from bring_api import (
@@ -12,28 +13,22 @@ from bring_api import (
 import voluptuous as vol
 
 from homeassistant.components.event import ATTR_EVENT_TYPE
-from homeassistant.components.todo import DOMAIN as TODO_DOMAIN
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.const import ATTR_ENTITY_ID
-from homeassistant.core import HomeAssistant, ServiceCall, callback
+from homeassistant.core import HomeAssistant, ServiceCall
 from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
-from homeassistant.helpers import (
-    config_validation as cv,
-    entity_registry as er,
-    service,
-)
+from homeassistant.helpers import config_validation as cv, entity_registry as er
 
-from .const import DOMAIN
+from .const import (
+    ATTR_ACTIVITY,
+    ATTR_REACTION,
+    ATTR_RECEIVER,
+    DOMAIN,
+    SERVICE_ACTIVITY_STREAM_REACTION,
+)
 from .coordinator import BringConfigEntry
 
-ATTR_ACTIVITY = "uuid"
-ATTR_ITEM_NAME = "item"
-ATTR_NOTIFICATION_TYPE = "message"
-ATTR_REACTION = "reaction"
-ATTR_RECEIVER = "publicUserUuid"
-
-SERVICE_PUSH_NOTIFICATION = "send_message"
-SERVICE_ACTIVITY_STREAM_REACTION = "send_reaction"
+_LOGGER = logging.getLogger(__name__)
 
 SERVICE_ACTIVITY_STREAM_REACTION_SCHEMA = vol.Schema(
     {
@@ -59,7 +54,6 @@ def get_config_entry(hass: HomeAssistant, entry_id: str) -> BringConfigEntry:
     return entry
 
 
-@callback
 def async_setup_services(hass: HomeAssistant) -> None:
     """Set up services for Bring! integration."""
 
@@ -114,17 +108,3 @@ def async_setup_services(hass: HomeAssistant) -> None:
         async_send_activity_stream_reaction,
         SERVICE_ACTIVITY_STREAM_REACTION_SCHEMA,
     )
-
-    service.async_register_platform_entity_service(
-        hass,
-        DOMAIN,
-        SERVICE_PUSH_NOTIFICATION,
-        entity_domain=TODO_DOMAIN,
-        schema={
-            vol.Required(ATTR_NOTIFICATION_TYPE): vol.All(
-                vol.Upper, vol.Coerce(BringNotificationType)
-            ),
-            vol.Optional(ATTR_ITEM_NAME): cv.string,
-        },
-        func="async_send_message",
-    )

homeassistant/components/bring/todo.py

@@ -13,6 +13,7 @@ from bring_api import (
     BringNotificationType,
     BringRequestException,
 )
+import voluptuous as vol
 
 from homeassistant.components.todo import (
     TodoItem,
@@ -22,9 +23,15 @@ from homeassistant.components.todo import (
 )
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
+from homeassistant.helpers import config_validation as cv, entity_platform
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import DOMAIN
+from .const import (
+    ATTR_ITEM_NAME,
+    ATTR_NOTIFICATION_TYPE,
+    DOMAIN,
+    SERVICE_PUSH_NOTIFICATION,
+)
 from .coordinator import BringConfigEntry, BringData, BringDataUpdateCoordinator
 from .entity import BringBaseEntity
 
@@ -56,6 +63,19 @@ async def async_setup_entry(
     coordinator.async_add_listener(add_entities)
     add_entities()
 
+    platform = entity_platform.async_get_current_platform()
+
+    platform.async_register_entity_service(
+        SERVICE_PUSH_NOTIFICATION,
+        {
+            vol.Required(ATTR_NOTIFICATION_TYPE): vol.All(
+                vol.Upper, vol.Coerce(BringNotificationType)
+            ),
+            vol.Optional(ATTR_ITEM_NAME): cv.string,
+        },
+        "async_send_message",
+    )
+
 
 class BringTodoListEntity(BringBaseEntity, TodoListEntity):
     """A To-do List representation of the Bring! Shopping List."""

homeassistant/components/broadlink/device.py

@@ -173,7 +173,7 @@ class BroadlinkDevice[_ApiT: blk.Device = blk.Device]:
         request = partial(function, *args, **kwargs)
         try:
             return await self.hass.async_add_executor_job(request)
-        except AuthorizationError, ConnectionClosedError:
+        except (AuthorizationError, ConnectionClosedError):
             if not await self.async_auth():
                 raise
             return await self.hass.async_add_executor_job(request)

homeassistant/components/broadlink/remote.py

@@ -337,7 +337,7 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
                 await asyncio.sleep(1)
                 try:
                     code = await device.async_request(device.api.check_data)
-                except ReadError, StorageError:
+                except (ReadError, StorageError):
                     continue
                 return b64encode(code).decode("utf8")
 
@@ -413,7 +413,7 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
                 await asyncio.sleep(1)
                 try:
                     code = await device.async_request(device.api.check_data)
-                except ReadError, StorageError:
+                except (ReadError, StorageError):
                     continue
                 return b64encode(code).decode("utf8")
 

homeassistant/components/brother/config_flow.py

@@ -127,7 +127,7 @@ class BrotherConfigFlow(ConfigFlow, domain=DOMAIN):
                 model, serial = await validate_input(self.hass, user_input)
             except InvalidHost:
                 errors[CONF_HOST] = "wrong_host"
-            except ConnectionError, TimeoutError:
+            except (ConnectionError, TimeoutError):
                 errors["base"] = "cannot_connect"
             except SnmpError:
                 errors["base"] = "snmp_error"
@@ -163,7 +163,7 @@ class BrotherConfigFlow(ConfigFlow, domain=DOMAIN):
             await self.brother.async_update()
         except UnsupportedModelError:
             return self.async_abort(reason="unsupported_model")
-        except ConnectionError, SnmpError, TimeoutError:
+        except (ConnectionError, SnmpError, TimeoutError):
             return self.async_abort(reason="cannot_connect")
 
         # Check if already configured
@@ -211,7 +211,7 @@ class BrotherConfigFlow(ConfigFlow, domain=DOMAIN):
                 await validate_input(self.hass, user_input, entry.unique_id)
             except InvalidHost:
                 errors[CONF_HOST] = "wrong_host"
-            except ConnectionError, TimeoutError:
+            except (ConnectionError, TimeoutError):
                 errors["base"] = "cannot_connect"
             except SnmpError:
                 errors["base"] = "snmp_error"

homeassistant/components/buienradar/util.py

@@ -199,7 +199,7 @@ class BrData:
         """Return the temperature, or None."""
         try:
             return float(self.data.get(TEMPERATURE))
-        except ValueError, TypeError:
+        except (ValueError, TypeError):
             return None
 
     @property
@@ -207,7 +207,7 @@ class BrData:
         """Return the feeltemperature, or None."""
         try:
             return float(self.data.get(FEELTEMPERATURE))
-        except ValueError, TypeError:
+        except (ValueError, TypeError):
             return None
 
     @property
@@ -215,7 +215,7 @@ class BrData:
         """Return the pressure, or None."""
         try:
             return float(self.data.get(PRESSURE))
-        except ValueError, TypeError:
+        except (ValueError, TypeError):
             return None
 
     @property
@@ -223,7 +223,7 @@ class BrData:
         """Return the humidity, or None."""
         try:
             return int(self.data.get(HUMIDITY))
-        except ValueError, TypeError:
+        except (ValueError, TypeError):
             return None
 
     @property
@@ -231,7 +231,7 @@ class BrData:
         """Return the visibility, or None."""
         try:
             return int(self.data.get(VISIBILITY))
-        except ValueError, TypeError:
+        except (ValueError, TypeError):
             return None
 
     @property
@@ -239,7 +239,7 @@ class BrData:
         """Return the windgust, or None."""
         try:
             return float(self.data.get(WINDGUST))
-        except ValueError, TypeError:
+        except (ValueError, TypeError):
             return None
 
     @property
@@ -247,7 +247,7 @@ class BrData:
         """Return the windspeed, or None."""
         try:
             return float(self.data.get(WINDSPEED))
-        except ValueError, TypeError:
+        except (ValueError, TypeError):
             return None
 
     @property
@@ -255,7 +255,7 @@ class BrData:
         """Return the wind bearing, or None."""
         try:
             return int(self.data.get(WINDAZIMUTH))
-        except ValueError, TypeError:
+        except (ValueError, TypeError):
             return None
 
     @property

homeassistant/components/calendar/__init__.py

@@ -691,7 +691,7 @@ class CalendarEventView(http.HomeAssistantView):
         try:
             start_date = dt_util.parse_datetime(start)
             end_date = dt_util.parse_datetime(end)
-        except ValueError, AttributeError:
+        except (ValueError, AttributeError):
             return web.Response(status=HTTPStatus.BAD_REQUEST)
         if start_date is None or end_date is None:
             return web.Response(status=HTTPStatus.BAD_REQUEST)

homeassistant/components/camera/strings.json

@@ -58,14 +58,14 @@
       "name": "Enable motion detection"
     },
     "play_stream": {
-      "description": "Plays a camera stream on a supported media player.",
+      "description": "Plays the camera stream on a supported media player.",
       "fields": {
         "format": {
           "description": "Stream format supported by the media player.",
           "name": "Format"
         },
         "media_player": {
-          "description": "Media player to stream to.",
+          "description": "Media players to stream to.",
           "name": "Media player"
         }
       },

homeassistant/components/canary/config_flow.py

@@ -71,7 +71,7 @@ class CanaryConfigFlow(ConfigFlow, domain=DOMAIN):
                 await self.hass.async_add_executor_job(
                     validate_input, self.hass, user_input
                 )
-            except ConnectTimeout, HTTPError:
+            except (ConnectTimeout, HTTPError):
                 errors["base"] = "cannot_connect"
             except Exception:
                 _LOGGER.exception("Unexpected exception")

homeassistant/components/climate/__init__.py

@@ -49,7 +49,6 @@ from .const import (  # noqa: F401
     ATTR_SWING_HORIZONTAL_MODES,
     ATTR_SWING_MODE,
     ATTR_SWING_MODES,
-    ATTR_TARGET_HUMIDITY_STEP,
     ATTR_TARGET_TEMP_HIGH,
     ATTR_TARGET_TEMP_LOW,
     ATTR_TARGET_TEMP_STEP,
@@ -235,7 +234,6 @@ CACHED_PROPERTIES_WITH_ATTR_ = {
     "max_temp",
     "min_humidity",
     "max_humidity",
-    "target_humidity_step",
 }
 
 
@@ -251,7 +249,6 @@ class ClimateEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
             ATTR_MAX_TEMP,
             ATTR_MIN_HUMIDITY,
             ATTR_MAX_HUMIDITY,
-            ATTR_TARGET_HUMIDITY_STEP,
             ATTR_TARGET_TEMP_STEP,
             ATTR_PRESET_MODES,
         }
@@ -278,7 +275,6 @@ class ClimateEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
     _attr_swing_horizontal_mode: str | None
     _attr_swing_horizontal_modes: list[str] | None
     _attr_target_humidity: float | None = None
-    _attr_target_humidity_step: int | None = None
     _attr_target_temperature_high: float | None
     _attr_target_temperature_low: float | None
     _attr_target_temperature_step: float | None = None
@@ -327,9 +323,6 @@ class ClimateEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
             data[ATTR_MIN_HUMIDITY] = self.min_humidity
             data[ATTR_MAX_HUMIDITY] = self.max_humidity
 
-            if self.target_humidity_step is not None:
-                data[ATTR_TARGET_HUMIDITY_STEP] = self.target_humidity_step
-
         if ClimateEntityFeature.FAN_MODE in supported_features:
             data[ATTR_FAN_MODES] = self.fan_modes
 
@@ -735,11 +728,6 @@ class ClimateEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
         """Return the maximum humidity."""
         return self._attr_max_humidity
 
-    @cached_property
-    def target_humidity_step(self) -> int | None:
-        """Return the supported step of humidity."""
-        return self._attr_target_humidity_step
-
 
 async def async_service_humidity_set(
     entity: ClimateEntity, service_call: ServiceCall

homeassistant/components/climate/const.py

@@ -114,7 +114,6 @@ ATTR_SWING_MODES = "swing_modes"
 ATTR_SWING_MODE = "swing_mode"
 ATTR_SWING_HORIZONTAL_MODE = "swing_horizontal_mode"
 ATTR_SWING_HORIZONTAL_MODES = "swing_horizontal_modes"
-ATTR_TARGET_HUMIDITY_STEP = "target_humidity_step"
 ATTR_TARGET_TEMP_HIGH = "target_temp_high"
 ATTR_TARGET_TEMP_LOW = "target_temp_low"
 ATTR_TARGET_TEMP_STEP = "target_temp_step"

homeassistant/components/cloud/alexa_config.py

@@ -373,7 +373,7 @@ class CloudAlexaConfig(alexa_config.AbstractConfig):
             if self.should_report_state:
                 try:
                     await self.async_enable_proactive_mode()
-                except alexa_errors.NoTokenAvailable, alexa_errors.RequireRelink:
+                except (alexa_errors.NoTokenAvailable, alexa_errors.RequireRelink):
                     await self.set_authorized(False)
             else:
                 await self.async_disable_proactive_mode()

homeassistant/components/cloud/client.py

@@ -187,7 +187,7 @@ class CloudClient(Interface):
                         err,
                     )
                 async_call_later(self._hass, 30, enable_alexa_job)
-            except alexa_errors.NoTokenAvailable, alexa_errors.RequireRelink:
+            except (alexa_errors.NoTokenAvailable, alexa_errors.RequireRelink):
                 pass
 
         enable_alexa_job = HassJob(enable_alexa, cancel_on_shutdown=True)

homeassistant/components/cloud/entity.py

@@ -2,7 +2,7 @@
 
 import base64
 from collections.abc import AsyncGenerator, Callable, Iterable
-from enum import StrEnum
+from enum import Enum
 import json
 import logging
 import re
@@ -59,7 +59,7 @@ _LOGGER = logging.getLogger(__name__)
 _MAX_TOOL_ITERATIONS = 10
 
 
-class ResponseItemType(StrEnum):
+class ResponseItemType(str, Enum):
     """Response item types."""
 
     FUNCTION_CALL = "function_call"
@@ -459,17 +459,8 @@ class BaseCloudLLMEntity(Entity):
         last_content: Any = chat_log.content[-1]
         if last_content.role == "user" and last_content.attachments:
             files = await self._async_prepare_files_for_prompt(last_content.attachments)
-
-            last_message = cast(dict[str, Any], messages[-1])
-            assert (
-                last_message["type"] == "message"
-                and last_message["role"] == "user"
-                and isinstance(last_message["content"], str)
-            )
-            last_message["content"] = [
-                {"type": "input_text", "text": last_message["content"]},
-                *files,
-            ]
+            current_content = last_content.content
+            last_content = [*(current_content or []), *files]
 
         tools: list[ToolParam] = []
         tool_choice: str | None = None

homeassistant/components/cloud/http_api.py

@@ -779,7 +779,7 @@ async def websocket_update_prefs(
                 msg["id"], "alexa_timeout", "Timeout validating Alexa access token."
             )
             return
-        except alexa_errors.NoTokenAvailable, alexa_errors.RequireRelink:
+        except (alexa_errors.NoTokenAvailable, alexa_errors.RequireRelink):
             connection.send_error(
                 msg["id"],
                 "alexa_relink",

homeassistant/components/cloud/manifest.json

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

homeassistant/components/cloudflare_r2/backup.py

@@ -196,46 +196,44 @@ class R2BackupAgent(BackupAgent):
         )
         upload_id = multipart_upload["UploadId"]
         try:
-            parts: list[dict[str, Any]] = []
+            parts = []
             part_number = 1
-            buffer = bytearray()  # bytes buffer to store the data
+            buffer_size = 0  # bytes
+            buffer: list[bytes] = []
 
             stream = await open_stream()
             async for chunk in stream:
-                buffer.extend(chunk)
-
-                # upload parts of exactly MULTIPART_MIN_PART_SIZE_BYTES to ensure
-                # all non-trailing parts have the same size (required by S3/R2)
-                while len(buffer) >= MULTIPART_MIN_PART_SIZE_BYTES:
-                    part_data = bytes(buffer[:MULTIPART_MIN_PART_SIZE_BYTES])
-                    del buffer[:MULTIPART_MIN_PART_SIZE_BYTES]
+                buffer_size += len(chunk)
+                buffer.append(chunk)
 
+                # If buffer size meets minimum part size, upload it as a part
+                if buffer_size >= MULTIPART_MIN_PART_SIZE_BYTES:
                     _LOGGER.debug(
-                        "Uploading part number %d, size %d",
-                        part_number,
-                        len(part_data),
+                        "Uploading part number %d, size %d", part_number, buffer_size
                     )
                     part = await self._client.upload_part(
                         Bucket=self._bucket,
                         Key=self._with_prefix(tar_filename),
                         PartNumber=part_number,
                         UploadId=upload_id,
-                        Body=part_data,
+                        Body=b"".join(buffer),
                     )
                     parts.append({"PartNumber": part_number, "ETag": part["ETag"]})
                     part_number += 1
+                    buffer_size = 0
+                    buffer = []
 
             # Upload the final buffer as the last part (no minimum size requirement)
             if buffer:
                 _LOGGER.debug(
-                    "Uploading final part number %d, size %d", part_number, len(buffer)
+                    "Uploading final part number %d, size %d", part_number, buffer_size
                 )
                 part = await self._client.upload_part(
                     Bucket=self._bucket,
                     Key=self._with_prefix(tar_filename),
                     PartNumber=part_number,
                     UploadId=upload_id,
-                    Body=bytes(buffer),
+                    Body=b"".join(buffer),
                 )
                 parts.append({"PartNumber": part_number, "ETag": part["ETag"]})
 

homeassistant/components/comed_hourly_pricing/sensor.py

@@ -126,5 +126,5 @@ class ComedHourlyPricingSensor(SensorEntity):
 
         except (TimeoutError, aiohttp.ClientError) as err:
             _LOGGER.error("Could not get data from ComEd API: %s", err)
-        except ValueError, KeyError:
+        except (ValueError, KeyError):
             _LOGGER.warning("Could not update status for %s", self.name)

homeassistant/components/compensation/sensor.py

@@ -186,7 +186,7 @@ class CompensationSensor(SensorEntity):
                 y_value = self._poly(x_value)
             self._attr_native_value = round(y_value, self._precision)
 
-        except ValueError, TypeError:
+        except (ValueError, TypeError):
             self._attr_native_value = None
             if self._source_attribute:
                 _LOGGER.warning(

homeassistant/components/compit/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["compit"],
   "quality_scale": "bronze",
-  "requirements": ["compit-inext-api==0.8.0"]
+  "requirements": ["compit-inext-api==0.7.0"]
 }

homeassistant/components/config/config_entries.py

@@ -421,7 +421,7 @@ def config_entries_flow_subscribe(
                 config_entries.SOURCE_USER,
             )
         ]
-    except ValueError, TypeError:
+    except (ValueError, TypeError):
         # If we can't serialize, we'll filter out unserializable flows
         serialized_flows = []
         for flw in hass.config_entries.flow.async_progress():
@@ -434,7 +434,7 @@ def config_entries_flow_subscribe(
                 serialized_flows.append(
                     json_bytes({"type": None, "flow_id": flw["flow_id"], "flow": flw})
                 )
-            except ValueError, TypeError:
+            except (ValueError, TypeError):
                 _LOGGER.error(
                     "Unable to serialize to JSON. Bad data found at %s",
                     format_unserializable_data(

homeassistant/components/control4/climate.py

@@ -38,8 +38,6 @@ CONTROL4_CURRENT_TEMPERATURE = "TEMPERATURE_F"
 CONTROL4_HUMIDITY = "HUMIDITY"
 CONTROL4_COOL_SETPOINT = "COOL_SETPOINT_F"
 CONTROL4_HEAT_SETPOINT = "HEAT_SETPOINT_F"
-CONTROL4_FAN_MODE = "FAN_MODE"
-CONTROL4_FAN_MODES_LIST = "FAN_MODES_LIST"
 
 VARIABLES_OF_INTEREST = {
     CONTROL4_HVAC_STATE,
@@ -48,8 +46,6 @@ VARIABLES_OF_INTEREST = {
     CONTROL4_HUMIDITY,
     CONTROL4_COOL_SETPOINT,
     CONTROL4_HEAT_SETPOINT,
-    CONTROL4_FAN_MODE,
-    CONTROL4_FAN_MODES_LIST,
 }
 
 # Map Control4 HVAC modes to Home Assistant
@@ -157,7 +153,12 @@ class Control4Climate(Control4Entity, ClimateEntity):
 
     _attr_has_entity_name = True
     _attr_temperature_unit = UnitOfTemperature.FAHRENHEIT
-    _attr_translation_key = "thermostat"
+    _attr_supported_features = (
+        ClimateEntityFeature.TARGET_TEMPERATURE
+        | ClimateEntityFeature.TARGET_TEMPERATURE_RANGE
+        | ClimateEntityFeature.TURN_ON
+        | ClimateEntityFeature.TURN_OFF
+    )
     _attr_hvac_modes = [HVACMode.OFF, HVACMode.HEAT, HVACMode.COOL, HVACMode.HEAT_COOL]
 
     def __init__(
@@ -200,19 +201,6 @@ class Control4Climate(Control4Entity, ClimateEntity):
         """Return the thermostat data from the coordinator."""
         return self.coordinator.data.get(self._idx)
 
-    @property
-    def supported_features(self) -> ClimateEntityFeature:
-        """Return the list of supported features."""
-        features = (
-            ClimateEntityFeature.TARGET_TEMPERATURE
-            | ClimateEntityFeature.TARGET_TEMPERATURE_RANGE
-            | ClimateEntityFeature.TURN_ON
-            | ClimateEntityFeature.TURN_OFF
-        )
-        if self.fan_modes:
-            features |= ClimateEntityFeature.FAN_MODE
-        return features
-
     @property
     def current_temperature(self) -> float | None:
         """Return the current temperature."""
@@ -287,28 +275,6 @@ class Control4Climate(Control4Entity, ClimateEntity):
             return data.get(CONTROL4_HEAT_SETPOINT)
         return None
 
-    @property
-    def fan_mode(self) -> str | None:
-        """Return the current fan mode."""
-        data = self._thermostat_data
-        if data is None:
-            return None
-        c4_fan_mode = data.get(CONTROL4_FAN_MODE)
-        if c4_fan_mode is None:
-            return None
-        return c4_fan_mode.lower()
-
-    @property
-    def fan_modes(self) -> list[str] | None:
-        """Return the list of available fan modes."""
-        data = self._thermostat_data
-        if data is None:
-            return None
-        modes = data.get(CONTROL4_FAN_MODES_LIST)
-        if not modes:
-            return None
-        return [m.strip().lower() for m in modes.split(",") if m.strip()]
-
     async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
         """Set new target HVAC mode."""
         c4_hvac_mode = HA_TO_C4_HVAC_MODE[hvac_mode]
@@ -337,9 +303,3 @@ class Control4Climate(Control4Entity, ClimateEntity):
                 await c4_climate.setHeatSetpointF(temp)
 
         await self.coordinator.async_request_refresh()
-
-    async def async_set_fan_mode(self, fan_mode: str) -> None:
-        """Set new target fan mode."""
-        c4_climate = self._create_api_object()
-        await c4_climate.setFanMode(fan_mode.title())
-        await self.coordinator.async_request_refresh()

homeassistant/components/control4/config_flow.py

@@ -74,7 +74,7 @@ class Control4ConfigFlow(ConfigFlow, domain=DOMAIN):
             director_bearer_token = (
                 await account.getDirectorBearerToken(controller_unique_id)
             )["token"]
-        except BadCredentials, Unauthorized:
+        except (BadCredentials, Unauthorized):
             errors["base"] = "invalid_auth"
             return errors, data, description_placeholders
         except NotFound:
@@ -97,7 +97,7 @@ class Control4ConfigFlow(ConfigFlow, domain=DOMAIN):
         except Unauthorized:
             errors["base"] = "director_auth_failed"
             return errors, data, description_placeholders
-        except ClientError, TimeoutError:
+        except (ClientError, TimeoutError):
             errors["base"] = "cannot_connect"
             description_placeholders["host"] = host
             return errors, data, description_placeholders

homeassistant/components/control4/icons.json

@@ -1,15 +0,0 @@
-{
-  "entity": {
-    "climate": {
-      "thermostat": {
-        "state_attributes": {
-          "fan_mode": {
-            "state": {
-              "circulate": "mdi:fan-clock"
-            }
-          }
-        }
-      }
-    }
-  }
-}

homeassistant/components/control4/strings.json

@@ -21,19 +21,6 @@
       }
     }
   },
-  "entity": {
-    "climate": {
-      "thermostat": {
-        "state_attributes": {
-          "fan_mode": {
-            "state": {
-              "circulate": "Circulate"
-            }
-          }
-        }
-      }
-    }
-  },
   "options": {
     "step": {
       "init": {

homeassistant/components/cookidoo/sensor.py

@@ -48,11 +48,9 @@ SENSOR_DESCRIPTIONS: tuple[CookidooSensorEntityDescription, ...] = (
         key=CookidooSensor.SUBSCRIPTION,
         translation_key=CookidooSensor.SUBSCRIPTION,
         value_fn=(
-            lambda data: (
-                SUBSCRIPTION_MAP[data.subscription.type]
-                if data.subscription
-                else SUBSCRIPTION_MAP["NONE"]
-            )
+            lambda data: SUBSCRIPTION_MAP[data.subscription.type]
+            if data.subscription
+            else SUBSCRIPTION_MAP["NONE"]
         ),
         entity_category=EntityCategory.DIAGNOSTIC,
         options=list(SUBSCRIPTION_MAP.values()),
@@ -62,11 +60,9 @@ SENSOR_DESCRIPTIONS: tuple[CookidooSensorEntityDescription, ...] = (
         key=CookidooSensor.EXPIRES,
         translation_key=CookidooSensor.EXPIRES,
         value_fn=(
-            lambda data: (
-                dt_util.parse_datetime(data.subscription.expires)
-                if data.subscription
-                else None
-            )
+            lambda data: dt_util.parse_datetime(data.subscription.expires)
+            if data.subscription
+            else None
         ),
         entity_category=EntityCategory.DIAGNOSTIC,
         device_class=SensorDeviceClass.TIMESTAMP,

homeassistant/components/daikin/config_flow.py

@@ -93,7 +93,7 @@ class FlowHandler(ConfigFlow, domain=DOMAIN):
                     password=password,
                     ssl_context=client_context_no_verify(),
                 )
-        except TimeoutError, ClientError:
+        except (TimeoutError, ClientError):
             self.host = None
             return self.async_show_form(
                 step_id="user",

homeassistant/components/datadog/config_flow.py

@@ -142,7 +142,7 @@ async def validate_datadog_connection(
     try:
         client = DogStatsd(user_input[CONF_HOST], user_input[CONF_PORT])
         await hass.async_add_executor_job(client.increment, "connection_test")
-    except OSError, ValueError:
+    except (OSError, ValueError):
         return False
     else:
         return True