Bump bluetooth-adapters to 2.2.0

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Joost Lekkerkerker <joostlek@outlook.com>

.devcontainer/devcontainer-lock.json

@@ -0,0 +1,9 @@
+{
+  "features": {
+    "ghcr.io/devcontainers/features/github-cli:1": {
+      "version": "1.1.0",
+      "resolved": "ghcr.io/devcontainers/features/github-cli@sha256:d22f50b70ed75339b4eed1ba9ecde3a1791f90e88d37936517e3bace0bbad671",
+      "integrity": "sha256:d22f50b70ed75339b4eed1ba9ecde3a1791f90e88d37936517e3bace0bbad671"
+    }
+  }
+}

.strict-typing

@@ -609,6 +609,7 @@ homeassistant.components.valve.*
 homeassistant.components.velbus.*
 homeassistant.components.velux.*
 homeassistant.components.victron_gx.*
+homeassistant.components.vistapool.*
 homeassistant.components.vivotek.*
 homeassistant.components.vlc_telnet.*
 homeassistant.components.vodafone_station.*

CODEOWNERS

@@ -236,8 +236,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/blebox/ @bbx-a @swistakm @bkobus-bbx
 /homeassistant/components/blink/ @fronzbot
 /tests/components/blink/ @fronzbot
-/homeassistant/components/blue_current/ @gleeuwen @NickKoepr @jtodorova23
-/tests/components/blue_current/ @gleeuwen @NickKoepr @jtodorova23
+/homeassistant/components/blue_current/ @gleeuwen @jtodorova23
+/tests/components/blue_current/ @gleeuwen @jtodorova23
 /homeassistant/components/bluemaestro/ @bdraco
 /tests/components/bluemaestro/ @bdraco
 /homeassistant/components/blueprint/ @home-assistant/core
@@ -945,8 +945,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/knx/ @Julius2342 @farmio @marvin-w
 /homeassistant/components/kodi/ @OnFreund
 /tests/components/kodi/ @OnFreund
-/homeassistant/components/konnected/ @heythisisnate
-/tests/components/konnected/ @heythisisnate
 /homeassistant/components/kostal_plenticore/ @stegm
 /tests/components/kostal_plenticore/ @stegm
 /homeassistant/components/kraken/ @eifinger
@@ -1932,6 +1930,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/victron_remote_monitoring/ @AndyTempel
 /homeassistant/components/vilfo/ @ManneW
 /tests/components/vilfo/ @ManneW
+/homeassistant/components/vistapool/ @fdebrus
+/tests/components/vistapool/ @fdebrus
 /homeassistant/components/vivotek/ @HarlemSquirrel
 /tests/components/vivotek/ @HarlemSquirrel
 /homeassistant/components/vizio/ @raman325

homeassistant/components/alexa/entities.py

@@ -39,7 +39,6 @@ from homeassistant.const import (
     ATTR_DEVICE_CLASS,
     ATTR_SUPPORTED_FEATURES,
     ATTR_UNIT_OF_MEASUREMENT,
-    CLOUD_NEVER_EXPOSED_ENTITIES,
     CONF_DESCRIPTION,
     CONF_NAME,
     UnitOfTemperature,
@@ -373,9 +372,6 @@ def async_get_entities(
     """Return all entities that are supported by Alexa."""
     entities: list[AlexaEntity] = []
     for state in hass.states.async_all():
-        if state.entity_id in CLOUD_NEVER_EXPOSED_ENTITIES:
-            continue
-
         if state.domain not in ENTITY_ADAPTERS:
             continue
 

homeassistant/components/altruist/config_flow.py

@@ -7,10 +7,11 @@ from altruistclient import AltruistClient, AltruistDeviceModel, AltruistError
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_HOST
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo
 
-from .const import CONF_HOST, DOMAIN
+from .const import DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 

homeassistant/components/altruist/const.py

@@ -1,6 +1,3 @@
 """Constants for the Altruist integration."""
 
 DOMAIN = "altruist"
-
-# pylint: disable-next=home-assistant-duplicate-const
-CONF_HOST = "host"

homeassistant/components/altruist/coordinator.py

@@ -10,13 +10,12 @@ import logging
 from altruistclient import AltruistClient, AltruistError
 
 from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_HOST
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
-from .const import CONF_HOST
-
 _LOGGER = logging.getLogger(__name__)
 
 UPDATE_INTERVAL = timedelta(seconds=15)

homeassistant/components/apple_tv/media_player.py

@@ -345,7 +345,10 @@ class AppleTvMediaPlayer(
             play_item = await media_source.async_resolve_media(
                 self.hass, media_id, self.entity_id
             )
-            media_id = async_process_play_media_url(self.hass, play_item.url)
+            if play_item.path and self._is_feature_available(FeatureName.StreamFile):
+                media_id = str(play_item.path)
+            else:
+                media_id = async_process_play_media_url(self.hass, play_item.url)
             media_type = MediaType.MUSIC
 
         if self._is_feature_available(FeatureName.StreamFile) and (

homeassistant/components/arcam_fmj/config_flow.py

@@ -16,6 +16,13 @@ from homeassistant.helpers.service_info.ssdp import ATTR_UPNP_UDN, SsdpServiceIn
 
 from .const import DEFAULT_NAME, DEFAULT_PORT, DOMAIN
 
+STEP_DATA_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_HOST): str,
+        vol.Required(CONF_PORT, default=DEFAULT_PORT): int,
+    }
+)
+
 
 class ArcamFmjFlowHandler(ConfigFlow, domain=DOMAIN):
     """Handle config flow."""
@@ -31,13 +38,22 @@ class ArcamFmjFlowHandler(ConfigFlow, domain=DOMAIN):
         await self.async_set_unique_id(uuid)
         self._abort_if_unique_id_configured({CONF_HOST: host, CONF_PORT: port})
 
-    async def _async_try_connect(self, host: str, port: int) -> None:
-        """Verify the device is reachable."""
+    async def _async_try_connect(self, host: str, port: int) -> dict[str, str]:
+        """Verify the device is reachable; return errors keyed by reason."""
         client = Client(host, port)
         try:
             await client.start()
+        except socket.gaierror:
+            return {"base": "invalid_host"}
+        except TimeoutError:
+            return {"base": "timeout_connect"}
+        except ConnectionRefusedError:
+            return {"base": "connection_refused"}
+        except ConnectionFailed, OSError:
+            return {"base": "cannot_connect"}
         finally:
             await client.stop()
+        return {}
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
@@ -53,19 +69,10 @@ class ArcamFmjFlowHandler(ConfigFlow, domain=DOMAIN):
                     user_input[CONF_HOST], user_input[CONF_PORT], uuid
                 )
 
-            try:
-                await self._async_try_connect(
-                    user_input[CONF_HOST], user_input[CONF_PORT]
-                )
-            except socket.gaierror:
-                errors["base"] = "invalid_host"
-            except TimeoutError:
-                errors["base"] = "timeout_connect"
-            except ConnectionRefusedError:
-                errors["base"] = "connection_refused"
-            except ConnectionFailed, OSError:
-                errors["base"] = "cannot_connect"
-            else:
+            errors = await self._async_try_connect(
+                user_input[CONF_HOST], user_input[CONF_PORT]
+            )
+            if not errors:
                 return self.async_create_entry(
                     title=f"{DEFAULT_NAME} ({user_input[CONF_HOST]})",
                     data={
@@ -74,16 +81,46 @@ class ArcamFmjFlowHandler(ConfigFlow, domain=DOMAIN):
                     },
                 )
 
-        fields = {
-            vol.Required(CONF_HOST): str,
-            vol.Required(CONF_PORT, default=DEFAULT_PORT): int,
-        }
-        schema = vol.Schema(fields)
+        schema = STEP_DATA_SCHEMA
         if user_input is not None:
             schema = self.add_suggested_values_to_schema(schema, user_input)
 
         return self.async_show_form(step_id="user", data_schema=schema, errors=errors)
 
+    async def async_step_reconfigure(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle reconfiguration of an existing entry."""
+        errors: dict[str, str] = {}
+        reconfigure_entry = self._get_reconfigure_entry()
+        if user_input is not None:
+            uuid = await get_uniqueid_from_host(
+                async_get_clientsession(self.hass), user_input[CONF_HOST]
+            )
+            if uuid:
+                await self.async_set_unique_id(uuid)
+                self._abort_if_unique_id_mismatch()
+
+            errors = await self._async_try_connect(
+                user_input[CONF_HOST], user_input[CONF_PORT]
+            )
+            if not errors:
+                return self.async_update_reload_and_abort(
+                    reconfigure_entry,
+                    data_updates={
+                        CONF_HOST: user_input[CONF_HOST],
+                        CONF_PORT: user_input[CONF_PORT],
+                    },
+                )
+
+        schema = self.add_suggested_values_to_schema(
+            STEP_DATA_SCHEMA, user_input or reconfigure_entry.data
+        )
+
+        return self.async_show_form(
+            step_id="reconfigure", data_schema=schema, errors=errors
+        )
+
     async def async_step_confirm(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
@@ -113,9 +150,7 @@ class ArcamFmjFlowHandler(ConfigFlow, domain=DOMAIN):
 
         await self._async_set_unique_id_and_update(host, port, uuid)
 
-        try:
-            await self._async_try_connect(host, port)
-        except ConnectionFailed, OSError:
+        if await self._async_try_connect(host, port):
             return self.async_abort(reason="cannot_connect")
 
         self.host = host

homeassistant/components/arcam_fmj/strings.json

@@ -3,7 +3,9 @@
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
       "already_in_progress": "[%key:common::config_flow::abort::already_in_progress%]",
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]"
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
+      "unique_id_mismatch": "Please ensure you reconfigure against the same device."
     },
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
@@ -16,6 +18,13 @@
       "confirm": {
         "description": "Do you want to add Arcam FMJ on `{host}` to Home Assistant?"
       },
+      "reconfigure": {
+        "data": {
+          "host": "[%key:common::config_flow::data::host%]",
+          "port": "[%key:common::config_flow::data::port%]"
+        },
+        "description": "[%key:component::arcam_fmj::config::step::user::description%]"
+      },
       "user": {
         "data": {
           "host": "[%key:common::config_flow::data::host%]",

homeassistant/components/aurora_abb_powerone/config_flow.py

@@ -9,12 +9,11 @@ import voluptuous as vol
 
 from homeassistant.components import usb
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import ATTR_SERIAL_NUMBER, CONF_ADDRESS, CONF_PORT
+from homeassistant.const import ATTR_MODEL, ATTR_SERIAL_NUMBER, CONF_ADDRESS, CONF_PORT
 from homeassistant.core import HomeAssistant
 
 from .const import (
     ATTR_FIRMWARE,
-    ATTR_MODEL,
     DEFAULT_ADDRESS,
     DEFAULT_INTEGRATION_TITLE,
     DOMAIN,

homeassistant/components/aurora_abb_powerone/const.py

@@ -19,8 +19,4 @@ DEVICES = "devices"
 MANUFACTURER = "ABB"
 
 ATTR_DEVICE_NAME = "device_name"
-# pylint: disable-next=home-assistant-duplicate-const
-ATTR_DEVICE_ID = "device_id"
-# pylint: disable-next=home-assistant-duplicate-const
-ATTR_MODEL = "model"
 ATTR_FIRMWARE = "firmware"

homeassistant/components/aurora_abb_powerone/sensor.py

@@ -13,6 +13,7 @@ from homeassistant.components.sensor import (
     SensorStateClass,
 )
 from homeassistant.const import (
+    ATTR_MODEL,
     ATTR_SERIAL_NUMBER,
     EntityCategory,
     UnitOfElectricCurrent,
@@ -31,7 +32,6 @@ from homeassistant.helpers.update_coordinator import CoordinatorEntity
 from .const import (
     ATTR_DEVICE_NAME,
     ATTR_FIRMWARE,
-    ATTR_MODEL,
     DEFAULT_DEVICE_NAME,
     DOMAIN,
     MANUFACTURER,

homeassistant/components/aws_s3/backup.py

@@ -17,10 +17,11 @@ from homeassistant.components.backup import (
     OnProgressCallback,
     suggested_filename,
 )
+from homeassistant.const import CONF_PREFIX
 from homeassistant.core import HomeAssistant, callback
 
 from . import S3ConfigEntry
-from .const import CONF_BUCKET, CONF_PREFIX, DATA_BACKUP_AGENT_LISTENERS, DOMAIN
+from .const import CONF_BUCKET, DATA_BACKUP_AGENT_LISTENERS, DOMAIN
 from .helpers import async_list_backups_from_s3
 
 _LOGGER = logging.getLogger(__name__)

homeassistant/components/aws_s3/config_flow.py

@@ -8,6 +8,7 @@ from botocore.exceptions import ClientError, ConnectionError, ParamValidationErr
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_PREFIX
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.selector import (
     TextSelector,
@@ -20,7 +21,6 @@ from .const import (
     CONF_ACCESS_KEY_ID,
     CONF_BUCKET,
     CONF_ENDPOINT_URL,
-    CONF_PREFIX,
     CONF_SECRET_ACCESS_KEY,
     DEFAULT_ENDPOINT_URL,
     DESCRIPTION_AWS_S3_DOCS_URL,

homeassistant/components/aws_s3/const.py

@@ -11,8 +11,6 @@ CONF_ACCESS_KEY_ID = "access_key_id"
 CONF_SECRET_ACCESS_KEY = "secret_access_key"
 CONF_ENDPOINT_URL = "endpoint_url"
 CONF_BUCKET = "bucket"
-# pylint: disable-next=home-assistant-duplicate-const
-CONF_PREFIX = "prefix"
 
 AWS_DOMAIN = "amazonaws.com"
 DEFAULT_ENDPOINT_URL = f"https://s3.eu-central-1.{AWS_DOMAIN}/"

homeassistant/components/aws_s3/coordinator.py

@@ -8,10 +8,11 @@ from aiobotocore.client import AioBaseClient as S3Client
 from botocore.exceptions import BotoCoreError
 
 from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_PREFIX
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
-from .const import CONF_BUCKET, CONF_PREFIX, DOMAIN
+from .const import CONF_BUCKET, DOMAIN
 from .helpers import async_list_backups_from_s3
 
 SCAN_INTERVAL = timedelta(hours=6)

homeassistant/components/aws_s3/diagnostics.py

@@ -5,15 +5,10 @@ from typing import Any
 
 from homeassistant.components.backup import DATA_MANAGER as BACKUP_DATA_MANAGER
 from homeassistant.components.diagnostics import async_redact_data
+from homeassistant.const import CONF_PREFIX
 from homeassistant.core import HomeAssistant
 
-from .const import (
-    CONF_ACCESS_KEY_ID,
-    CONF_BUCKET,
-    CONF_PREFIX,
-    CONF_SECRET_ACCESS_KEY,
-    DOMAIN,
-)
+from .const import CONF_ACCESS_KEY_ID, CONF_BUCKET, CONF_SECRET_ACCESS_KEY, DOMAIN
 from .coordinator import S3ConfigEntry
 from .helpers import async_list_backups_from_s3
 

homeassistant/components/axis/config_flow.py

@@ -8,7 +8,6 @@ from urllib.parse import urlsplit
 import voluptuous as vol
 
 from homeassistant.config_entries import (
-    SOURCE_IGNORE,
     SOURCE_REAUTH,
     SOURCE_RECONFIGURE,
     ConfigEntry,
@@ -139,25 +138,15 @@ class AxisFlowHandler(ConfigFlow, domain=DOMAIN):
     async def _create_entry(self, serial: str) -> ConfigFlowResult:
         """Create entry for device.
 
-        Generate a name to be used as a prefix for device entities.
+        Use the discovered device name when available.
         """
-        model = self.config[CONF_MODEL]
-        same_model = [
-            entry.data[CONF_NAME]
-            for entry in self.hass.config_entries.async_entries(DOMAIN)
-            if entry.source != SOURCE_IGNORE and entry.data[CONF_MODEL] == model
-        ]
-
-        name = model
-        for idx in range(len(same_model) + 1):
-            name = f"{model} {idx}"
-            if name not in same_model:
-                break
-
+        if (title_placeholders := self.context.get("title_placeholders")) is not None:
+            name = title_placeholders[CONF_NAME]
+        else:
+            name = f"{self.config[CONF_MODEL]} - {serial}"
         self.config[CONF_NAME] = name
 
-        title = f"{model} - {serial}"
-        return self.async_create_entry(title=title, data=self.config)
+        return self.async_create_entry(title=name, data=self.config)
 
     async def async_step_reconfigure(
         self, user_input: dict[str, Any] | None = None

homeassistant/components/axis/hub/event_source.py

@@ -2,8 +2,7 @@
 
 import axis
 from axis.errors import Unauthorized
-from axis.interfaces.mqtt import mqtt_json_to_event
-from axis.models.mqtt import ClientState
+from axis.models.mqtt import ClientState, mqtt_json_to_event
 from axis.stream_manager import Signal, State
 
 from homeassistant.components import mqtt

homeassistant/components/axis/manifest.json

@@ -29,7 +29,7 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["axis"],
-  "requirements": ["axis==71"],
+  "requirements": ["axis==72"],
   "ssdp": [
     {
       "manufacturer": "AXIS"

homeassistant/components/blue_current/manifest.json

@@ -1,7 +1,7 @@
 {
   "domain": "blue_current",
   "name": "Blue Current",
-  "codeowners": ["@gleeuwen", "@NickKoepr", "@jtodorova23"],
+  "codeowners": ["@gleeuwen", "@jtodorova23"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/blue_current",
   "integration_type": "hub",

homeassistant/components/bluetooth/__init__.py

@@ -11,6 +11,7 @@ from bluetooth_adapters import (
     ADAPTER_CONNECTION_SLOTS,
     ADAPTER_HW_VERSION,
     ADAPTER_MANUFACTURER,
+    ADAPTER_PASSIVE_SCAN,
     ADAPTER_SW_VERSION,
     DEFAULT_ADDRESS,
     DEFAULT_CONNECTION_SLOTS,
@@ -69,6 +70,7 @@ from .api import (
     async_register_callback,
     async_register_scanner,
     async_remove_scanner,
+    async_request_active_scan,
     async_scanner_by_source,
     async_scanner_count,
     async_scanner_devices_by_address,
@@ -79,7 +81,6 @@ from .const import (
     BLUETOOTH_DISCOVERY_COOLDOWN_SECONDS,
     CONF_ADAPTER,
     CONF_DETAILS,
-    CONF_PASSIVE,
     CONF_SOURCE_CONFIG_ENTRY_ID,
     CONF_SOURCE_DEVICE_ID,
     CONF_SOURCE_DOMAIN,
@@ -93,7 +94,7 @@ from .manager import HomeAssistantBluetoothManager
 from .match import BluetoothCallbackMatcher, IntegrationMatcher
 from .models import BluetoothCallback, BluetoothChange
 from .storage import BluetoothStorage
-from .util import adapter_title
+from .util import adapter_title, resolve_scanning_mode
 
 if TYPE_CHECKING:
     from homeassistant.helpers.typing import ConfigType
@@ -128,6 +129,7 @@ __all__ = [
     "async_register_callback",
     "async_register_scanner",
     "async_remove_scanner",
+    "async_request_active_scan",
     "async_scanner_by_source",
     "async_scanner_count",
     "async_scanner_devices_by_address",
@@ -387,12 +389,15 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         raise ConfigEntryNotReady(
             f"Bluetooth adapter {adapter} with address {address} not found"
         )
-    passive = entry.options.get(CONF_PASSIVE)
     adapters = await manager.async_get_bluetooth_adapters()
-    mode = BluetoothScanningMode.PASSIVE if passive else BluetoothScanningMode.ACTIVE
+    details = adapters[adapter]
+    mode = resolve_scanning_mode(entry.options)
+    # AUTO needs passive scanning support to flip on demand; without it
+    # the scanner would start passive on hardware that can't do passive.
+    if mode is BluetoothScanningMode.AUTO and not details.get(ADAPTER_PASSIVE_SCAN):
+        mode = BluetoothScanningMode.ACTIVE
     scanner = HaScanner(mode, adapter, address)
     scanner.async_setup()
-    details = adapters[adapter]
     if entry.title == address:
         hass.config_entries.async_update_entry(
             entry, title=adapter_title(adapter, details)

homeassistant/components/bluetooth/active_update_processor.py

@@ -68,9 +68,20 @@ class ActiveBluetoothProcessorCoordinator[_DataT](
         | None = None,
         poll_debouncer: Debouncer[Coroutine[Any, Any, None]] | None = None,
         connectable: bool = True,
+        scan_interval: float | None = None,
+        scan_duration: float | None = None,
     ) -> None:
         """Initialize the processor."""
-        super().__init__(hass, logger, address, mode, update_method, connectable)
+        super().__init__(
+            hass,
+            logger,
+            address,
+            mode,
+            update_method,
+            connectable,
+            scan_interval,
+            scan_duration,
+        )
 
         self._needs_poll_method = needs_poll_method
         self._poll_method = poll_method

homeassistant/components/bluetooth/api.py

@@ -130,17 +130,26 @@ def async_register_callback(
     callback: BluetoothCallback,
     match_dict: BluetoothCallbackMatcher | None,
     mode: BluetoothScanningMode,
+    *,
+    scan_interval: float | None = None,
+    scan_duration: float | None = None,
 ) -> Callable[[], None]:
     """Register to receive a callback on bluetooth change.
 
-    mode is currently not used as we only support active scanning.
-    Passive scanning will be available in the future. The flag
-    is required to be present to avoid a future breaking change
-    when we support passive scanning.
+    When ``mode`` is not PASSIVE and ``match_dict["address"]`` is set,
+    the address is registered with habluetooth's active-scan scheduler
+    so AUTO-mode scanners flip ACTIVE on demand for that device.
+    ``scan_interval`` / ``scan_duration`` default to habluetooth's
+    DEFAULT_ACTIVE_SCAN_* (5 minutes / 10 seconds) when not provided;
+    integrations that need a different cadence can pass explicit
+    values. Without an address in the matcher the active-scan request
+    is skipped; the callback itself still fires normally.
 
     Returns a callback that can be used to cancel the registration.
     """
-    return _get_manager(hass).async_register_callback(callback, match_dict)
+    return _get_manager(hass).async_register_callback(
+        callback, match_dict, mode, scan_interval, scan_duration
+    )
 
 
 async def async_process_advertisements(
@@ -161,7 +170,7 @@ async def async_process_advertisements(
             done.set_result(service_info)
 
     unload = _get_manager(hass).async_register_callback(
-        _async_discovered_device, match_dict
+        _async_discovered_device, match_dict, mode, scan_duration=timeout
     )
 
     try:
@@ -275,3 +284,19 @@ def async_set_fallback_availability_interval(
 ) -> None:
     """Override the fallback availability timeout for a MAC address."""
     _get_manager(hass).async_set_fallback_availability_interval(address, interval)
+
+
+async def async_request_active_scan(
+    hass: HomeAssistant, duration: float | None = None
+) -> None:
+    """Run an on-demand active sweep across every AUTO scanner.
+
+    Intended for config-flow discovery and other one-shot probes that
+    need fresh advertisements without waiting for the periodic
+    rediscovery cadence. Awaits ``duration`` seconds so the caller can
+    then read newly discovered advertisements. Defaults to habluetooth's
+    on-demand sweep duration when ``duration`` is not provided; the
+    scheduler clamps the value to its allowed range. Concurrent callers
+    dedupe to a single bus-wide window.
+    """
+    await _get_manager(hass).async_request_active_scan(duration)

homeassistant/components/bluetooth/config_flow.py

@@ -12,7 +12,7 @@ from bluetooth_adapters import (
     adapter_model,
     get_adapters,
 )
-from habluetooth import get_manager
+from habluetooth import BluetoothScanningMode, get_manager
 import voluptuous as vol
 
 from homeassistant.components import onboarding
@@ -24,14 +24,21 @@ from homeassistant.config_entries import (
 )
 from homeassistant.core import callback
 from homeassistant.helpers.schema_config_entry_flow import (
+    SchemaCommonFlowHandler,
     SchemaFlowFormStep,
     SchemaOptionsFlowHandler,
 )
+from homeassistant.helpers.selector import (
+    SelectSelector,
+    SelectSelectorConfig,
+    SelectSelectorMode,
+)
 from homeassistant.helpers.typing import DiscoveryInfoType
 
 from .const import (
     CONF_ADAPTER,
     CONF_DETAILS,
+    CONF_MODE,
     CONF_PASSIVE,
     CONF_SOURCE,
     CONF_SOURCE_CONFIG_ENTRY_ID,
@@ -40,15 +47,39 @@ from .const import (
     CONF_SOURCE_MODEL,
     DOMAIN,
 )
-from .util import adapter_title
+from .util import adapter_title, resolve_scanning_mode
 
-OPTIONS_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_PASSIVE, default=False): bool,
-    }
+_MODE_SELECTOR = SelectSelector(
+    SelectSelectorConfig(
+        options=[
+            BluetoothScanningMode.AUTO.value,
+            BluetoothScanningMode.ACTIVE.value,
+            BluetoothScanningMode.PASSIVE.value,
+        ],
+        translation_key="mode",
+        mode=SelectSelectorMode.DROPDOWN,
+    )
 )
+
+
+async def _options_schema(handler: SchemaCommonFlowHandler) -> vol.Schema:
+    """Build the options schema with the saved mode as the default."""
+    current = resolve_scanning_mode(handler.options).value
+    return vol.Schema({vol.Required(CONF_MODE, default=current): _MODE_SELECTOR})
+
+
+async def _validate_options(
+    handler: SchemaCommonFlowHandler, user_input: dict[str, Any]
+) -> dict[str, Any]:
+    """Mirror CONF_MODE into the legacy CONF_PASSIVE for downgrade safety."""
+    user_input[CONF_PASSIVE] = (
+        user_input[CONF_MODE] == BluetoothScanningMode.PASSIVE.value
+    )
+    return user_input
+
+
 OPTIONS_FLOW = {
-    "init": SchemaFlowFormStep(OPTIONS_SCHEMA),
+    "init": SchemaFlowFormStep(_options_schema, validate_user_input=_validate_options),
 }
 
 

homeassistant/components/bluetooth/const.py

@@ -7,14 +7,21 @@ from habluetooth import (  # noqa: F401
     FALLBACK_MAXIMUM_STALE_ADVERTISEMENT_SECONDS,
     SCANNER_WATCHDOG_INTERVAL,
     SCANNER_WATCHDOG_TIMEOUT,
+    BluetoothScanningMode,
 )
 
+from homeassistant.const import CONF_MODE  # noqa: F401
+
 DOMAIN = "bluetooth"
 
 CONF_ADAPTER = "adapter"
 CONF_DETAILS = "details"
+# CONF_PASSIVE is the legacy boolean option; we keep writing it alongside
+# CONF_MODE so a downgrade to a pre-AUTO release reads a sensible value.
 CONF_PASSIVE = "passive"
 
+DEFAULT_MODE = BluetoothScanningMode.AUTO.value
+
 
 # pylint: disable-next=home-assistant-duplicate-const
 CONF_SOURCE: Final = "source"

homeassistant/components/bluetooth/manager.py

@@ -202,6 +202,9 @@ class HomeAssistantBluetoothManager(BluetoothManager):
         self,
         callback: BluetoothCallback,
         matcher: BluetoothCallbackMatcher | None,
+        mode: BluetoothScanningMode = BluetoothScanningMode.ACTIVE,
+        scan_interval: float | None = None,
+        scan_duration: float | None = None,
     ) -> Callable[[], None]:
         """Register a callback."""
         callback_matcher = BluetoothCallbackMatcherWithCallback(callback=callback)
@@ -216,15 +219,31 @@ class HomeAssistantBluetoothManager(BluetoothManager):
         connectable = callback_matcher[CONNECTABLE]
         self._callback_index.add_callback_matcher(callback_matcher)
 
+        # If the matcher targets a specific address and the caller
+        # didn't explicitly ask for PASSIVE, wire it into habluetooth's
+        # active-scan scheduler so AUTO-mode scanners flip ACTIVE on
+        # demand for this device. ``scan_interval``/``scan_duration``
+        # default to habluetooth's DEFAULT_ACTIVE_SCAN_* when None.
+        cancel_active_scan: Callable[[], None] | None = None
+        if (
+            mode is not BluetoothScanningMode.PASSIVE
+            and (address := callback_matcher.get(ADDRESS)) is not None
+        ):
+            cancel_active_scan = self.async_register_active_scan(
+                address, scan_interval, scan_duration
+            )
+
         def _async_remove_callback() -> None:
             self._callback_index.remove_callback_matcher(callback_matcher)
+            if cancel_active_scan is not None:
+                cancel_active_scan()
 
         # If we have history for the subscriber, we can trigger the callback
         # immediately with the last packet so the subscriber can see the
         # device.
         history = self._connectable_history if connectable else self._all_history
         service_infos: Iterable[BluetoothServiceInfoBleak] = []
-        if address := callback_matcher.get(ADDRESS):
+        if (address := callback_matcher.get(ADDRESS)) is not None:
             if service_info := history.get(address):
                 service_infos = [service_info]
         else:

homeassistant/components/bluetooth/manifest.json

@@ -15,12 +15,12 @@
   ],
   "quality_scale": "internal",
   "requirements": [
-    "bleak==2.1.1",
-    "bleak-retry-connector==4.6.0",
-    "bluetooth-adapters==2.1.0",
+    "bleak==3.0.2",
+    "bleak-retry-connector==4.6.1",
+    "bluetooth-adapters==2.2.0",
     "bluetooth-auto-recovery==1.5.3",
-    "bluetooth-data-tools==1.29.11",
+    "bluetooth-data-tools==1.29.18",
     "dbus-fast==5.0.3",
-    "habluetooth==6.2.0"
+    "habluetooth==6.7.3"
   ]
 }

homeassistant/components/bluetooth/passive_update_processor.py

@@ -298,9 +298,13 @@ class PassiveBluetoothProcessorCoordinator[_DataT](BasePassiveBluetoothCoordinat
         mode: BluetoothScanningMode,
         update_method: Callable[[BluetoothServiceInfoBleak], _DataT],
         connectable: bool = False,
+        scan_interval: float | None = None,
+        scan_duration: float | None = None,
     ) -> None:
         """Initialize the coordinator."""
-        super().__init__(hass, logger, address, mode, connectable)
+        super().__init__(
+            hass, logger, address, mode, connectable, scan_interval, scan_duration
+        )
         self._processors: list[PassiveBluetoothDataProcessor[Any, _DataT]] = []
         self._update_method = update_method
         self.last_update_success = True

homeassistant/components/bluetooth/strings.json

@@ -48,9 +48,21 @@
     "step": {
       "init": {
         "data": {
-          "passive": "Passive scanning"
+          "mode": "Scanning mode"
+        },
+        "data_description": {
+          "mode": "Auto is recommended for most setups. It saves battery on your Bluetooth devices while still catching new devices and updates quickly."
         }
       }
     }
+  },
+  "selector": {
+    "mode": {
+      "options": {
+        "active": "Active (uses more device battery, fastest updates)",
+        "auto": "Auto (recommended, saves device battery)",
+        "passive": "Passive (lowest device battery use, some details may be missing)"
+      }
+    }
   }
 }

homeassistant/components/bluetooth/update_coordinator.py

@@ -30,6 +30,8 @@ class BasePassiveBluetoothCoordinator(ABC):
         address: str,
         mode: BluetoothScanningMode,
         connectable: bool,
+        scan_interval: float | None = None,
+        scan_duration: float | None = None,
     ) -> None:
         """Initialize the coordinator."""
         self.hass = hass
@@ -38,6 +40,8 @@ class BasePassiveBluetoothCoordinator(ABC):
         self.connectable = connectable
         self._on_stop: list[CALLBACK_TYPE] = []
         self.mode = mode
+        self._scan_interval = scan_interval
+        self._scan_duration = scan_duration
         self._last_unavailable_time = 0.0
         self._last_name = address
         # Subclasses are responsible for setting _available to True
@@ -92,6 +96,8 @@ class BasePassiveBluetoothCoordinator(ABC):
                     address=self.address, connectable=self.connectable
                 ),
                 self.mode,
+                scan_interval=self._scan_interval,
+                scan_duration=self._scan_duration,
             )
         )
         self._on_stop.append(

homeassistant/components/bluetooth/util.py

@@ -1,5 +1,9 @@
 """The bluetooth integration utilities."""
 
+from collections.abc import Mapping
+import logging
+from typing import Any
+
 from bluetooth_adapters import (
     ADAPTER_ADDRESS,
     ADAPTER_MANUFACTURER,
@@ -9,14 +13,32 @@ from bluetooth_adapters import (
     adapter_unique_name,
 )
 from bluetooth_data_tools import monotonic_time_coarse
-from habluetooth import get_manager
+from habluetooth import BluetoothScanningMode, get_manager
 
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 
+from .const import CONF_MODE, CONF_PASSIVE, DEFAULT_MODE
 from .models import BluetoothServiceInfoBleak
 from .storage import BluetoothStorage
 
+_LOGGER = logging.getLogger(__name__)
+
+
+def resolve_scanning_mode(options: Mapping[str, Any]) -> BluetoothScanningMode:
+    """Resolve CONF_MODE, falling back to legacy CONF_PASSIVE or DEFAULT_MODE."""
+    if (mode_value := options.get(CONF_MODE)) is not None:
+        try:
+            return BluetoothScanningMode(mode_value)
+        except TypeError, ValueError:
+            _LOGGER.warning("Unknown bluetooth scanning mode %r", mode_value)
+            return BluetoothScanningMode(DEFAULT_MODE)
+    if (legacy_passive := options.get(CONF_PASSIVE)) is True:
+        return BluetoothScanningMode.PASSIVE
+    if legacy_passive is False:
+        return BluetoothScanningMode.ACTIVE
+    return BluetoothScanningMode(DEFAULT_MODE)
+
 
 class InvalidConfigEntryID(HomeAssistantError):
     """Invalid config entry id."""

homeassistant/components/braviatv/config_flow.py

@@ -9,7 +9,14 @@ from pybravia import BraviaAuthError, BraviaClient, BraviaError, BraviaNotSuppor
 import voluptuous as vol
 
 from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_CLIENT_ID, CONF_HOST, CONF_MAC, CONF_NAME, CONF_PIN
+from homeassistant.const import (
+    ATTR_MODEL,
+    CONF_CLIENT_ID,
+    CONF_HOST,
+    CONF_MAC,
+    CONF_NAME,
+    CONF_PIN,
+)
 from homeassistant.helpers import instance_id
 from homeassistant.helpers.aiohttp_client import async_create_clientsession
 from homeassistant.helpers.service_info.ssdp import (
@@ -23,7 +30,6 @@ from homeassistant.util.network import is_host_valid
 from .const import (
     ATTR_CID,
     ATTR_MAC,
-    ATTR_MODEL,
     CONF_NICKNAME,
     CONF_USE_PSK,
     CONF_USE_SSL,

homeassistant/components/braviatv/const.py

@@ -6,8 +6,6 @@ from typing import Final
 ATTR_CID: Final = "cid"
 ATTR_MAC: Final = "macAddr"
 ATTR_MANUFACTURER: Final = "Sony"
-# pylint: disable-next=home-assistant-duplicate-const
-ATTR_MODEL: Final = "model"
 
 CONF_NICKNAME: Final = "nickname"
 CONF_USE_PSK: Final = "use_psk"

homeassistant/components/clicksend_tts/notify.py

@@ -14,6 +14,7 @@ from homeassistant.components.notify import (
 )
 from homeassistant.const import (
     CONF_API_KEY,
+    CONF_LANGUAGE,
     CONF_NAME,
     CONF_RECIPIENT,
     CONF_USERNAME,
@@ -29,8 +30,6 @@ BASE_API_URL = "https://rest.clicksend.com/v3"
 
 HEADERS = {"Content-Type": CONTENT_TYPE_JSON}
 
-# pylint: disable-next=home-assistant-duplicate-const
-CONF_LANGUAGE = "language"
 CONF_VOICE = "voice"
 
 MALE_VOICE = "male"

homeassistant/components/cloud/alexa_config.py

@@ -32,7 +32,6 @@ from homeassistant.components.homeassistant.exposed_entities import (
     async_should_expose,
 )
 from homeassistant.components.sensor import SensorDeviceClass
-from homeassistant.const import CLOUD_NEVER_EXPOSED_ENTITIES
 from homeassistant.core import Event, HomeAssistant, callback, split_entity_id
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import entity_registry as er, start
@@ -275,9 +274,6 @@ class CloudAlexaConfig(alexa_config.AbstractConfig):
 
     def _should_expose_legacy(self, entity_id: str) -> bool:
         """If an entity should be exposed."""
-        if entity_id in CLOUD_NEVER_EXPOSED_ENTITIES:
-            return False
-
         entity_configs = self._prefs.alexa_entity_configs
         entity_config = entity_configs.get(entity_id, {})
         entity_expose: bool | None = entity_config.get(PREF_SHOULD_EXPOSE)
@@ -308,8 +304,6 @@ class CloudAlexaConfig(alexa_config.AbstractConfig):
         """If an entity should be exposed."""
         entity_filter: EntityFilter = self._config[CONF_FILTER]
         if not entity_filter.empty_filter:
-            if entity_id in CLOUD_NEVER_EXPOSED_ENTITIES:
-                return False
             return entity_filter(entity_id)
 
         return async_should_expose(self.hass, CLOUD_ALEXA, entity_id)

homeassistant/components/cloud/google_config.py

@@ -22,7 +22,6 @@ from homeassistant.components.homeassistant.exposed_entities import (
     async_should_expose,
 )
 from homeassistant.components.sensor import SensorDeviceClass
-from homeassistant.const import CLOUD_NEVER_EXPOSED_ENTITIES
 from homeassistant.core import (
     CoreState,
     Event,
@@ -282,9 +281,6 @@ class CloudGoogleConfig(AbstractConfig):
 
     def _should_expose_legacy(self, entity_id: str) -> bool:
         """If an entity ID should be exposed."""
-        if entity_id in CLOUD_NEVER_EXPOSED_ENTITIES:
-            return False
-
         entity_configs = self._prefs.google_entity_configs
         entity_config = entity_configs.get(entity_id, {})
         entity_expose: bool | None = entity_config.get(PREF_SHOULD_EXPOSE)
@@ -316,8 +312,6 @@ class CloudGoogleConfig(AbstractConfig):
         """If an entity should be exposed."""
         entity_filter: EntityFilter = self._config[CONF_FILTER]
         if not entity_filter.empty_filter:
-            if entity_id in CLOUD_NEVER_EXPOSED_ENTITIES:
-                return False
             return entity_filter(entity_id)
 
         return async_should_expose(self.hass, CLOUD_GOOGLE, entity_id)

homeassistant/components/cloud/http_api.py

@@ -29,7 +29,6 @@ from homeassistant.components.homeassistant import exposed_entities
 from homeassistant.components.http import KEY_HASS, HomeAssistantView, require_admin
 from homeassistant.components.http.data_validator import RequestDataValidator
 from homeassistant.components.system_health import get_info as get_system_health_info
-from homeassistant.const import CLOUD_NEVER_EXPOSED_ENTITIES
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv
@@ -973,7 +972,7 @@ async def google_assistant_get(
         return
 
     entity = google_helpers.GoogleEntity(hass, gconf, state)
-    if entity_id in CLOUD_NEVER_EXPOSED_ENTITIES or not entity.is_supported():
+    if not entity.is_supported():
         connection.send_error(
             msg["id"],
             websocket_api.ERR_NOT_SUPPORTED,
@@ -1075,9 +1074,7 @@ async def alexa_get(
     """Get data for a single alexa entity."""
     entity_id: str = msg["entity_id"]
 
-    if entity_id in CLOUD_NEVER_EXPOSED_ENTITIES or not entity_supported_by_alexa(
-        hass, entity_id
-    ):
+    if not entity_supported_by_alexa(hass, entity_id):
         connection.send_error(
             msg["id"],
             websocket_api.ERR_NOT_SUPPORTED,

homeassistant/components/cloudflare_r2/backup.py

@@ -17,10 +17,11 @@ from homeassistant.components.backup import (
     OnProgressCallback,
     suggested_filename,
 )
+from homeassistant.const import CONF_PREFIX
 from homeassistant.core import HomeAssistant, callback
 
 from . import R2ConfigEntry
-from .const import CONF_BUCKET, CONF_PREFIX, DATA_BACKUP_AGENT_LISTENERS, DOMAIN
+from .const import CONF_BUCKET, DATA_BACKUP_AGENT_LISTENERS, DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 CACHE_TTL = 300

homeassistant/components/cloudflare_r2/config_flow.py

@@ -13,6 +13,7 @@ from botocore.exceptions import (
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_PREFIX
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.selector import (
     TextSelector,
@@ -25,7 +26,6 @@ from .const import (
     CONF_ACCESS_KEY_ID,
     CONF_BUCKET,
     CONF_ENDPOINT_URL,
-    CONF_PREFIX,
     CONF_SECRET_ACCESS_KEY,
     DEFAULT_ENDPOINT_URL,
     DESCRIPTION_R2_AUTH_DOCS_URL,

homeassistant/components/cloudflare_r2/const.py

@@ -11,8 +11,6 @@ CONF_ACCESS_KEY_ID = "access_key_id"
 CONF_SECRET_ACCESS_KEY = "secret_access_key"
 CONF_ENDPOINT_URL = "endpoint_url"
 CONF_BUCKET = "bucket"
-# pylint: disable-next=home-assistant-duplicate-const
-CONF_PREFIX = "prefix"
 
 # R2 is S3-compatible. Endpoint should be like:
 # https://<accountid>.r2.cloudflarestorage.com

homeassistant/components/color_extractor/const.py

@@ -5,6 +5,3 @@ ATTR_URL = "color_extract_url"
 
 DOMAIN = "color_extractor"
 DEFAULT_NAME = "Color extractor"
-
-# pylint: disable-next=home-assistant-duplicate-const
-SERVICE_TURN_ON = "turn_on"

homeassistant/components/color_extractor/services.py

@@ -14,11 +14,11 @@ from homeassistant.components.light import (
     DOMAIN as LIGHT_DOMAIN,
     LIGHT_TURN_ON_SCHEMA,
 )
-from homeassistant.const import SERVICE_TURN_ON as LIGHT_SERVICE_TURN_ON
+from homeassistant.const import SERVICE_TURN_ON
 from homeassistant.core import HomeAssistant, ServiceCall, callback
 from homeassistant.helpers import aiohttp_client, config_validation as cv
 
-from .const import ATTR_PATH, ATTR_URL, DOMAIN, SERVICE_TURN_ON
+from .const import ATTR_PATH, ATTR_URL, DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -141,7 +141,7 @@ async def async_handle_service(service_call: ServiceCall) -> None:
         service_data[ATTR_RGB_COLOR] = color
 
         await service_call.hass.services.async_call(
-            LIGHT_DOMAIN, LIGHT_SERVICE_TURN_ON, service_data, blocking=True
+            LIGHT_DOMAIN, SERVICE_TURN_ON, service_data, blocking=True
         )
 
 

homeassistant/components/cookidoo/__init__.py

@@ -42,6 +42,35 @@ async def async_unload_entry(hass: HomeAssistant, entry: CookidooConfigEntry) ->
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
 
 
+def _migrate_identifiers(
+    hass: HomeAssistant,
+    config_entry: CookidooConfigEntry,
+    old_prefix: str,
+    new_unique_id: str,
+) -> None:
+    """Migrate device identifiers and entity unique_ids from old to new prefix."""
+    device_registry = dr.async_get(hass)
+    entity_registry = er.async_get(hass)
+    device_entries = dr.async_entries_for_config_entry(
+        device_registry, config_entry_id=config_entry.entry_id
+    )
+    entity_entries = er.async_entries_for_config_entry(
+        entity_registry, config_entry_id=config_entry.entry_id
+    )
+    for dev in device_entries:
+        new_identifiers = {
+            (DOMAIN, new_unique_id) if domain == DOMAIN else (domain, identifier)
+            for domain, identifier in dev.identifiers
+        }
+        device_registry.async_update_device(dev.id, new_identifiers=new_identifiers)
+    for ent in entity_entries:
+        if ent.unique_id and ent.unique_id.startswith(f"{old_prefix}_"):
+            entity_registry.async_update_entity(
+                ent.entity_id,
+                new_unique_id=f"{new_unique_id}{ent.unique_id[len(old_prefix) :]}",
+            )
+
+
 async def async_migrate_entry(
     hass: HomeAssistant, config_entry: CookidooConfigEntry
 ) -> bool:
@@ -49,41 +78,37 @@ async def async_migrate_entry(
     _LOGGER.debug("Migrating from version %s", config_entry.version)
 
     if config_entry.version == 1 and config_entry.minor_version == 1:
-        # Add the unique uuid
+        # Add the unique uuid (first migration, entities used config_entry_id as prefix)
         cookidoo = await cookidoo_from_config_entry(hass, config_entry)
 
         try:
-            auth_data = await cookidoo.login()
+            await cookidoo.login()
+            user_info = await cookidoo.get_user_info()
         except (CookidooRequestException, CookidooAuthException) as e:
-            _LOGGER.error(
-                "Could not migrate config config_entry: %s",
-                str(e),
-            )
+            _LOGGER.error("Could not migrate config entry: %s", e)
             return False
 
-        unique_id = auth_data.sub
-
-        device_registry = dr.async_get(hass)
-        entity_registry = er.async_get(hass)
-        device_entries = dr.async_entries_for_config_entry(
-            device_registry, config_entry_id=config_entry.entry_id
-        )
-        entity_entries = er.async_entries_for_config_entry(
-            entity_registry, config_entry_id=config_entry.entry_id
-        )
-        for dev in device_entries:
-            device_registry.async_update_device(
-                dev.id, new_identifiers={(DOMAIN, unique_id)}
-            )
-        for ent in entity_entries:
-            assert ent.config_entry_id
-            entity_registry.async_update_entity(
-                ent.entity_id,
-                new_unique_id=ent.unique_id.replace(ent.config_entry_id, unique_id),
-            )
-
+        _migrate_identifiers(hass, config_entry, config_entry.entry_id, user_info.id)
         hass.config_entries.async_update_entry(
-            config_entry, unique_id=auth_data.sub, minor_version=2
+            config_entry, unique_id=user_info.id, minor_version=3
+        )
+
+    if config_entry.version == 1 and config_entry.minor_version == 2:
+        # Migrate unique_id from old CIAM sub to community profile id
+        cookidoo = await cookidoo_from_config_entry(hass, config_entry)
+
+        try:
+            await cookidoo.login()
+            user_info = await cookidoo.get_user_info()
+        except (CookidooRequestException, CookidooAuthException) as e:
+            _LOGGER.error("Could not migrate config entry: %s", e)
+            return False
+
+        old_unique_id = config_entry.unique_id
+        if old_unique_id:
+            _migrate_identifiers(hass, config_entry, old_unique_id, user_info.id)
+        hass.config_entries.async_update_entry(
+            config_entry, unique_id=user_info.id, minor_version=3
         )
 
     _LOGGER.debug(

homeassistant/components/cookidoo/calendar.py

@@ -3,7 +3,11 @@
 from datetime import date, datetime, timedelta
 import logging
 
-from cookidoo_api import CookidooAuthException, CookidooException
+from cookidoo_api import (
+    CookidooAuthException,
+    CookidooException,
+    CookidooRequestException,
+)
 from cookidoo_api.types import CookidooCalendarDayRecipe
 
 from homeassistant.components.calendar import CalendarEntity, CalendarEvent
@@ -74,7 +78,13 @@ class CookidooCalendarEntity(CookidooBaseEntity, CalendarEntity):
                 week_day
             )
         except CookidooAuthException:
-            await self.coordinator.cookidoo.refresh_token()
+            try:
+                await self.coordinator.cookidoo.login()
+            except (CookidooAuthException, CookidooRequestException) as exc:
+                raise HomeAssistantError(
+                    translation_domain=DOMAIN,
+                    translation_key="calendar_fetch_failed",
+                ) from exc
             return await self.coordinator.cookidoo.get_recipes_in_calendar_week(
                 week_day
             )

homeassistant/components/cookidoo/config_flow.py

@@ -54,7 +54,7 @@ class CookidooConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Cookidoo."""
 
     VERSION = 1
-    MINOR_VERSION = 2
+    MINOR_VERSION = 3
 
     COUNTRY_DATA_SCHEMA: dict
     LANGUAGE_DATA_SCHEMA: dict
@@ -223,8 +223,9 @@ class CookidooConfigFlow(ConfigFlow, domain=DOMAIN):
 
         cookidoo = await cookidoo_from_config_data(self.hass, data_input)
         try:
-            auth_data = await cookidoo.login()
-            self.user_uuid = auth_data.sub
+            await cookidoo.login()
+            user_info = await cookidoo.get_user_info()
+            self.user_uuid = user_info.id
             if language_input:
                 await cookidoo.get_additional_items()
         except CookidooRequestException:

homeassistant/components/cookidoo/coordinator.py

@@ -87,7 +87,7 @@ class CookidooDataUpdateCoordinator(DataUpdateCoordinator[CookidooData]):
             )
         except CookidooAuthException:
             try:
-                await self.cookidoo.refresh_token()
+                await self.cookidoo.login()
             except CookidooAuthException as exc:
                 raise ConfigEntryAuthFailed(
                     translation_domain=DOMAIN,
@@ -96,6 +96,11 @@ class CookidooDataUpdateCoordinator(DataUpdateCoordinator[CookidooData]):
                         CONF_EMAIL: self.config_entry.data[CONF_EMAIL]
                     },
                 ) from exc
+            except CookidooRequestException as exc:
+                raise UpdateFailed(
+                    translation_domain=DOMAIN,
+                    translation_key="setup_request_exception",
+                ) from exc
             _LOGGER.debug(
                 "Authentication failed but re-authentication"
                 " was successful, trying again later"

homeassistant/components/cookidoo/helpers.py

@@ -2,11 +2,12 @@
 
 from typing import Any
 
+from aiohttp import CookieJar
 from cookidoo_api import Cookidoo, CookidooConfig, get_localization_options
 
 from homeassistant.const import CONF_COUNTRY, CONF_EMAIL, CONF_LANGUAGE, CONF_PASSWORD
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.aiohttp_client import async_create_clientsession
 
 from .coordinator import CookidooConfigEntry
 
@@ -21,7 +22,7 @@ async def cookidoo_from_config_data(
     )
 
     return Cookidoo(
-        async_get_clientsession(hass),
+        async_create_clientsession(hass, cookie_jar=CookieJar(unsafe=True)),
         CookidooConfig(
             email=data[CONF_EMAIL],
             password=data[CONF_PASSWORD],

homeassistant/components/cookidoo/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["cookidoo_api"],
   "quality_scale": "silver",
-  "requirements": ["cookidoo-api==0.14.0"]
+  "requirements": ["cookidoo-api==0.17.2"]
 }

homeassistant/components/dhcp/manifest.json

@@ -15,7 +15,7 @@
   ],
   "quality_scale": "internal",
   "requirements": [
-    "aiodhcpwatcher==1.2.1",
+    "aiodhcpwatcher==1.2.6",
     "aiodiscover==3.2.3",
     "cached-ipaddress==1.0.1"
   ]

homeassistant/components/drop_connect/config_flow.py

@@ -6,13 +6,13 @@ from typing import TYPE_CHECKING, Any
 from dropmqttapi.discovery import DropDiscovery
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_DEVICE_ID
 from homeassistant.helpers.service_info.mqtt import MqttServiceInfo
 
 from .const import (
     CONF_COMMAND_TOPIC,
     CONF_DATA_TOPIC,
     CONF_DEVICE_DESC,
-    CONF_DEVICE_ID,
     CONF_DEVICE_NAME,
     CONF_DEVICE_OWNER_ID,
     CONF_DEVICE_TYPE,

homeassistant/components/drop_connect/const.py

@@ -4,8 +4,6 @@
 CONF_COMMAND_TOPIC = "drop_command_topic"
 CONF_DATA_TOPIC = "drop_data_topic"
 CONF_DEVICE_DESC = "device_desc"
-# pylint: disable-next=home-assistant-duplicate-const
-CONF_DEVICE_ID = "device_id"
 CONF_DEVICE_TYPE = "device_type"
 CONF_HUB_ID = "drop_hub_id"
 CONF_DEVICE_NAME = "name"

homeassistant/components/drop_connect/sensor.py

@@ -13,6 +13,7 @@ from homeassistant.components.sensor import (
 from homeassistant.const import (
     CONCENTRATION_PARTS_PER_MILLION,
     PERCENTAGE,
+    TEMPERATURE,
     EntityCategory,
     UnitOfPressure,
     UnitOfTemperature,
@@ -49,8 +50,6 @@ CURRENT_SYSTEM_PRESSURE = "current_system_pressure"
 HIGH_SYSTEM_PRESSURE = "high_system_pressure"
 LOW_SYSTEM_PRESSURE = "low_system_pressure"
 BATTERY = "battery"
-# pylint: disable-next=home-assistant-duplicate-const
-TEMPERATURE = "temperature"
 INLET_TDS = "inlet_tds"
 OUTLET_TDS = "outlet_tds"
 CARTRIDGE_1_LIFE = "cart1"

homeassistant/components/elevenlabs/__init__.py

@@ -8,7 +8,7 @@ from elevenlabs.core import ApiError
 from httpx import ConnectError
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_API_KEY, Platform
+from homeassistant.const import CONF_API_KEY, CONF_MODEL, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import (
     ConfigEntryAuthFailed,
@@ -17,7 +17,7 @@ from homeassistant.exceptions import (
 )
 from homeassistant.helpers.httpx_client import get_async_client
 
-from .const import CONF_MODEL, CONF_STT_MODEL
+from .const import CONF_STT_MODEL
 
 _LOGGER = logging.getLogger(__name__)
 

homeassistant/components/elevenlabs/config_flow.py

@@ -8,7 +8,7 @@ from elevenlabs.core import ApiError
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult, OptionsFlow
-from homeassistant.const import CONF_API_KEY
+from homeassistant.const import CONF_API_KEY, CONF_MODEL
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.httpx_client import get_async_client
 from homeassistant.helpers.selector import (
@@ -20,7 +20,6 @@ from homeassistant.helpers.selector import (
 from . import ElevenLabsConfigEntry
 from .const import (
     CONF_CONFIGURE_VOICE,
-    CONF_MODEL,
     CONF_SIMILARITY,
     CONF_STABILITY,
     CONF_STT_AUTO_LANGUAGE,

homeassistant/components/elevenlabs/const.py

@@ -1,11 +1,6 @@
 """Constants for the ElevenLabs text-to-speech integration."""
 
-# pylint: disable-next=home-assistant-duplicate-const
-ATTR_MODEL = "model"
-
 CONF_VOICE = "voice"
-# pylint: disable-next=home-assistant-duplicate-const
-CONF_MODEL = "model"
 CONF_CONFIGURE_VOICE = "configure_voice"
 CONF_STABILITY = "stability"
 CONF_SIMILARITY = "similarity"

homeassistant/components/elevenlabs/tts.py

@@ -20,7 +20,7 @@ from homeassistant.components.tts import (
     TtsAudioType,
     Voice,
 )
-from homeassistant.const import EntityCategory
+from homeassistant.const import ATTR_MODEL, EntityCategory
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
@@ -28,7 +28,6 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import ElevenLabsConfigEntry
 from .const import (
-    ATTR_MODEL,
     CONF_SIMILARITY,
     CONF_STABILITY,
     CONF_STYLE,

homeassistant/components/energyid/__init__.py

@@ -10,7 +10,7 @@ from aiohttp import ClientError, ClientResponseError
 from energyid_webhooks.client_v2 import WebhookClient
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import STATE_UNAVAILABLE, STATE_UNKNOWN
+from homeassistant.const import CONF_DEVICE_ID, STATE_UNAVAILABLE, STATE_UNKNOWN
 from homeassistant.core import (
     CALLBACK_TYPE,
     Event,
@@ -28,7 +28,6 @@ from homeassistant.helpers.event import (
 )
 
 from .const import (
-    CONF_DEVICE_ID,
     CONF_DEVICE_NAME,
     CONF_ENERGYID_KEY,
     CONF_HA_ENTITY_UUID,

homeassistant/components/energyid/config_flow.py

@@ -15,13 +15,13 @@ from homeassistant.config_entries import (
     ConfigFlowResult,
     ConfigSubentryFlow,
 )
+from homeassistant.const import CONF_DEVICE_ID
 from homeassistant.core import callback
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.instance_id import async_get as async_get_instance_id
 
 from .const import (
-    CONF_DEVICE_ID,
     CONF_DEVICE_NAME,
     CONF_PROVISIONING_KEY,
     CONF_PROVISIONING_SECRET,

homeassistant/components/energyid/const.py

@@ -8,8 +8,6 @@ NAME: Final = "EnergyID"
 # --- Config Flow and Entry Data ---
 CONF_PROVISIONING_KEY: Final = "provisioning_key"
 CONF_PROVISIONING_SECRET: Final = "provisioning_secret"
-# pylint: disable-next=home-assistant-duplicate-const
-CONF_DEVICE_ID: Final = "device_id"
 CONF_DEVICE_NAME: Final = "device_name"
 
 # --- Subentry (Mapping) Data ---

homeassistant/components/esphome/alarm_control_panel.py

@@ -4,10 +4,10 @@ from functools import partial
 
 from aioesphomeapi import (
     AlarmControlPanelCommand,
+    AlarmControlPanelEntityFeature as ESPHomeAlarmControlPanelEntityFeature,
     AlarmControlPanelEntityState as ESPHomeAlarmControlPanelEntityState,
     AlarmControlPanelInfo,
     AlarmControlPanelState as ESPHomeAlarmControlPanelState,
-    APIIntEnum,
     EntityInfo,
 )
 
@@ -50,16 +50,28 @@ _ESPHOME_ACP_STATE_TO_HASS_STATE: EsphomeEnumMapper[
     }
 )
 
-
-class EspHomeACPFeatures(APIIntEnum):
-    """ESPHome AlarmControlPanel feature numbers."""
-
-    ARM_HOME = 1
-    ARM_AWAY = 2
-    ARM_NIGHT = 4
-    TRIGGER = 8
-    ARM_CUSTOM_BYPASS = 16
-    ARM_VACATION = 32
+_FEATURES: dict[
+    ESPHomeAlarmControlPanelEntityFeature, AlarmControlPanelEntityFeature
+] = {
+    ESPHomeAlarmControlPanelEntityFeature.ARM_HOME: (
+        AlarmControlPanelEntityFeature.ARM_HOME
+    ),
+    ESPHomeAlarmControlPanelEntityFeature.ARM_AWAY: (
+        AlarmControlPanelEntityFeature.ARM_AWAY
+    ),
+    ESPHomeAlarmControlPanelEntityFeature.ARM_NIGHT: (
+        AlarmControlPanelEntityFeature.ARM_NIGHT
+    ),
+    ESPHomeAlarmControlPanelEntityFeature.TRIGGER: (
+        AlarmControlPanelEntityFeature.TRIGGER
+    ),
+    ESPHomeAlarmControlPanelEntityFeature.ARM_CUSTOM_BYPASS: (
+        AlarmControlPanelEntityFeature.ARM_CUSTOM_BYPASS
+    ),
+    ESPHomeAlarmControlPanelEntityFeature.ARM_VACATION: (
+        AlarmControlPanelEntityFeature.ARM_VACATION
+    ),
+}
 
 
 class EsphomeAlarmControlPanel(
@@ -73,20 +85,14 @@ class EsphomeAlarmControlPanel(
         """Set attrs from static info."""
         super()._on_static_info_update(static_info)
         static_info = self._static_info
-        feature = 0
-        if static_info.supported_features & EspHomeACPFeatures.ARM_HOME:
-            feature |= AlarmControlPanelEntityFeature.ARM_HOME
-        if static_info.supported_features & EspHomeACPFeatures.ARM_AWAY:
-            feature |= AlarmControlPanelEntityFeature.ARM_AWAY
-        if static_info.supported_features & EspHomeACPFeatures.ARM_NIGHT:
-            feature |= AlarmControlPanelEntityFeature.ARM_NIGHT
-        if static_info.supported_features & EspHomeACPFeatures.TRIGGER:
-            feature |= AlarmControlPanelEntityFeature.TRIGGER
-        if static_info.supported_features & EspHomeACPFeatures.ARM_CUSTOM_BYPASS:
-            feature |= AlarmControlPanelEntityFeature.ARM_CUSTOM_BYPASS
-        if static_info.supported_features & EspHomeACPFeatures.ARM_VACATION:
-            feature |= AlarmControlPanelEntityFeature.ARM_VACATION
-        self._attr_supported_features = AlarmControlPanelEntityFeature(feature)
+        esp_flags = ESPHomeAlarmControlPanelEntityFeature(
+            static_info.supported_features
+        )
+        flags = AlarmControlPanelEntityFeature(0)
+        for esp_flag in esp_flags:
+            if (flag := _FEATURES.get(esp_flag)) is not None:
+                flags |= flag
+        self._attr_supported_features = flags
         self._attr_code_format = (
             CodeFormat.NUMBER if static_info.requires_code else None
         )

homeassistant/components/esphome/bluetooth.py

@@ -1,16 +1,33 @@
 """Bluetooth support for esphome."""
 
 from functools import partial
+import logging
 from typing import TYPE_CHECKING
 
-from aioesphomeapi import APIClient, DeviceInfo
+from aioesphomeapi import (
+    APIClient,
+    APIVersion,
+    BluetoothProxyFeature,
+    BluetoothScannerMode,
+    BluetoothScannerStateResponse,
+    DeviceInfo,
+)
 from bleak_esphome import connect_scanner
 
-from homeassistant.components.bluetooth import async_register_scanner
+from homeassistant.components.bluetooth import (
+    BluetoothScanningMode,
+    async_register_scanner,
+)
 from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback as hass_callback
 
-from .const import DOMAIN
-from .entry_data import RuntimeEntryData
+from .const import CONF_BLUETOOTH_SCANNING_MODE, DEFAULT_BLUETOOTH_SCANNING_MODE, DOMAIN
+from .entry_data import ESPHomeConfigEntry, RuntimeEntryData
+
+if TYPE_CHECKING:
+    from bleak_esphome.backend.scanner import ESPHomeScanner
+
+_LOGGER = logging.getLogger(__name__)
+_VALID_SCANNING_MODES = {mode.value for mode in BluetoothScanningMode}
 
 
 @hass_callback
@@ -23,6 +40,7 @@ def _async_unload(unload_callbacks: list[CALLBACK_TYPE]) -> None:
 @hass_callback
 def async_connect_scanner(
     hass: HomeAssistant,
+    entry: ESPHomeConfigEntry,
     entry_data: RuntimeEntryData,
     cli: APIClient,
     device_info: DeviceInfo,
@@ -35,17 +53,75 @@ def async_connect_scanner(
     scanner = client_data.scanner
     if TYPE_CHECKING:
         assert scanner is not None
-    return partial(
-        _async_unload,
-        [
-            async_register_scanner(
-                hass,
-                scanner,
-                source_domain=DOMAIN,
-                source_model=device_info.model,
-                source_config_entry_id=entry_data.entry_id,
-                source_device_id=device_id,
-            ),
-            scanner.async_setup(),
-        ],
-    )
+    api_version = cli.api_version or APIVersion()
+    feature_flags = device_info.bluetooth_proxy_feature_flags_compat(api_version)
+    state_and_mode = bool(feature_flags & BluetoothProxyFeature.FEATURE_STATE_AND_MODE)
+    # Pin mode before async_register_scanner so habluetooth spawns the AUTO worker.
+    deferred_migration: CALLBACK_TYPE | None = None
+    if state_and_mode:
+        deferred_migration = _async_apply_scanning_mode(hass, entry, scanner, cli)
+    callbacks: list[CALLBACK_TYPE] = [
+        async_register_scanner(
+            hass,
+            scanner,
+            source_domain=DOMAIN,
+            source_model=device_info.model,
+            source_config_entry_id=entry_data.entry_id,
+            source_device_id=device_id,
+        ),
+        scanner.async_setup(),
+    ]
+    if deferred_migration is not None:
+        callbacks.append(deferred_migration)
+    return partial(_async_unload, callbacks)
+
+
+@hass_callback
+def _async_apply_scanning_mode(
+    hass: HomeAssistant,
+    entry: ESPHomeConfigEntry,
+    scanner: ESPHomeScanner,
+    cli: APIClient,
+) -> CALLBACK_TYPE | None:
+    """Apply saved scanning mode synchronously; migrate from configured_mode later."""
+    saved = entry.options.get(CONF_BLUETOOTH_SCANNING_MODE)
+    if saved is not None and saved not in _VALID_SCANNING_MODES:
+        _LOGGER.warning("%s: unknown scanning mode %r", entry.title, saved)
+        saved = None
+    initial_value = saved if saved is not None else DEFAULT_BLUETOOTH_SCANNING_MODE
+    scanner.async_set_scanning_mode(BluetoothScanningMode(initial_value))
+    if saved is not None:
+        return None
+
+    unsub_holder: list[CALLBACK_TYPE] = []
+
+    @hass_callback
+    def _migrate(state: BluetoothScannerStateResponse) -> None:
+        # proto3 unset enums decode to None; wait for a real value.
+        if (configured_pb := state.configured_mode) is None:
+            return
+        if unsub_holder:
+            unsub_holder.pop()()
+        if configured_pb is BluetoothScannerMode.PASSIVE:
+            new_mode = BluetoothScanningMode.PASSIVE
+        else:
+            new_mode = BluetoothScanningMode(DEFAULT_BLUETOOTH_SCANNING_MODE)
+        hass.config_entries.async_update_entry(
+            entry,
+            options={
+                **entry.options,
+                CONF_BLUETOOTH_SCANNING_MODE: new_mode.value,
+            },
+        )
+        # AUTO -> AUTO is already pinned; only re-apply on a downgrade.
+        if new_mode is not BluetoothScanningMode(DEFAULT_BLUETOOTH_SCANNING_MODE):
+            scanner.async_set_scanning_mode(new_mode)
+
+    unsub_holder.append(cli.subscribe_bluetooth_scanner_state(_migrate))
+
+    @hass_callback
+    def _unsubscribe() -> None:
+        if unsub_holder:
+            unsub_holder.pop()()
+
+    return _unsubscribe

homeassistant/components/esphome/config_flow.py

@@ -9,6 +9,7 @@ from typing import Any, cast
 from aioesphomeapi import (
     APIClient,
     APIConnectionError,
+    BluetoothProxyFeature,
     DeviceInfo,
     InvalidAuthAPIError,
     InvalidEncryptionKeyAPIError,
@@ -20,6 +21,7 @@ import aiohttp
 import voluptuous as vol
 
 from homeassistant.components import zeroconf
+from homeassistant.components.bluetooth import BluetoothScanningMode
 from homeassistant.config_entries import (
     SOURCE_ESPHOME,
     SOURCE_IGNORE,
@@ -38,6 +40,11 @@ from homeassistant.data_entry_flow import AbortFlow, FlowResultType
 from homeassistant.helpers import discovery_flow
 from homeassistant.helpers.device_registry import format_mac
 from homeassistant.helpers.importlib import async_import_module
+from homeassistant.helpers.selector import (
+    SelectSelector,
+    SelectSelectorConfig,
+    SelectSelectorMode,
+)
 from homeassistant.helpers.service_info.dhcp import DhcpServiceInfo
 from homeassistant.helpers.service_info.esphome import ESPHomeServiceInfo
 from homeassistant.helpers.service_info.hassio import HassioServiceInfo
@@ -47,10 +54,12 @@ from homeassistant.util.json import json_loads_object
 
 from .const import (
     CONF_ALLOW_SERVICE_CALLS,
+    CONF_BLUETOOTH_SCANNING_MODE,
     CONF_DEVICE_NAME,
     CONF_NOISE_PSK,
     CONF_SUBSCRIBE_LOGS,
     DEFAULT_ALLOW_SERVICE_CALLS,
+    DEFAULT_BLUETOOTH_SCANNING_MODE,
     DEFAULT_NEW_CONFIG_ALLOW_ALLOW_SERVICE_CALLS,
     DEFAULT_PORT,
     DOMAIN,
@@ -68,6 +77,18 @@ _LOGGER = logging.getLogger(__name__)
 ZERO_NOISE_PSK = "MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDA="
 DEFAULT_NAME = "ESPHome"
 
+_BLUETOOTH_SCANNING_MODE_SELECTOR = SelectSelector(
+    SelectSelectorConfig(
+        options=[
+            BluetoothScanningMode.AUTO.value,
+            BluetoothScanningMode.ACTIVE.value,
+            BluetoothScanningMode.PASSIVE.value,
+        ],
+        translation_key="bluetooth_scanning_mode",
+        mode=SelectSelectorMode.DROPDOWN,
+    )
+)
+
 
 class EsphomeFlowHandler(ConfigFlow, domain=DOMAIN):
     """Handle a esphome config flow."""
@@ -936,18 +957,44 @@ class OptionsFlowHandler(OptionsFlowWithReload):
         if user_input is not None:
             return self.async_create_entry(title="", data=user_input)
 
-        data_schema = vol.Schema(
-            {
+        options = self.config_entry.options
+        schema: dict[Any, Any] = {
+            vol.Required(
+                CONF_ALLOW_SERVICE_CALLS,
+                default=options.get(
+                    CONF_ALLOW_SERVICE_CALLS, DEFAULT_ALLOW_SERVICE_CALLS
+                ),
+            ): bool,
+            vol.Required(
+                CONF_SUBSCRIBE_LOGS,
+                default=options.get(CONF_SUBSCRIBE_LOGS, False),
+            ): bool,
+        }
+        if _entry_has_bluetooth_scanner(self.config_entry):
+            schema[
                 vol.Required(
-                    CONF_ALLOW_SERVICE_CALLS,
-                    default=self.config_entry.options.get(
-                        CONF_ALLOW_SERVICE_CALLS, DEFAULT_ALLOW_SERVICE_CALLS
+                    CONF_BLUETOOTH_SCANNING_MODE,
+                    default=options.get(
+                        CONF_BLUETOOTH_SCANNING_MODE, DEFAULT_BLUETOOTH_SCANNING_MODE
                     ),
-                ): bool,
-                vol.Required(
-                    CONF_SUBSCRIBE_LOGS,
-                    default=self.config_entry.options.get(CONF_SUBSCRIBE_LOGS, False),
-                ): bool,
-            }
+                )
+            ] = _BLUETOOTH_SCANNING_MODE_SELECTOR
+        return self.async_show_form(step_id="init", data_schema=vol.Schema(schema))
+
+
+@callback
+def _entry_has_bluetooth_scanner(entry: ESPHomeConfigEntry) -> bool:
+    """Return True if the entry exposes a bluetooth proxy scanner or has one saved."""
+    # Keep showing the option if it was previously saved, even when the
+    # device is offline or stops advertising the feature flag, so the
+    # saved value isn't silently dropped on the next options save.
+    if CONF_BLUETOOTH_SCANNING_MODE in entry.options:
+        return True
+    if entry.state is ConfigEntryState.LOADED and (
+        device_info := entry.runtime_data.device_info
+    ):
+        flags = device_info.bluetooth_proxy_feature_flags_compat(
+            entry.runtime_data.api_version
         )
-        return self.async_show_form(step_id="init", data_schema=data_schema)
+        return bool(flags & BluetoothProxyFeature.FEATURE_STATE_AND_MODE)
+    return False

homeassistant/components/esphome/const.py

@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING, Final
 
 from awesomeversion import AwesomeVersion
 
+from homeassistant.components.bluetooth import BluetoothScanningMode
 from homeassistant.util.hass_dict import HassKey
 
 if TYPE_CHECKING:
@@ -18,9 +19,11 @@ CONF_SUBSCRIBE_LOGS = "subscribe_logs"
 CONF_DEVICE_NAME = "device_name"
 CONF_NOISE_PSK = "noise_psk"
 CONF_BLUETOOTH_MAC_ADDRESS = "bluetooth_mac_address"
+CONF_BLUETOOTH_SCANNING_MODE = "bluetooth_scanning_mode"
 
 DEFAULT_ALLOW_SERVICE_CALLS = True
 DEFAULT_NEW_CONFIG_ALLOW_ALLOW_SERVICE_CALLS = False
+DEFAULT_BLUETOOTH_SCANNING_MODE = BluetoothScanningMode.AUTO.value
 
 DEFAULT_PORT: Final = 6053
 

homeassistant/components/esphome/manager.py

@@ -669,7 +669,7 @@ class ESPHomeManager:
         if device_info.bluetooth_proxy_feature_flags_compat(api_version):
             entry_data.disconnect_callbacks.add(
                 async_connect_scanner(
-                    hass, entry_data, cli, device_info, self.device_id
+                    hass, self.entry, entry_data, cli, device_info, self.device_id
                 )
             )
         else:

homeassistant/components/esphome/manifest.json

@@ -17,9 +17,9 @@
   "mqtt": ["esphome/discover/#"],
   "quality_scale": "platinum",
   "requirements": [
-    "aioesphomeapi==45.0.4",
+    "aioesphomeapi==45.2.2",
     "esphome-dashboard-api==1.3.0",
-    "bleak-esphome==3.7.3"
+    "bleak-esphome==3.9.1"
   ],
   "zeroconf": ["_esphomelib._tcp.local."]
 }

homeassistant/components/esphome/strings.json

@@ -209,13 +209,24 @@
       "init": {
         "data": {
           "allow_service_calls": "Allow the device to perform Home Assistant actions.",
+          "bluetooth_scanning_mode": "Bluetooth scanning mode",
           "subscribe_logs": "Subscribe to logs from the device."
         },
         "data_description": {
           "allow_service_calls": "When enabled, ESPHome devices can perform Home Assistant actions or send events. Only enable this if you trust the device.",
+          "bluetooth_scanning_mode": "Auto is recommended for most setups. It saves battery on your Bluetooth devices while still catching new devices and updates quickly.",
           "subscribe_logs": "When enabled, the device will send logs to Home Assistant and you can view them in the logs panel."
         }
       }
     }
+  },
+  "selector": {
+    "bluetooth_scanning_mode": {
+      "options": {
+        "active": "Active (uses more device battery, fastest updates)",
+        "auto": "Auto (recommended, saves device battery)",
+        "passive": "Passive (lowest device battery use, some details may be missing)"
+      }
+    }
   }
 }

homeassistant/components/eufylife_ble/config_flow.py

@@ -5,6 +5,7 @@ from typing import Any
 from eufylife_ble_client import MODEL_TO_NAME
 import voluptuous as vol
 
+from homeassistant.components import bluetooth
 from homeassistant.components.bluetooth import (
     BluetoothServiceInfoBleak,
     async_discovered_service_info,
@@ -75,6 +76,7 @@ class EufyLifeConfigFlow(ConfigFlow, domain=DOMAIN):
                 data={CONF_MODEL: model},
             )
 
+        await bluetooth.async_request_active_scan(self.hass)
         current_addresses = self._async_current_ids(include_ignore=False)
         for discovery_info in async_discovered_service_info(self.hass, False):
             address = discovery_info.address

homeassistant/components/fireservicerota/coordinator.py

@@ -2,6 +2,7 @@
 
 from datetime import timedelta
 import logging
+from typing import Any
 
 from pyfireservicerota import (
     ExpiredTokenError,
@@ -177,10 +178,12 @@ class FireServiceRotaClient:
 
             if await self.oauth.async_refresh_tokens():
                 self.token_refresh_failure = False
-                await self._hass.async_add_executor_job(self.websocket.start_listener)
 
-                # pylint: disable-next=home-assistant-sequential-executor-jobs
-                return await self._hass.async_add_executor_job(func, *args)
+                def _restart_and_call() -> Any:
+                    self.websocket.start_listener()
+                    return func(*args)
+
+                return await self._hass.async_add_executor_job(_restart_and_call)
 
     async def async_update(self) -> dict | None:
         """Get the latest availability data."""

homeassistant/components/fish_audio/__init__.py

@@ -5,11 +5,10 @@ import logging
 from fishaudio import AsyncFishAudio
 from fishaudio.exceptions import AuthenticationError, FishAudioError
 
-from homeassistant.const import Platform
+from homeassistant.const import CONF_API_KEY, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 
-from .const import CONF_API_KEY
 from .types import FishAudioConfigEntry
 
 _LOGGER = logging.getLogger(__name__)

homeassistant/components/fish_audio/config_flow.py

@@ -16,6 +16,7 @@ from homeassistant.config_entries import (
     ConfigSubentryFlow,
     SubentryFlowResult,
 )
+from homeassistant.const import CONF_API_KEY, CONF_LANGUAGE, CONF_NAME
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.selector import (
     LanguageSelector,
@@ -29,11 +30,8 @@ from homeassistant.helpers.selector import (
 from .const import (
     API_KEYS_URL,
     BACKEND_MODELS,
-    CONF_API_KEY,
     CONF_BACKEND,
-    CONF_LANGUAGE,
     CONF_LATENCY,
-    CONF_NAME,
     CONF_SELF_ONLY,
     CONF_SORT_BY,
     CONF_TITLE,

homeassistant/components/fish_audio/const.py

@@ -4,17 +4,10 @@ from typing import Literal
 
 DOMAIN = "fish_audio"
 
-
-# pylint: disable-next=home-assistant-duplicate-const
-CONF_NAME: Literal["name"] = "name"
 CONF_USER_ID: Literal["user_id"] = "user_id"
-# pylint: disable-next=home-assistant-duplicate-const
-CONF_API_KEY: Literal["api_key"] = "api_key"
 CONF_VOICE_ID: Literal["voice_id"] = "voice_id"
 CONF_BACKEND: Literal["backend"] = "backend"
 CONF_SELF_ONLY: Literal["self_only"] = "self_only"
-# pylint: disable-next=home-assistant-duplicate-const
-CONF_LANGUAGE: Literal["language"] = "language"
 CONF_SORT_BY: Literal["sort_by"] = "sort_by"
 CONF_LATENCY: Literal["latency"] = "latency"
 CONF_TITLE: Literal["title"] = "title"

homeassistant/components/fitbit/const.py

@@ -13,8 +13,6 @@ ATTR_LAST_SAVED_AT: Final = "last_saved_at"
 
 ATTR_DURATION: Final = "duration"
 ATTR_DISTANCE: Final = "distance"
-# pylint: disable-next=home-assistant-duplicate-const
-ATTR_ELEVATION: Final = "elevation"
 ATTR_HEIGHT: Final = "height"
 ATTR_WEIGHT: Final = "weight"
 ATTR_BODY: Final = "body"

homeassistant/components/fritz/entity.py

@@ -53,6 +53,8 @@ class FritzDeviceBase(CoordinatorEntity[AvmWrapper]):
 class FritzBoxBaseEntity:
     """Fritz host entity base class."""
 
+    _attr_has_entity_name = True
+
     def __init__(self, avm_wrapper: AvmWrapper, device_name: str) -> None:
         """Init device info class."""
         self._avm_wrapper = avm_wrapper

homeassistant/components/fritz/image.py

@@ -76,7 +76,6 @@ class FritzGuestWifiQRImage(FritzBoxBaseEntity, ImageEntity):
 
     _attr_content_type = "image/png"
     _attr_entity_category = EntityCategory.DIAGNOSTIC
-    _attr_has_entity_name = True
     _attr_should_poll = True
 
     def __init__(

homeassistant/components/fritz/models.py

@@ -170,7 +170,6 @@ class SwitchInfo(TypedDict):
     """FRITZ!Box switch info class."""
 
     description: str
-    friendly_name: str
     icon: str
     type: str
     callback_update: Callable

homeassistant/components/fritz/switch.py

@@ -380,44 +380,18 @@ class FritzBoxBaseSwitch(FritzBoxBaseEntity, SwitchEntity):
         """Init Fritzbox base switch."""
         super().__init__(avm_wrapper, device_friendly_name)
 
-        self._description = switch_info["description"]
-        self._friendly_name = switch_info["friendly_name"]
-        self._icon = switch_info["icon"]
+        description = switch_info["description"]
+
         self._type = switch_info["type"]
         self._update = switch_info["callback_update"]
         self._switch = switch_info["callback_switch"]
+
+        self._attr_icon = switch_info["icon"]
         self._attr_is_on = switch_info["init_state"]
-
-        self._name = f"{self._friendly_name} {self._description}"
-        self._unique_id = f"{self._avm_wrapper.unique_id}-{slugify(self._description)}"
-
-        self._attributes: dict[str, str | None] = {}
-        self._is_available = True
-
-    @property
-    def name(self) -> str:
-        """Return name."""
-        return self._name
-
-    @property
-    def icon(self) -> str:
-        """Return icon."""
-        return self._icon
-
-    @property
-    def unique_id(self) -> str:
-        """Return unique id."""
-        return self._unique_id
-
-    @property
-    def available(self) -> bool:
-        """Return availability."""
-        return self._is_available
-
-    @property
-    def extra_state_attributes(self) -> dict[str, str | None]:
-        """Return device attributes."""
-        return self._attributes
+        self._attr_name = description
+        self._attr_unique_id = f"{self._avm_wrapper.unique_id}-{slugify(description)}"
+        self._attr_extra_state_attributes: dict[str, Any | None] = {}
+        self._attr_available = True
 
     async def async_update(self) -> None:
         """Update data."""
@@ -438,7 +412,6 @@ class FritzBoxBaseSwitch(FritzBoxBaseEntity, SwitchEntity):
         self._attr_is_on = turn_on
 
 
-# pylint: disable-next=home-assistant-missing-has-entity-name
 class FritzBoxPortSwitch(FritzBoxBaseSwitch):
     """Defines a FRITZ!Box Tools PortForward switch."""
 
@@ -452,9 +425,6 @@ class FritzBoxPortSwitch(FritzBoxBaseSwitch):
         connection_type: str,
     ) -> None:
         """Init Fritzbox port switch."""
-        self._avm_wrapper = avm_wrapper
-
-        self._attributes = {}
         self.connection_type = connection_type
         # dict in the format as it comes from fritzconnection,
         # eg: {"NewRemoteHost": "0.0.0.0", "NewExternalPort": 22, ...}
@@ -464,7 +434,6 @@ class FritzBoxPortSwitch(FritzBoxBaseSwitch):
 
         switch_info = SwitchInfo(
             description=f"Port forward {port_name}",
-            friendly_name=device_friendly_name,
             icon="mdi:check-network",
             type=SWITCH_TYPE_PORTFORWARD,
             callback_update=self._async_fetch_update,
@@ -483,11 +452,11 @@ class FritzBoxPortSwitch(FritzBoxBaseSwitch):
             "Specific %s response: %s", SWITCH_TYPE_PORTFORWARD, self.port_mapping
         )
         if not self.port_mapping:
-            self._is_available = False
+            self._attr_available = False
             return
 
         self._attr_is_on = self.port_mapping["NewEnabled"] is True
-        self._is_available = True
+        self._attr_available = True
 
         attributes_dict = {
             "NewInternalClient": "internal_ip",
@@ -498,7 +467,7 @@ class FritzBoxPortSwitch(FritzBoxBaseSwitch):
         }
 
         for key, attr in attributes_dict.items():
-            self._attributes[attr] = self.port_mapping[key]
+            self._attr_extra_state_attributes[attr] = self.port_mapping[key]
 
     async def _async_switch_on_off_executor(self, turn_on: bool) -> None:
         self.port_mapping["NewEnabled"] = "1" if turn_on else "0"
@@ -605,7 +574,6 @@ class FritzBoxProfileSwitch(FritzBoxBaseCoordinatorSwitch):
         self.async_write_ha_state()
 
 
-# pylint: disable-next=home-assistant-missing-has-entity-name
 class FritzBoxWifiSwitch(FritzBoxBaseSwitch):
     """Defines a FRITZ!Box Tools Wifi switch."""
 
@@ -617,10 +585,8 @@ class FritzBoxWifiSwitch(FritzBoxBaseSwitch):
         network_data: dict[str, Any],
     ) -> None:
         """Init Fritz Wifi switch."""
-        self._avm_wrapper = avm_wrapper
         self._wifi_info = network_data
 
-        self._attributes = {}
         self._attr_entity_category = EntityCategory.CONFIG
         self._attr_entity_registry_enabled_default = (
             avm_wrapper.mesh_role is not MeshRoles.SLAVE
@@ -632,14 +598,13 @@ class FritzBoxWifiSwitch(FritzBoxBaseSwitch):
 
         switch_info = SwitchInfo(
             description=description,
-            friendly_name=device_friendly_name,
             icon="mdi:wifi",
             type=SWITCH_TYPE_WIFINETWORK,
             callback_update=self._async_fetch_update,
             callback_switch=self._async_switch_on_off_executor,
             init_state=network_data["NewEnable"],
         )
-        super().__init__(self._avm_wrapper, device_friendly_name, switch_info)
+        super().__init__(avm_wrapper, device_friendly_name, switch_info)
 
     async def _async_fetch_update(self) -> None:
         """Fetch updates."""
@@ -652,16 +617,16 @@ class FritzBoxWifiSwitch(FritzBoxBaseSwitch):
         )
 
         if not wifi_info:
-            self._is_available = False
+            self._attr_available = False
             return
 
         self._attr_is_on = wifi_info["NewEnable"] is True
-        self._is_available = True
+        self._attr_available = True
 
         std = wifi_info["NewStandard"]
-        self._attributes["standard"] = std or None
-        self._attributes["bssid"] = wifi_info["NewBSSID"]
-        self._attributes["mac_address_control"] = wifi_info[
+        self._attr_extra_state_attributes["standard"] = std or None
+        self._attr_extra_state_attributes["bssid"] = wifi_info["NewBSSID"]
+        self._attr_extra_state_attributes["mac_address_control"] = wifi_info[
             "NewMACAddressControlEnabled"
         ]
         self._wifi_info = wifi_info

homeassistant/components/fujitsu_fglair/__init__.py

@@ -5,11 +5,11 @@ from contextlib import suppress
 from ayla_iot_unofficial import new_ayla_api
 from ayla_iot_unofficial.fujitsu_consts import FGLAIR_APP_CREDENTIALS
 
-from homeassistant.const import CONF_PASSWORD, CONF_USERNAME, Platform
+from homeassistant.const import CONF_PASSWORD, CONF_REGION, CONF_USERNAME, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import aiohttp_client
 
-from .const import API_TIMEOUT, CONF_EUROPE, CONF_REGION, REGION_DEFAULT, REGION_EU
+from .const import API_TIMEOUT, CONF_EUROPE, REGION_DEFAULT, REGION_EU
 from .coordinator import FGLairConfigEntry, FGLairCoordinator
 
 PLATFORMS: list[Platform] = [Platform.CLIMATE, Platform.SENSOR]

homeassistant/components/fujitsu_fglair/config_flow.py

@@ -9,11 +9,11 @@ from ayla_iot_unofficial.fujitsu_consts import FGLAIR_APP_CREDENTIALS
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
+from homeassistant.const import CONF_PASSWORD, CONF_REGION, CONF_USERNAME
 from homeassistant.helpers import aiohttp_client
 from homeassistant.helpers.selector import SelectSelector, SelectSelectorConfig
 
-from .const import API_TIMEOUT, CONF_REGION, DOMAIN, REGION_DEFAULT, REGION_EU
+from .const import API_TIMEOUT, DOMAIN, REGION_DEFAULT, REGION_EU
 
 _LOGGER = logging.getLogger(__name__)
 

homeassistant/components/fujitsu_fglair/const.py

@@ -7,8 +7,6 @@ API_REFRESH = timedelta(minutes=5)
 
 DOMAIN = "fujitsu_fglair"
 
-# pylint: disable-next=home-assistant-duplicate-const
-CONF_REGION = "region"
 CONF_EUROPE = "is_europe"
 REGION_EU = "eu"
 REGION_DEFAULT = "default"

homeassistant/components/gios/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["dacite", "gios"],
   "quality_scale": "platinum",
-  "requirements": ["gios==7.0.0"]
+  "requirements": ["gios==7.1.0"]
 }

homeassistant/components/google/manifest.json

@@ -8,5 +8,5 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["googleapiclient"],
-  "requirements": ["gcal-sync==8.0.0", "oauth2client==4.1.3", "ical==13.2.2"]
+  "requirements": ["gcal-sync==8.0.0", "oauth2client==4.1.3", "ical==13.2.4"]
 }

homeassistant/components/google_assistant/helpers.py

@@ -18,7 +18,6 @@ from homeassistant.components import webhook
 from homeassistant.const import (
     ATTR_DEVICE_CLASS,
     ATTR_SUPPORTED_FEATURES,
-    CLOUD_NEVER_EXPOSED_ENTITIES,
     CONF_NAME,
     STATE_UNAVAILABLE,
 )
@@ -803,8 +802,6 @@ def async_get_entities(
     is_supported_cache = config.is_supported_cache
     for state in hass.states.async_all():
         entity_id = state.entity_id
-        if entity_id in CLOUD_NEVER_EXPOSED_ENTITIES:
-            continue
         # Check check inlined for performance to avoid
         # function calls for every entity since we enumerate
         # the entire state machine here

homeassistant/components/google_assistant/http.py

@@ -12,7 +12,6 @@ import jwt
 
 from homeassistant.components import webhook
 from homeassistant.components.http import KEY_HASS, HomeAssistantView
-from homeassistant.const import CLOUD_NEVER_EXPOSED_ENTITIES
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import entity_registry as er
@@ -167,9 +166,6 @@ class GoogleConfig(AbstractConfig):
             # Ignore entities that are views
             return False
 
-        if state.entity_id in CLOUD_NEVER_EXPOSED_ENTITIES:
-            return False
-
         entity_registry = er.async_get(self.hass)
         registry_entry = entity_registry.async_get(state.entity_id)
         if registry_entry:

homeassistant/components/google_generative_ai_conversation/config_flow.py

@@ -19,7 +19,7 @@ from homeassistant.config_entries import (
     ConfigSubentryFlow,
     SubentryFlowResult,
 )
-from homeassistant.const import CONF_API_KEY, CONF_LLM_HASS_API, CONF_NAME
+from homeassistant.const import CONF_API_KEY, CONF_LLM_HASS_API, CONF_NAME, CONF_PROMPT
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import llm
 from homeassistant.helpers.selector import (
@@ -38,7 +38,6 @@ from .const import (
     CONF_HARASSMENT_BLOCK_THRESHOLD,
     CONF_HATE_BLOCK_THRESHOLD,
     CONF_MAX_TOKENS,
-    CONF_PROMPT,
     CONF_RECOMMENDED,
     CONF_SEXUAL_BLOCK_THRESHOLD,
     CONF_TEMPERATURE,

homeassistant/components/google_generative_ai_conversation/const.py

@@ -2,7 +2,7 @@
 
 import logging
 
-from homeassistant.const import CONF_LLM_HASS_API
+from homeassistant.const import CONF_LLM_HASS_API, CONF_PROMPT
 from homeassistant.helpers import llm
 
 LOGGER = logging.getLogger(__package__)
@@ -15,8 +15,6 @@ DEFAULT_STT_NAME = "Google AI STT"
 DEFAULT_TTS_NAME = "Google AI TTS"
 DEFAULT_AI_TASK_NAME = "Google AI Task"
 
-# pylint: disable-next=home-assistant-duplicate-const
-CONF_PROMPT = "prompt"
 DEFAULT_STT_PROMPT = "Transcribe the attached audio"
 
 CONF_RECOMMENDED = "recommended"

homeassistant/components/google_generative_ai_conversation/conversation.py

@@ -4,11 +4,11 @@ from typing import Literal
 
 from homeassistant.components import conversation
 from homeassistant.config_entries import ConfigEntry, ConfigSubentry
-from homeassistant.const import CONF_LLM_HASS_API, MATCH_ALL
+from homeassistant.const import CONF_LLM_HASS_API, CONF_PROMPT, MATCH_ALL
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import CONF_PROMPT, DOMAIN
+from .const import DOMAIN
 from .entity import GoogleGenerativeAILLMBaseEntity
 
 

homeassistant/components/google_generative_ai_conversation/stt.py

@@ -7,16 +7,11 @@ from google.genai.types import Part
 
 from homeassistant.components import stt
 from homeassistant.config_entries import ConfigEntry, ConfigSubentry
+from homeassistant.const import CONF_PROMPT
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import (
-    CONF_CHAT_MODEL,
-    CONF_PROMPT,
-    DEFAULT_STT_PROMPT,
-    LOGGER,
-    RECOMMENDED_STT_MODEL,
-)
+from .const import CONF_CHAT_MODEL, DEFAULT_STT_PROMPT, LOGGER, RECOMMENDED_STT_MODEL
 from .entity import GoogleGenerativeAILLMBaseEntity
 from .helpers import convert_to_wav
 

homeassistant/components/google_photos/services.py

@@ -84,11 +84,9 @@ async def _async_handle_upload(call: ServiceCall) -> ServiceResponse:
 
     scopes = config_entry.data["token"]["scope"].split(" ")
     if UPLOAD_SCOPE not in scopes:
-        # pylint: disable-next=home-assistant-exception-placeholder-mismatch
         raise HomeAssistantError(
             translation_domain=DOMAIN,
             translation_key="missing_upload_permission",
-            translation_placeholders={"target": DOMAIN},
         )
     coordinator = config_entry.runtime_data
     client_api = coordinator.client

homeassistant/components/google_travel_time/const.py

@@ -12,8 +12,6 @@ DOMAIN = "google_travel_time"
 ATTRIBUTION = "Powered by Google"
 
 CONF_DESTINATION = "destination"
-# pylint: disable-next=home-assistant-duplicate-const
-CONF_OPTIONS = "options"
 CONF_ORIGIN = "origin"
 CONF_AVOID = "avoid"
 CONF_UNITS = "units"

homeassistant/components/govee_ble/config_flow.py

@@ -5,6 +5,7 @@ from typing import Any
 from govee_ble import GoveeBluetoothDeviceData as DeviceData
 import voluptuous as vol
 
+from homeassistant.components import bluetooth
 from homeassistant.components.bluetooth import (
     BluetoothServiceInfoBleak,
     async_discovered_service_info,
@@ -76,6 +77,7 @@ class GoveeConfigFlow(ConfigFlow, domain=DOMAIN):
                 title=title, data={CONF_DEVICE_TYPE: device.device_type}
             )
 
+        await bluetooth.async_request_active_scan(self.hass)
         current_addresses = self._async_current_ids(include_ignore=False)
         for discovery_info in async_discovered_service_info(self.hass, False):
             address = discovery_info.address

homeassistant/components/growatt_server/config_flow.py

@@ -12,6 +12,7 @@ from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResu
 from homeassistant.const import (
     CONF_NAME,
     CONF_PASSWORD,
+    CONF_REGION,
     CONF_TOKEN,
     CONF_URL,
     CONF_USERNAME,
@@ -25,7 +26,6 @@ from .const import (
     AUTH_PASSWORD,
     CONF_AUTH_TYPE,
     CONF_PLANT_ID,
-    CONF_REGION,
     DEFAULT_URL,
     DOMAIN,
     ERROR_CANNOT_CONNECT,

homeassistant/components/growatt_server/const.py

@@ -3,13 +3,6 @@
 from homeassistant.const import Platform
 
 CONF_PLANT_ID = "plant_id"
-# pylint: disable-next=home-assistant-duplicate-const
-CONF_REGION = "region"
-
-
-# API key support
-# pylint: disable-next=home-assistant-duplicate-const
-CONF_API_KEY = "api_key"
 
 # Auth types for config flow
 AUTH_PASSWORD = "password"

homeassistant/components/hegel/config_flow.py

@@ -9,10 +9,10 @@ import voluptuous as vol
 from yarl import URL
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_HOST
+from homeassistant.const import CONF_HOST, CONF_MODEL
 from homeassistant.helpers.service_info.ssdp import SsdpServiceInfo
 
-from .const import CONF_MODEL, DEFAULT_PORT, DOMAIN, MODEL_INPUTS
+from .const import DEFAULT_PORT, DOMAIN, MODEL_INPUTS
 
 _LOGGER = logging.getLogger(__name__)
 

homeassistant/components/hegel/const.py

@@ -3,8 +3,6 @@
 DOMAIN = "hegel"
 DEFAULT_PORT = 50001
 
-# pylint: disable-next=home-assistant-duplicate-const
-CONF_MODEL = "model"
 CONF_MAX_VOLUME = "max_volume"  # 1.0 means amp's internal max
 
 HEARTBEAT_TIMEOUT_MINUTES = 3

homeassistant/components/hegel/media_player.py

@@ -20,6 +20,7 @@ from homeassistant.components.media_player import (
     MediaPlayerEntityFeature,
     MediaPlayerState,
 )
+from homeassistant.const import CONF_MODEL
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
 from homeassistant.helpers.device_registry import DeviceInfo
@@ -27,7 +28,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.event import async_track_time_interval
 
 from . import HegelConfigEntry
-from .const import CONF_MODEL, DOMAIN, HEARTBEAT_TIMEOUT_MINUTES, MODEL_INPUTS
+from .const import DOMAIN, HEARTBEAT_TIMEOUT_MINUTES, MODEL_INPUTS
 
 _LOGGER = logging.getLogger(__name__)
 

homeassistant/components/heos/config_flow.py

@@ -116,7 +116,7 @@ async def _validate_auth(
 
 def _get_current_hosts(entry: HeosConfigEntry) -> set[str]:
     """Get a set of current hosts from the entry."""
-    hosts = set(entry.data[CONF_HOST])
+    hosts = {entry.data[CONF_HOST]}
     if hasattr(entry, "runtime_data"):
         hosts.update(
             player.ip_address

homeassistant/components/heos/media_player.py

@@ -473,6 +473,7 @@ class HeosMediaPlayer(CoordinatorEntity[HeosCoordinator], MediaPlayerEntity):
                 await self.coordinator.heos.set_group(new_members)
                 return
 
+    @catch_action_error("remove from queue")
     async def async_remove_from_queue(self, queue_ids: list[int]) -> None:
         """Remove items from the queue."""
         await self._player.remove_from_queue(queue_ids)

homeassistant/components/homeassistant/exposed_entities.py

@@ -10,7 +10,6 @@ import voluptuous as vol
 from homeassistant.components import websocket_api
 from homeassistant.components.binary_sensor import BinarySensorDeviceClass
 from homeassistant.components.sensor import SensorDeviceClass
-from homeassistant.const import CLOUD_NEVER_EXPOSED_ENTITIES
 from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback, split_entity_id
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import entity_registry as er
@@ -246,9 +245,6 @@ class ExposedEntities:
         """Return True if an entity should be exposed to an assistant."""
         should_expose: bool
 
-        if entity_id in CLOUD_NEVER_EXPOSED_ENTITIES:
-            return False
-
         entity_registry = er.async_get(self._hass)
         if not (registry_entry := entity_registry.async_get(entity_id)):
             return self._async_should_expose_legacy_entity(assistant, entity_id)
@@ -406,19 +402,6 @@ def ws_expose_entity(
     """Expose an entity to an assistant."""
     entity_ids: list[str] = msg["entity_ids"]
 
-    if blocked := next(
-        (
-            entity_id
-            for entity_id in entity_ids
-            if entity_id in CLOUD_NEVER_EXPOSED_ENTITIES
-        ),
-        None,
-    ):
-        connection.send_error(
-            msg["id"], websocket_api.ERR_NOT_ALLOWED, f"can't expose '{blocked}'"
-        )
-        return
-
     for entity_id in entity_ids:
         for assistant in msg["assistants"]:
             async_expose_entity(hass, assistant, entity_id, msg["should_expose"])