feat: Add multiple media selection to MediaSelector

Co-authored-by: paulus.schoutsen <paulus.schoutsen@nabucasa.com>

.github/workflows/ci.yaml

@@ -625,7 +625,7 @@ jobs:
     steps:
       - *checkout
       - name: Dependency review
-        uses: actions/dependency-review-action@40c09b7dc99638e5ddb0bfd91c1673effc064d8a # v4.8.1
+        uses: actions/dependency-review-action@56339e523c0409420f6c2c9a2f4292bbb3c07dd3 # v4.8.0
         with:
           license-check: false # We use our own license audit checks
 

.github/workflows/codeql.yml

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

.gitignore

@@ -79,6 +79,7 @@ junit.xml
 .project
 .pydevproject
 
+.python-version
 .tool-versions
 
 # emacs auto backups

.python-version

@@ -1 +0,0 @@
-3.13

CODEOWNERS

@@ -46,8 +46,6 @@ build.json @home-assistant/supervisor
 /tests/components/accuweather/ @bieniu
 /homeassistant/components/acmeda/ @atmurray
 /tests/components/acmeda/ @atmurray
-/homeassistant/components/actron_air/ @kclif9 @JagadishDhanamjayam
-/tests/components/actron_air/ @kclif9 @JagadishDhanamjayam
 /homeassistant/components/adax/ @danielhiversen @lazytarget
 /tests/components/adax/ @danielhiversen @lazytarget
 /homeassistant/components/adguard/ @frenck

Dockerfile.dev

@@ -36,7 +36,7 @@ COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
 
 USER vscode
 
-COPY .python-version ./
+ENV UV_PYTHON=3.13.2
 RUN uv python install
 
 ENV VIRTUAL_ENV="/home/vscode/.local/ha-venv"

homeassistant/components/actron_air/__init__.py

@@ -1,57 +0,0 @@
-"""The Actron Air integration."""
-
-from actron_neo_api import (
-    ActronAirNeoACSystem,
-    ActronNeoAPI,
-    ActronNeoAPIError,
-    ActronNeoAuthError,
-)
-
-from homeassistant.const import CONF_API_TOKEN, Platform
-from homeassistant.core import HomeAssistant
-
-from .const import _LOGGER
-from .coordinator import (
-    ActronAirConfigEntry,
-    ActronAirRuntimeData,
-    ActronAirSystemCoordinator,
-)
-
-PLATFORM = [Platform.CLIMATE]
-
-
-async def async_setup_entry(hass: HomeAssistant, entry: ActronAirConfigEntry) -> bool:
-    """Set up Actron Air integration from a config entry."""
-
-    api = ActronNeoAPI(refresh_token=entry.data[CONF_API_TOKEN])
-    systems: list[ActronAirNeoACSystem] = []
-
-    try:
-        systems = await api.get_ac_systems()
-        await api.update_status()
-    except ActronNeoAuthError:
-        _LOGGER.error("Authentication error while setting up Actron Air integration")
-        raise
-    except ActronNeoAPIError as err:
-        _LOGGER.error("API error while setting up Actron Air integration: %s", err)
-        raise
-
-    system_coordinators: dict[str, ActronAirSystemCoordinator] = {}
-    for system in systems:
-        coordinator = ActronAirSystemCoordinator(hass, entry, api, system)
-        _LOGGER.debug("Setting up coordinator for system: %s", system["serial"])
-        await coordinator.async_config_entry_first_refresh()
-        system_coordinators[system["serial"]] = coordinator
-
-    entry.runtime_data = ActronAirRuntimeData(
-        api=api,
-        system_coordinators=system_coordinators,
-    )
-
-    await hass.config_entries.async_forward_entry_setups(entry, PLATFORM)
-    return True
-
-
-async def async_unload_entry(hass: HomeAssistant, entry: ActronAirConfigEntry) -> bool:
-    """Unload a config entry."""
-    return await hass.config_entries.async_unload_platforms(entry, PLATFORM)

homeassistant/components/actron_air/climate.py

@@ -1,259 +0,0 @@
-"""Climate platform for Actron Air integration."""
-
-from typing import Any
-
-from actron_neo_api import ActronAirNeoStatus, ActronAirNeoZone
-
-from homeassistant.components.climate import (
-    FAN_AUTO,
-    FAN_HIGH,
-    FAN_LOW,
-    FAN_MEDIUM,
-    ClimateEntity,
-    ClimateEntityFeature,
-    HVACMode,
-)
-from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from .const import DOMAIN
-from .coordinator import ActronAirConfigEntry, ActronAirSystemCoordinator
-
-PARALLEL_UPDATES = 0
-
-FAN_MODE_MAPPING_ACTRONAIR_TO_HA = {
-    "AUTO": FAN_AUTO,
-    "LOW": FAN_LOW,
-    "MED": FAN_MEDIUM,
-    "HIGH": FAN_HIGH,
-}
-FAN_MODE_MAPPING_HA_TO_ACTRONAIR = {
-    v: k for k, v in FAN_MODE_MAPPING_ACTRONAIR_TO_HA.items()
-}
-HVAC_MODE_MAPPING_ACTRONAIR_TO_HA = {
-    "COOL": HVACMode.COOL,
-    "HEAT": HVACMode.HEAT,
-    "FAN": HVACMode.FAN_ONLY,
-    "AUTO": HVACMode.AUTO,
-    "OFF": HVACMode.OFF,
-}
-HVAC_MODE_MAPPING_HA_TO_ACTRONAIR = {
-    v: k for k, v in HVAC_MODE_MAPPING_ACTRONAIR_TO_HA.items()
-}
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: ActronAirConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Actron Air climate entities."""
-    system_coordinators = entry.runtime_data.system_coordinators
-    entities: list[ClimateEntity] = []
-
-    for coordinator in system_coordinators.values():
-        status = coordinator.data
-        name = status.ac_system.system_name
-        entities.append(ActronSystemClimate(coordinator, name))
-
-        entities.extend(
-            ActronZoneClimate(coordinator, zone)
-            for zone in status.remote_zone_info
-            if zone.exists
-        )
-
-    async_add_entities(entities)
-
-
-class BaseClimateEntity(CoordinatorEntity[ActronAirSystemCoordinator], ClimateEntity):
-    """Base class for Actron Air climate entities."""
-
-    _attr_has_entity_name = True
-    _attr_temperature_unit = UnitOfTemperature.CELSIUS
-    _attr_supported_features = (
-        ClimateEntityFeature.TARGET_TEMPERATURE
-        | ClimateEntityFeature.FAN_MODE
-        | ClimateEntityFeature.TURN_ON
-        | ClimateEntityFeature.TURN_OFF
-    )
-    _attr_name = None
-    _attr_fan_modes = list(FAN_MODE_MAPPING_ACTRONAIR_TO_HA.values())
-    _attr_hvac_modes = list(HVAC_MODE_MAPPING_ACTRONAIR_TO_HA.values())
-
-    def __init__(
-        self,
-        coordinator: ActronAirSystemCoordinator,
-        name: str,
-    ) -> None:
-        """Initialize an Actron Air unit."""
-        super().__init__(coordinator)
-        self._serial_number = coordinator.serial_number
-
-
-class ActronSystemClimate(BaseClimateEntity):
-    """Representation of the Actron Air system."""
-
-    _attr_supported_features = (
-        ClimateEntityFeature.TARGET_TEMPERATURE
-        | ClimateEntityFeature.FAN_MODE
-        | ClimateEntityFeature.TURN_ON
-        | ClimateEntityFeature.TURN_OFF
-    )
-
-    def __init__(
-        self,
-        coordinator: ActronAirSystemCoordinator,
-        name: str,
-    ) -> None:
-        """Initialize an Actron Air unit."""
-        super().__init__(coordinator, name)
-        serial_number = coordinator.serial_number
-        self._attr_unique_id = serial_number
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, serial_number)},
-            name=self._status.ac_system.system_name,
-            manufacturer="Actron Air",
-            model_id=self._status.ac_system.master_wc_model,
-            sw_version=self._status.ac_system.master_wc_firmware_version,
-            serial_number=serial_number,
-        )
-
-    @property
-    def min_temp(self) -> float:
-        """Return the minimum temperature that can be set."""
-        return self._status.min_temp
-
-    @property
-    def max_temp(self) -> float:
-        """Return the maximum temperature that can be set."""
-        return self._status.max_temp
-
-    @property
-    def _status(self) -> ActronAirNeoStatus:
-        """Get the current status from the coordinator."""
-        return self.coordinator.data
-
-    @property
-    def hvac_mode(self) -> HVACMode | None:
-        """Return the current HVAC mode."""
-        if not self._status.user_aircon_settings.is_on:
-            return HVACMode.OFF
-
-        mode = self._status.user_aircon_settings.mode
-        return HVAC_MODE_MAPPING_ACTRONAIR_TO_HA.get(mode)
-
-    @property
-    def fan_mode(self) -> str | None:
-        """Return the current fan mode."""
-        fan_mode = self._status.user_aircon_settings.fan_mode
-        return FAN_MODE_MAPPING_ACTRONAIR_TO_HA.get(fan_mode)
-
-    @property
-    def current_humidity(self) -> float:
-        """Return the current humidity."""
-        return self._status.master_info.live_humidity_pc
-
-    @property
-    def current_temperature(self) -> float:
-        """Return the current temperature."""
-        return self._status.master_info.live_temp_c
-
-    @property
-    def target_temperature(self) -> float:
-        """Return the target temperature."""
-        return self._status.user_aircon_settings.temperature_setpoint_cool_c
-
-    async def async_set_fan_mode(self, fan_mode: str) -> None:
-        """Set a new fan mode."""
-        api_fan_mode = FAN_MODE_MAPPING_HA_TO_ACTRONAIR.get(fan_mode.lower())
-        await self._status.user_aircon_settings.set_fan_mode(api_fan_mode)
-
-    async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
-        """Set the HVAC mode."""
-        ac_mode = HVAC_MODE_MAPPING_HA_TO_ACTRONAIR.get(hvac_mode)
-        await self._status.ac_system.set_system_mode(ac_mode)
-
-    async def async_set_temperature(self, **kwargs: Any) -> None:
-        """Set the temperature."""
-        temp = kwargs.get(ATTR_TEMPERATURE)
-        await self._status.user_aircon_settings.set_temperature(temperature=temp)
-
-
-class ActronZoneClimate(BaseClimateEntity):
-    """Representation of a zone within the Actron Air system."""
-
-    _attr_supported_features = (
-        ClimateEntityFeature.TARGET_TEMPERATURE
-        | ClimateEntityFeature.TURN_ON
-        | ClimateEntityFeature.TURN_OFF
-    )
-
-    def __init__(
-        self,
-        coordinator: ActronAirSystemCoordinator,
-        zone: ActronAirNeoZone,
-    ) -> None:
-        """Initialize an Actron Air unit."""
-        super().__init__(coordinator, zone.title)
-        serial_number = coordinator.serial_number
-        self._zone_id: int = zone.zone_id
-        self._attr_unique_id: str = f"{serial_number}_zone_{zone.zone_id}"
-        self._attr_device_info: DeviceInfo = DeviceInfo(
-            identifiers={(DOMAIN, self._attr_unique_id)},
-            name=zone.title,
-            manufacturer="Actron Air",
-            model="Zone",
-            suggested_area=zone.title,
-            via_device=(DOMAIN, serial_number),
-        )
-
-    @property
-    def min_temp(self) -> float:
-        """Return the minimum temperature that can be set."""
-        return self._zone.min_temp
-
-    @property
-    def max_temp(self) -> float:
-        """Return the maximum temperature that can be set."""
-        return self._zone.max_temp
-
-    @property
-    def _zone(self) -> ActronAirNeoZone:
-        """Get the current zone data from the coordinator."""
-        status = self.coordinator.data
-        return status.zones[self._zone_id]
-
-    @property
-    def hvac_mode(self) -> HVACMode | None:
-        """Return the current HVAC mode."""
-        if self._zone.is_active:
-            mode = self._zone.hvac_mode
-            return HVAC_MODE_MAPPING_ACTRONAIR_TO_HA.get(mode)
-        return HVACMode.OFF
-
-    @property
-    def current_humidity(self) -> float | None:
-        """Return the current humidity."""
-        return self._zone.humidity
-
-    @property
-    def current_temperature(self) -> float | None:
-        """Return the current temperature."""
-        return self._zone.live_temp_c
-
-    @property
-    def target_temperature(self) -> float | None:
-        """Return the target temperature."""
-        return self._zone.temperature_setpoint_cool_c
-
-    async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
-        """Set the HVAC mode."""
-        is_enabled = hvac_mode != HVACMode.OFF
-        await self._zone.enable(is_enabled)
-
-    async def async_set_temperature(self, **kwargs: Any) -> None:
-        """Set the temperature."""
-        await self._zone.set_temperature(temperature=kwargs["temperature"])

homeassistant/components/actron_air/config_flow.py

@@ -1,132 +0,0 @@
-"""Setup config flow for Actron Air integration."""
-
-import asyncio
-from typing import Any
-
-from actron_neo_api import ActronNeoAPI, ActronNeoAuthError
-
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_API_TOKEN
-from homeassistant.exceptions import HomeAssistantError
-
-from .const import _LOGGER, DOMAIN
-
-
-class ActronAirConfigFlow(ConfigFlow, domain=DOMAIN):
-    """Handle a config flow for Actron Air."""
-
-    def __init__(self) -> None:
-        """Initialize the config flow."""
-        self._api: ActronNeoAPI | None = None
-        self._device_code: str | None = None
-        self._user_code: str = ""
-        self._verification_uri: str = ""
-        self._expires_minutes: str = "30"
-        self.login_task: asyncio.Task | None = None
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the initial step."""
-        if self._api is None:
-            _LOGGER.debug("Initiating device authorization")
-            self._api = ActronNeoAPI()
-            try:
-                device_code_response = await self._api.request_device_code()
-            except ActronNeoAuthError as err:
-                _LOGGER.error("OAuth2 flow failed: %s", err)
-                return self.async_abort(reason="oauth2_error")
-
-            self._device_code = device_code_response["device_code"]
-            self._user_code = device_code_response["user_code"]
-            self._verification_uri = device_code_response["verification_uri_complete"]
-            self._expires_minutes = str(device_code_response["expires_in"] // 60)
-
-        async def _wait_for_authorization() -> None:
-            """Wait for the user to authorize the device."""
-            assert self._api is not None
-            assert self._device_code is not None
-            _LOGGER.debug("Waiting for device authorization")
-            try:
-                await self._api.poll_for_token(self._device_code)
-                _LOGGER.debug("Authorization successful")
-            except ActronNeoAuthError as ex:
-                _LOGGER.exception("Error while waiting for device authorization")
-                raise CannotConnect from ex
-
-        _LOGGER.debug("Checking login task")
-        if self.login_task is None:
-            _LOGGER.debug("Creating task for device authorization")
-            self.login_task = self.hass.async_create_task(_wait_for_authorization())
-
-        if self.login_task.done():
-            _LOGGER.debug("Login task is done, checking results")
-            if exception := self.login_task.exception():
-                if isinstance(exception, CannotConnect):
-                    return self.async_show_progress_done(
-                        next_step_id="connection_error"
-                    )
-                return self.async_show_progress_done(next_step_id="timeout")
-            return self.async_show_progress_done(next_step_id="finish_login")
-
-        return self.async_show_progress(
-            step_id="user",
-            progress_action="wait_for_authorization",
-            description_placeholders={
-                "user_code": self._user_code,
-                "verification_uri": self._verification_uri,
-                "expires_minutes": self._expires_minutes,
-            },
-            progress_task=self.login_task,
-        )
-
-    async def async_step_finish_login(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the finalization of login."""
-        _LOGGER.debug("Finalizing authorization")
-        assert self._api is not None
-
-        try:
-            user_data = await self._api.get_user_info()
-        except ActronNeoAuthError as err:
-            _LOGGER.error("Error getting user info: %s", err)
-            return self.async_abort(reason="oauth2_error")
-
-        unique_id = str(user_data["id"])
-        await self.async_set_unique_id(unique_id)
-        self._abort_if_unique_id_configured()
-
-        return self.async_create_entry(
-            title=user_data["email"],
-            data={CONF_API_TOKEN: self._api.refresh_token_value},
-        )
-
-    async def async_step_timeout(
-        self,
-        user_input: dict[str, Any] | None = None,
-    ) -> ConfigFlowResult:
-        """Handle issues that need transition await from progress step."""
-        if user_input is None:
-            return self.async_show_form(
-                step_id="timeout",
-            )
-        del self.login_task
-        return await self.async_step_user()
-
-    async def async_step_connection_error(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle connection error from progress step."""
-        if user_input is None:
-            return self.async_show_form(step_id="connection_error")
-
-        # Reset state and try again
-        self._api = None
-        self._device_code = None
-        self.login_task = None
-        return await self.async_step_user()
-
-
-class CannotConnect(HomeAssistantError):
-    """Error to indicate we cannot connect."""

homeassistant/components/actron_air/const.py

@@ -1,6 +0,0 @@
-"""Constants used by Actron Air integration."""
-
-import logging
-
-_LOGGER = logging.getLogger(__package__)
-DOMAIN = "actron_air"

homeassistant/components/actron_air/coordinator.py

@@ -1,69 +0,0 @@
-"""Coordinator for Actron Air integration."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from datetime import timedelta
-
-from actron_neo_api import ActronAirNeoACSystem, ActronAirNeoStatus, ActronNeoAPI
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
-from homeassistant.util import dt as dt_util
-
-from .const import _LOGGER
-
-STALE_DEVICE_TIMEOUT = timedelta(hours=24)
-ERROR_NO_SYSTEMS_FOUND = "no_systems_found"
-ERROR_UNKNOWN = "unknown_error"
-
-
-@dataclass
-class ActronAirRuntimeData:
-    """Runtime data for the Actron Air integration."""
-
-    api: ActronNeoAPI
-    system_coordinators: dict[str, ActronAirSystemCoordinator]
-
-
-type ActronAirConfigEntry = ConfigEntry[ActronAirRuntimeData]
-
-AUTH_ERROR_THRESHOLD = 3
-SCAN_INTERVAL = timedelta(seconds=30)
-
-
-class ActronAirSystemCoordinator(DataUpdateCoordinator[ActronAirNeoACSystem]):
-    """System coordinator for Actron Air integration."""
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        entry: ActronAirConfigEntry,
-        api: ActronNeoAPI,
-        system: ActronAirNeoACSystem,
-    ) -> None:
-        """Initialize the coordinator."""
-        super().__init__(
-            hass,
-            _LOGGER,
-            name="Actron Air Status",
-            update_interval=SCAN_INTERVAL,
-            config_entry=entry,
-        )
-        self.system = system
-        self.serial_number = system["serial"]
-        self.api = api
-        self.status = self.api.state_manager.get_status(self.serial_number)
-        self.last_seen = dt_util.utcnow()
-
-    async def _async_update_data(self) -> ActronAirNeoStatus:
-        """Fetch updates and merge incremental changes into the full state."""
-        await self.api.update_status()
-        self.status = self.api.state_manager.get_status(self.serial_number)
-        self.last_seen = dt_util.utcnow()
-        return self.status
-
-    def is_device_stale(self) -> bool:
-        """Check if a device is stale (not seen for a while)."""
-        return (dt_util.utcnow() - self.last_seen) > STALE_DEVICE_TIMEOUT

homeassistant/components/actron_air/manifest.json

@@ -1,16 +0,0 @@
-{
-  "domain": "actron_air",
-  "name": "Actron Air",
-  "codeowners": ["@kclif9", "@JagadishDhanamjayam"],
-  "config_flow": true,
-  "dhcp": [
-    {
-      "hostname": "neo-*",
-      "macaddress": "FC0FE7*"
-    }
-  ],
-  "documentation": "https://www.home-assistant.io/integrations/actron_air",
-  "iot_class": "cloud_polling",
-  "quality_scale": "bronze",
-  "requirements": ["actron-neo-api==0.1.84"]
-}

homeassistant/components/actron_air/quality_scale.yaml

@@ -1,78 +0,0 @@
-rules:
-  # Bronze
-  action-setup:
-    status: exempt
-    comment: This integration does not have custom service actions.
-  appropriate-polling: done
-  brands: done
-  common-modules: done
-  config-flow-test-coverage: done
-  config-flow: done
-  dependency-transparency: done
-  docs-actions:
-    status: exempt
-    comment: This integration does not have custom service actions.
-  docs-high-level-description: done
-  docs-installation-instructions: done
-  docs-removal-instructions: done
-  entity-event-setup:
-    status: exempt
-    comment: This integration does not subscribe to external events.
-  entity-unique-id: done
-  has-entity-name: done
-  runtime-data: done
-  test-before-configure: done
-  test-before-setup: done
-  unique-config-entry: done
-
-  # Silver
-  action-exceptions: todo
-  config-entry-unloading: done
-  docs-configuration-parameters:
-    status: exempt
-    comment: No options flow
-  docs-installation-parameters: done
-  entity-unavailable: done
-  integration-owner: done
-  log-when-unavailable: done
-  parallel-updates: done
-  reauthentication-flow: todo
-  test-coverage: todo
-
-  # Gold
-  devices: done
-  diagnostics: todo
-  discovery-update-info:
-    status: exempt
-    comment: This integration uses DHCP discovery, however is cloud polling. Therefore there is no information to update.
-  discovery: done
-  docs-data-update: done
-  docs-examples: done
-  docs-known-limitations: done
-  docs-supported-devices: done
-  docs-supported-functions: done
-  docs-troubleshooting: done
-  docs-use-cases: done
-  dynamic-devices: todo
-  entity-category:
-    status: exempt
-    comment: This integration does not use entity categories.
-  entity-device-class:
-    status: exempt
-    comment: This integration does not use entity device classes.
-  entity-disabled-by-default:
-    status: exempt
-    comment: Not required for this integration at this stage.
-  entity-translations: todo
-  exception-translations: todo
-  icon-translations: todo
-  reconfiguration-flow: todo
-  repair-issues:
-    status: exempt
-    comment: This integration does not have any known issues that require repair.
-  stale-devices: todo
-
-  # Platinum
-  async-dependency: done
-  inject-websession: todo
-  strict-typing: todo

homeassistant/components/actron_air/strings.json

@@ -1,29 +0,0 @@
-{
-  "config": {
-    "step": {
-      "user": {
-        "title": "Actron Air OAuth2 Authorization"
-      },
-      "timeout": {
-        "title": "Authorization timeout",
-        "description": "The authorization process timed out. Please try again.",
-        "data": {}
-      },
-      "connection_error": {
-        "title": "Connection error",
-        "description": "Failed to connect to Actron Air. Please check your internet connection and try again.",
-        "data": {}
-      }
-    },
-    "progress": {
-      "wait_for_authorization": "To authenticate, open the following URL and login at Actron Air:\n{verification_uri}\nIf the code is not automatically copied, paste the following code to authorize the integration:\n\n```{user_code}```\n\n\nThe login attempt will time out after {expires_minutes} minutes."
-    },
-    "error": {
-      "oauth2_error": "Failed to start OAuth2 flow. Please try again later."
-    },
-    "abort": {
-      "oauth2_error": "Failed to start OAuth2 flow",
-      "already_configured": "[%key:common::config_flow::abort::already_configured_account%]"
-    }
-  }
-}

homeassistant/components/ai_task/services.yaml

@@ -30,6 +30,7 @@ generate_data:
         media:
           accept:
             - "*"
+          multiple: true
 generate_image:
   fields:
     task_name:
@@ -57,3 +58,4 @@ generate_image:
         media:
           accept:
             - "*"
+          multiple: true

homeassistant/components/airos/__init__.py

@@ -2,8 +2,6 @@
 
 from __future__ import annotations
 
-import logging
-
 from airos.airos8 import AirOS8
 
 from homeassistant.const import (
@@ -14,11 +12,10 @@ from homeassistant.const import (
     CONF_VERIFY_SSL,
     Platform,
 )
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import device_registry as dr, entity_registry as er
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
-from .const import DEFAULT_SSL, DEFAULT_VERIFY_SSL, DOMAIN, SECTION_ADVANCED_SETTINGS
+from .const import DEFAULT_SSL, DEFAULT_VERIFY_SSL, SECTION_ADVANCED_SETTINGS
 from .coordinator import AirOSConfigEntry, AirOSDataUpdateCoordinator
 
 _PLATFORMS: list[Platform] = [
@@ -26,8 +23,6 @@ _PLATFORMS: list[Platform] = [
     Platform.SENSOR,
 ]
 
-_LOGGER = logging.getLogger(__name__)
-
 
 async def async_setup_entry(hass: HomeAssistant, entry: AirOSConfigEntry) -> bool:
     """Set up Ubiquiti airOS from a config entry."""
@@ -59,13 +54,11 @@ async def async_setup_entry(hass: HomeAssistant, entry: AirOSConfigEntry) -> boo
 async def async_migrate_entry(hass: HomeAssistant, entry: AirOSConfigEntry) -> bool:
     """Migrate old config entry."""
 
-    # This means the user has downgraded from a future version
-    if entry.version > 2:
+    if entry.version > 1:
+        # This means the user has downgraded from a future version
         return False
 
-    # 1.1 Migrate config_entry to add advanced ssl settings
     if entry.version == 1 and entry.minor_version == 1:
-        new_minor_version = 2
         new_data = {**entry.data}
         advanced_data = {
             CONF_SSL: DEFAULT_SSL,
@@ -76,52 +69,7 @@ async def async_migrate_entry(hass: HomeAssistant, entry: AirOSConfigEntry) -> b
         hass.config_entries.async_update_entry(
             entry,
             data=new_data,
-            minor_version=new_minor_version,
-        )
-
-    # 2.1 Migrate binary_sensor entity unique_id from device_id to mac_address
-    #     Step 1 - migrate binary_sensor entity unique_id
-    #     Step 2 - migrate device entity identifier
-    if entry.version == 1:
-        new_version = 2
-        new_minor_version = 1
-
-        mac_adress = dr.format_mac(entry.unique_id)
-
-        device_registry = dr.async_get(hass)
-        if device_entry := device_registry.async_get_device(
-            connections={(dr.CONNECTION_NETWORK_MAC, mac_adress)}
-        ):
-            old_device_id = next(
-                (
-                    device_id
-                    for domain, device_id in device_entry.identifiers
-                    if domain == DOMAIN
-                ),
-            )
-
-            @callback
-            def update_unique_id(
-                entity_entry: er.RegistryEntry,
-            ) -> dict[str, str] | None:
-                """Update unique id from device_id to mac address."""
-                if old_device_id and entity_entry.unique_id.startswith(old_device_id):
-                    suffix = entity_entry.unique_id.removeprefix(old_device_id)
-                    new_unique_id = f"{mac_adress}{suffix}"
-                    return {"new_unique_id": new_unique_id}
-                return None
-
-            await er.async_migrate_entries(hass, entry.entry_id, update_unique_id)
-
-            new_identifiers = device_entry.identifiers.copy()
-            new_identifiers.discard((DOMAIN, old_device_id))
-            new_identifiers.add((DOMAIN, mac_adress))
-            device_registry.async_update_device(
-                device_entry.id, new_identifiers=new_identifiers
-            )
-
-        hass.config_entries.async_update_entry(
-            entry, version=new_version, minor_version=new_minor_version
+            minor_version=2,
         )
 
     return True

homeassistant/components/airos/binary_sensor.py

@@ -98,7 +98,7 @@ class AirOSBinarySensor(AirOSEntity, BinarySensorEntity):
         super().__init__(coordinator)
 
         self.entity_description = description
-        self._attr_unique_id = f"{coordinator.data.derived.mac}_{description.key}"
+        self._attr_unique_id = f"{coordinator.data.host.device_id}_{description.key}"
 
     @property
     def is_on(self) -> bool:

homeassistant/components/airos/config_flow.py

@@ -15,12 +15,7 @@ from airos.exceptions import (
 )
 import voluptuous as vol
 
-from homeassistant.config_entries import (
-    SOURCE_REAUTH,
-    SOURCE_RECONFIGURE,
-    ConfigFlow,
-    ConfigFlowResult,
-)
+from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlow, ConfigFlowResult
 from homeassistant.const import (
     CONF_HOST,
     CONF_PASSWORD,
@@ -62,8 +57,8 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
 class AirOSConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Ubiquiti airOS."""
 
-    VERSION = 2
-    MINOR_VERSION = 1
+    VERSION = 1
+    MINOR_VERSION = 2
 
     def __init__(self) -> None:
         """Initialize the config flow."""
@@ -124,7 +119,7 @@ class AirOSConfigFlow(ConfigFlow, domain=DOMAIN):
         else:
             await self.async_set_unique_id(airos_data.derived.mac)
 
-            if self.source in [SOURCE_REAUTH, SOURCE_RECONFIGURE]:
+            if self.source == SOURCE_REAUTH:
                 self._abort_if_unique_id_mismatch()
             else:
                 self._abort_if_unique_id_configured()
@@ -169,54 +164,3 @@ class AirOSConfigFlow(ConfigFlow, domain=DOMAIN):
             ),
             errors=self.errors,
         )
-
-    async def async_step_reconfigure(
-        self,
-        user_input: Mapping[str, Any] | None = None,
-    ) -> ConfigFlowResult:
-        """Handle reconfiguration of airOS."""
-        self.errors = {}
-        entry = self._get_reconfigure_entry()
-        current_data = entry.data
-
-        if user_input is not None:
-            validate_data = {**current_data, **user_input}
-            if await self._validate_and_get_device_info(config_data=validate_data):
-                return self.async_update_reload_and_abort(
-                    entry,
-                    data_updates=validate_data,
-                )
-
-        return self.async_show_form(
-            step_id="reconfigure",
-            data_schema=vol.Schema(
-                {
-                    vol.Required(CONF_PASSWORD): TextSelector(
-                        TextSelectorConfig(
-                            type=TextSelectorType.PASSWORD,
-                            autocomplete="current-password",
-                        )
-                    ),
-                    vol.Required(SECTION_ADVANCED_SETTINGS): section(
-                        vol.Schema(
-                            {
-                                vol.Required(
-                                    CONF_SSL,
-                                    default=current_data[SECTION_ADVANCED_SETTINGS][
-                                        CONF_SSL
-                                    ],
-                                ): bool,
-                                vol.Required(
-                                    CONF_VERIFY_SSL,
-                                    default=current_data[SECTION_ADVANCED_SETTINGS][
-                                        CONF_VERIFY_SSL
-                                    ],
-                                ): bool,
-                            }
-                        ),
-                        {"collapsed": True},
-                    ),
-                }
-            ),
-            errors=self.errors,
-        )

homeassistant/components/airos/entity.py

@@ -33,14 +33,9 @@ class AirOSEntity(CoordinatorEntity[AirOSDataUpdateCoordinator]):
         self._attr_device_info = DeviceInfo(
             connections={(CONNECTION_NETWORK_MAC, airos_data.derived.mac)},
             configuration_url=configuration_url,
-            identifiers={(DOMAIN, airos_data.derived.mac)},
+            identifiers={(DOMAIN, str(airos_data.host.device_id))},
             manufacturer=MANUFACTURER,
             model=airos_data.host.devmodel,
-            model_id=(
-                sku
-                if (sku := airos_data.derived.sku) not in ["UNKNOWN", "AMBIGUOUS"]
-                else None
-            ),
             name=airos_data.host.hostname,
             sw_version=airos_data.host.fwversion,
         )

homeassistant/components/airos/manifest.json

@@ -4,8 +4,7 @@
   "codeowners": ["@CoMPaTech"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/airos",
-  "integration_type": "device",
   "iot_class": "local_polling",
   "quality_scale": "bronze",
-  "requirements": ["airos==0.5.6"]
+  "requirements": ["airos==0.5.5"]
 }

homeassistant/components/airos/strings.json

@@ -10,27 +10,6 @@
           "password": "[%key:component::airos::config::step::user::data_description::password%]"
         }
       },
-      "reconfigure": {
-        "data": {
-          "password": "[%key:common::config_flow::data::password%]"
-        },
-        "data_description": {
-          "password": "[%key:component::airos::config::step::user::data_description::password%]"
-        },
-        "sections": {
-          "advanced_settings": {
-            "name": "[%key:component::airos::config::step::user::sections::advanced_settings::name%]",
-            "data": {
-              "ssl": "[%key:component::airos::config::step::user::sections::advanced_settings::data::ssl%]",
-              "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
-            },
-            "data_description": {
-              "ssl": "[%key:component::airos::config::step::user::sections::advanced_settings::data_description::ssl%]",
-              "verify_ssl": "[%key:component::airos::config::step::user::sections::advanced_settings::data_description::verify_ssl%]"
-            }
-          }
-        }
-      },
       "user": {
         "data": {
           "host": "[%key:common::config_flow::data::host%]",
@@ -44,7 +23,6 @@
         },
         "sections": {
           "advanced_settings": {
-            "name": "Advanced settings",
             "data": {
               "ssl": "Use HTTPS",
               "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
@@ -66,7 +44,6 @@
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
       "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
-      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
       "unique_id_mismatch": "Re-authentication should be used for the same device not a new one"
     }
   },

homeassistant/components/airq/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["aioairq"],
-  "requirements": ["aioairq==0.4.7"]
+  "requirements": ["aioairq==0.4.6"]
 }

homeassistant/components/asuswrt/bridge.py

@@ -7,13 +7,13 @@ from collections import namedtuple
 from collections.abc import Awaitable, Callable, Coroutine
 import functools
 import logging
-from typing import Any
+from typing import Any, cast
 
 from aioasuswrt.asuswrt import AsusWrt as AsusWrtLegacy
 from aiohttp import ClientSession
 from asusrouter import AsusRouter, AsusRouterError
 from asusrouter.config import ARConfigKey
-from asusrouter.modules.client import AsusClient, ConnectionState
+from asusrouter.modules.client import AsusClient
 from asusrouter.modules.data import AsusData
 from asusrouter.modules.homeassistant import convert_to_ha_data, convert_to_ha_sensors
 from asusrouter.tools.connection import get_cookie_jar
@@ -219,7 +219,7 @@ class AsusWrtLegacyBridge(AsusWrtBridge):
     @property
     def is_connected(self) -> bool:
         """Get connected status."""
-        return self._api.is_connected
+        return cast(bool, self._api.is_connected)
 
     async def async_connect(self) -> None:
         """Connect to the device."""
@@ -235,7 +235,8 @@ class AsusWrtLegacyBridge(AsusWrtBridge):
 
     async def async_disconnect(self) -> None:
         """Disconnect to the device."""
-        await self._api.async_disconnect()
+        if self._api is not None and self._protocol == PROTOCOL_TELNET:
+            self._api.connection.disconnect()
 
     async def async_get_connected_devices(self) -> dict[str, WrtDevice]:
         """Get list of connected devices."""
@@ -436,7 +437,6 @@ class AsusWrtHttpBridge(AsusWrtBridge):
             if dev.connection is not None
             and dev.description is not None
             and dev.connection.ip_address is not None
-            and dev.state is ConnectionState.CONNECTED
         }
 
     async def async_get_available_sensors(self) -> dict[str, dict[str, Any]]:

homeassistant/components/asuswrt/device_tracker.py

@@ -10,6 +10,8 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from . import AsusWrtConfigEntry
 from .router import AsusWrtDevInfo, AsusWrtRouter
 
+ATTR_LAST_TIME_REACHABLE = "last_time_reachable"
+
 DEFAULT_DEVICE_NAME = "Unknown device"
 
 
@@ -56,6 +58,8 @@ def add_entities(
 class AsusWrtDevice(ScannerEntity):
     """Representation of a AsusWrt device."""
 
+    _unrecorded_attributes = frozenset({ATTR_LAST_TIME_REACHABLE})
+
     _attr_should_poll = False
 
     def __init__(self, router: AsusWrtRouter, device: AsusWrtDevInfo) -> None:
@@ -93,6 +97,11 @@ class AsusWrtDevice(ScannerEntity):
     def async_on_demand_update(self) -> None:
         """Update state."""
         self._device = self._router.devices[self._device.mac]
+        self._attr_extra_state_attributes = {}
+        if self._device.last_activity:
+            self._attr_extra_state_attributes[ATTR_LAST_TIME_REACHABLE] = (
+                self._device.last_activity.isoformat(timespec="seconds")
+            )
         self.async_write_ha_state()
 
     async def async_added_to_hass(self) -> None:

homeassistant/components/asuswrt/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["aioasuswrt", "asusrouter", "asyncssh"],
-  "requirements": ["aioasuswrt==1.5.1", "asusrouter==1.21.0"]
+  "requirements": ["aioasuswrt==1.4.0", "asusrouter==1.21.0"]
 }

homeassistant/components/auth/login_flow.py

@@ -136,22 +136,17 @@ class WellKnownOAuthInfoView(HomeAssistantView):
             url_prefix = get_url(hass, require_current_request=True)
         except NoURLAvailableError:
             url_prefix = ""
-
-        metadata = {
-            "authorization_endpoint": f"{url_prefix}/auth/authorize",
-            "token_endpoint": f"{url_prefix}/auth/token",
-            "revocation_endpoint": f"{url_prefix}/auth/revoke",
-            "response_types_supported": ["code"],
-            "service_documentation": (
-                "https://developers.home-assistant.io/docs/auth_api"
-            ),
-        }
-
-        # Add issuer only when we have a valid base URL (RFC 8414 compliance)
-        if url_prefix:
-            metadata["issuer"] = url_prefix
-
-        return self.json(metadata)
+        return self.json(
+            {
+                "authorization_endpoint": f"{url_prefix}/auth/authorize",
+                "token_endpoint": f"{url_prefix}/auth/token",
+                "revocation_endpoint": f"{url_prefix}/auth/revoke",
+                "response_types_supported": ["code"],
+                "service_documentation": (
+                    "https://developers.home-assistant.io/docs/auth_api"
+                ),
+            }
+        )
 
 
 class AuthProvidersView(HomeAssistantView):

homeassistant/components/bluetooth/__init__.py

@@ -57,7 +57,6 @@ from .api import (
     _get_manager,
     async_address_present,
     async_ble_device_from_address,
-    async_clear_address_from_match_history,
     async_current_scanners,
     async_discovered_service_info,
     async_get_advertisement_callback,
@@ -116,7 +115,6 @@ __all__ = [
     "HomeAssistantRemoteScanner",
     "async_address_present",
     "async_ble_device_from_address",
-    "async_clear_address_from_match_history",
     "async_current_scanners",
     "async_discovered_service_info",
     "async_get_advertisement_callback",

homeassistant/components/bluetooth/api.py

@@ -193,20 +193,6 @@ def async_rediscover_address(hass: HomeAssistant, address: str) -> None:
     _get_manager(hass).async_rediscover_address(address)
 
 
-@hass_callback
-def async_clear_address_from_match_history(hass: HomeAssistant, address: str) -> None:
-    """Clear an address from the integration matcher history.
-
-    This allows future advertisements from this address to trigger discovery
-    even if the advertisement content has changed but the service data UUIDs
-    remain the same.
-
-    Unlike async_rediscover_address, this does not immediately re-trigger
-    discovery with the current advertisement in history.
-    """
-    _get_manager(hass).async_clear_address_from_match_history(address)
-
-
 @hass_callback
 def async_register_scanner(
     hass: HomeAssistant,

homeassistant/components/bluetooth/manager.py

@@ -120,19 +120,6 @@ class HomeAssistantBluetoothManager(BluetoothManager):
         if service_info := self._all_history.get(address):
             self._async_trigger_matching_discovery(service_info)
 
-    @hass_callback
-    def async_clear_address_from_match_history(self, address: str) -> None:
-        """Clear an address from the integration matcher history.
-
-        This allows future advertisements from this address to trigger discovery
-        even if the advertisement content has changed but the service data UUIDs
-        remain the same.
-
-        Unlike async_rediscover_address, this does not immediately re-trigger
-        discovery with the current advertisement in history.
-        """
-        self._integration_matcher.async_clear_address(address)
-
     def _discover_service_info(self, service_info: BluetoothServiceInfoBleak) -> None:
         matched_domains = self._integration_matcher.match_domains(service_info)
         if self._debug:

homeassistant/components/bluetooth/match.py

@@ -68,17 +68,12 @@ class IntegrationMatchHistory:
     manufacturer_data: bool
     service_data: set[str]
     service_uuids: set[str]
-    name: str
 
 
 def seen_all_fields(
-    previous_match: IntegrationMatchHistory,
-    advertisement_data: AdvertisementData,
-    name: str,
+    previous_match: IntegrationMatchHistory, advertisement_data: AdvertisementData
 ) -> bool:
     """Return if we have seen all fields."""
-    if previous_match.name != name:
-        return False
     if not previous_match.manufacturer_data and advertisement_data.manufacturer_data:
         return False
     if advertisement_data.service_data and (
@@ -127,11 +122,10 @@ class IntegrationMatcher:
         device = service_info.device
         advertisement_data = service_info.advertisement
         connectable = service_info.connectable
-        name = service_info.name
         matched = self._matched_connectable if connectable else self._matched
         matched_domains: set[str] = set()
         if (previous_match := matched.get(device.address)) and seen_all_fields(
-            previous_match, advertisement_data, name
+            previous_match, advertisement_data
         ):
             # We have seen all fields so we can skip the rest of the matchers
             return matched_domains
@@ -146,13 +140,11 @@ class IntegrationMatcher:
             )
             previous_match.service_data |= set(advertisement_data.service_data)
             previous_match.service_uuids |= set(advertisement_data.service_uuids)
-            previous_match.name = name
         else:
             matched[device.address] = IntegrationMatchHistory(
                 manufacturer_data=bool(advertisement_data.manufacturer_data),
                 service_data=set(advertisement_data.service_data),
                 service_uuids=set(advertisement_data.service_uuids),
-                name=name,
             )
         return matched_domains
 

homeassistant/components/canary/alarm_control_panel.py

@@ -31,7 +31,7 @@ async def async_setup_entry(
         for location_id, location in coordinator.data["locations"].items()
     ]
 
-    async_add_entities(alarms)
+    async_add_entities(alarms, True)
 
 
 class CanaryAlarm(

homeassistant/components/canary/camera.py

@@ -68,7 +68,8 @@ async def async_setup_entry(
             for location_id, location in coordinator.data["locations"].items()
             for device in location.devices
             if device.is_online
-        )
+        ),
+        True,
     )
 
 

homeassistant/components/canary/sensor.py

@@ -80,7 +80,7 @@ async def async_setup_entry(
                     if device_type.get("name") in sensor_type[4]
                 )
 
-    async_add_entities(sensors)
+    async_add_entities(sensors, True)
 
 
 class CanarySensor(CoordinatorEntity[CanaryDataUpdateCoordinator], SensorEntity):

homeassistant/components/cloud/manifest.json

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

homeassistant/components/co2signal/config_flow.py

@@ -38,10 +38,6 @@ TYPE_SPECIFY_COUNTRY = "specify_country_code"
 
 _LOGGER = logging.getLogger(__name__)
 
-DESCRIPTION_PLACEHOLDER = {
-    "register_link": "https://electricitymaps.com/free-tier",
-}
-
 
 class ElectricityMapsConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Co2signal."""
@@ -74,7 +70,6 @@ class ElectricityMapsConfigFlow(ConfigFlow, domain=DOMAIN):
             return self.async_show_form(
                 step_id="user",
                 data_schema=data_schema,
-                description_placeholders=DESCRIPTION_PLACEHOLDER,
             )
 
         data = {CONF_API_KEY: user_input[CONF_API_KEY]}
@@ -184,5 +179,4 @@ class ElectricityMapsConfigFlow(ConfigFlow, domain=DOMAIN):
             step_id=step_id,
             data_schema=data_schema,
             errors=errors,
-            description_placeholders=DESCRIPTION_PLACEHOLDER,
         )

homeassistant/components/co2signal/quality_scale.yaml

@@ -18,6 +18,7 @@ rules:
     status: todo
     comment: |
       The config flow misses data descriptions.
+      Remove URLs from data descriptions, they should be replaced with placeholders.
       Make use of Electricity Maps zone keys in country code as dropdown.
       Make use of location selector for coordinates.
   dependency-transparency: done

homeassistant/components/co2signal/strings.json

@@ -6,7 +6,7 @@
           "location": "[%key:common::config_flow::data::location%]",
           "api_key": "[%key:common::config_flow::data::access_token%]"
         },
-        "description": "Visit the [Electricity Maps page]({register_link}) to request a token."
+        "description": "Visit https://electricitymaps.com/free-tier to request a token."
       },
       "coordinates": {
         "data": {

homeassistant/components/coinbase/config_flow.py

@@ -166,7 +166,6 @@ class CoinbaseConfigFlow(ConfigFlow, domain=DOMAIN):
                 data_schema=STEP_USER_DATA_SCHEMA,
                 description_placeholders={
                     "account_name": self.reauth_entry.title,
-                    "developer_url": "https://www.coinbase.com/developer-platform",
                 },
                 errors=errors,
             )
@@ -196,7 +195,6 @@ class CoinbaseConfigFlow(ConfigFlow, domain=DOMAIN):
             data_schema=STEP_USER_DATA_SCHEMA,
             description_placeholders={
                 "account_name": self.reauth_entry.title,
-                "developer_url": "https://www.coinbase.com/developer-platform",
             },
             errors=errors,
         )

homeassistant/components/coinbase/strings.json

@@ -11,7 +11,7 @@
       },
       "reauth_confirm": {
         "title": "Update Coinbase API credentials",
-        "description": "Your current Coinbase API key appears to be for the deprecated v2 API. Please reconfigure with a new API key created for the v3 API. Visit the [Developer Platform]({developer_url}) to create new credentials for {account_name}.",
+        "description": "Your current Coinbase API key appears to be for the deprecated v2 API. Please reconfigure with a new API key created for the v3 API. Visit https://www.coinbase.com/developer-platform  to create new credentials for {account_name}.",
         "data": {
           "api_key": "[%key:common::config_flow::data::api_key%]",
           "api_token": "API secret"

homeassistant/components/comelit/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "local_polling",
   "loggers": ["aiocomelit"],
   "quality_scale": "platinum",
-  "requirements": ["aiocomelit==1.1.2"]
+  "requirements": ["aiocomelit==1.1.1"]
 }

homeassistant/components/comelit/utils.py

@@ -138,7 +138,7 @@ def new_device_listener(
     data_type: str,
 ) -> Callable[[], None]:
     """Subscribe to coordinator updates to check for new devices."""
-    known_devices: dict[str, list[int]] = {}
+    known_devices: set[int] = set()
 
     def _check_devices() -> None:
         """Check for new devices and call callback with any new monitors."""
@@ -147,8 +147,8 @@ def new_device_listener(
 
         new_devices: list[DeviceType] = []
         for _id in coordinator.data[data_type]:
-            if _id not in (id_list := known_devices.get(data_type, [])):
-                known_devices.update({data_type: [*id_list, _id]})
+            if _id not in known_devices:
+                known_devices.add(_id)
                 new_devices.append(coordinator.data[data_type][_id])
 
         if new_devices:

homeassistant/components/control4/media_player.py

@@ -148,15 +148,6 @@ async def async_setup_entry(
                             source_type={dev_type}, idx=dev_id, name=name
                         )
 
-        # Skip rooms with no audio/video sources
-        if not sources:
-            _LOGGER.debug(
-                "Skipping room '%s' (ID: %s) - no audio/video sources found",
-                room.get("name"),
-                room_id,
-            )
-            continue
-
         try:
             hidden = room["roomHidden"]
             entity_list.append(

homeassistant/components/ecobee/config_flow.py

@@ -61,8 +61,5 @@ class EcobeeFlowHandler(ConfigFlow, domain=DOMAIN):
         return self.async_show_form(
             step_id="authorize",
             errors=errors,
-            description_placeholders={
-                "pin": self._ecobee.pin,
-                "auth_url": "https://www.ecobee.com/consumerportal/index.html",
-            },
+            description_placeholders={"pin": self._ecobee.pin},
         )

homeassistant/components/ecobee/strings.json

@@ -8,7 +8,7 @@
         }
       },
       "authorize": {
-        "description": "Please authorize this app at {auth_url} with PIN code:\n\n{pin}\n\nThen, select **Submit**."
+        "description": "Please authorize this app at https://www.ecobee.com/consumerportal/index.html with PIN code:\n\n{pin}\n\nThen, select **Submit**."
       }
     },
     "error": {

homeassistant/components/enphase_envoy/icons.json

@@ -38,25 +38,6 @@
       },
       "available_energy": {
         "default": "mdi:battery-50"
-      },
-      "grid_status": {
-        "default": "mdi:transmission-tower",
-        "state": {
-          "off_grid": "mdi:transmission-tower-off",
-          "synchronizing": "mdi:sync-alert"
-        }
-      },
-      "mid_state": {
-        "default": "mdi:electric-switch-closed",
-        "state": {
-          "open": "mdi:electric-switch"
-        }
-      },
-      "admin_state": {
-        "default": "mdi:transmission-tower",
-        "state": {
-          "off_grid": "mdi:transmission-tower-off"
-        }
       }
     },
     "switch": {

homeassistant/components/enphase_envoy/sensor.py

@@ -824,12 +824,6 @@ class EnvoyCollarSensorEntityDescription(SensorEntityDescription):
     value_fn: Callable[[EnvoyCollar], datetime.datetime | int | float | str]
 
 
-# translations don't accept uppercase
-ADMIN_STATE_MAP = {
-    "ENCMN_MDE_ON_GRID": "on_grid",
-    "ENCMN_MDE_OFF_GRID": "off_grid",
-}
-
 COLLAR_SENSORS = (
     EnvoyCollarSensorEntityDescription(
         key="temperature",
@@ -844,21 +838,11 @@ COLLAR_SENSORS = (
         device_class=SensorDeviceClass.TIMESTAMP,
         value_fn=lambda collar: dt_util.utc_from_timestamp(collar.last_report_date),
     ),
-    # grid_state does not seem to change when off-grid, but rather admin_state_str
     EnvoyCollarSensorEntityDescription(
         key="grid_state",
         translation_key="grid_status",
         value_fn=lambda collar: collar.grid_state,
     ),
-    # grid_status off-grid shows in admin_state rather than in grid_state
-    # map values as translations don't accept uppercase which these are
-    EnvoyCollarSensorEntityDescription(
-        key="admin_state_str",
-        translation_key="admin_state",
-        value_fn=lambda collar: ADMIN_STATE_MAP.get(
-            collar.admin_state_str, collar.admin_state_str
-        ),
-    ),
     EnvoyCollarSensorEntityDescription(
         key="mid_state",
         translation_key="mid_state",

homeassistant/components/enphase_envoy/strings.json

@@ -409,26 +409,10 @@
         "name": "Last report duration"
       },
       "grid_status": {
-        "name": "[%key:component::enphase_envoy::entity::binary_sensor::grid_status::name%]",
-        "state": {
-          "on_grid": "On grid",
-          "off_grid": "Off grid",
-          "synchronizing": "Synchronizing to grid"
-        }
+        "name": "[%key:component::enphase_envoy::entity::binary_sensor::grid_status::name%]"
       },
       "mid_state": {
-        "name": "MID state",
-        "state": {
-          "open": "[%key:common::state::open%]",
-          "close": "[%key:common::state::closed%]"
-        }
-      },
-      "admin_state": {
-        "name": "Admin state",
-        "state": {
-          "on_grid": "[%key:component::enphase_envoy::entity::sensor::grid_status::state::on_grid%]",
-          "off_grid": "[%key:component::enphase_envoy::entity::sensor::grid_status::state::off_grid%]"
-        }
+        "name": "MID state"
       }
     },
     "switch": {

homeassistant/components/esphome/config_flow.py

@@ -500,16 +500,6 @@ class EsphomeFlowHandler(ConfigFlow, domain=DOMAIN):
     ) -> ConfigFlowResult:
         """Handle creating a new entry by removing the old one and creating new."""
         assert self._entry_with_name_conflict is not None
-        if self.source in (SOURCE_REAUTH, SOURCE_RECONFIGURE):
-            return self.async_update_reload_and_abort(
-                self._entry_with_name_conflict,
-                title=self._name,
-                unique_id=self.unique_id,
-                data=self._async_make_config_data(),
-                options={
-                    CONF_ALLOW_SERVICE_CALLS: DEFAULT_NEW_CONFIG_ALLOW_ALLOW_SERVICE_CALLS,
-                },
-            )
         await self.hass.config_entries.async_remove(
             self._entry_with_name_conflict.entry_id
         )

homeassistant/components/esphome/manifest.json

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

homeassistant/components/foscam/coordinator.py

@@ -35,16 +35,9 @@ class FoscamDeviceInfo:
     is_turn_off_volume: bool
     is_turn_off_light: bool
     supports_speak_volume_adjustment: bool
-    supports_pet_adjustment: bool
-    supports_car_adjustment: bool
-    supports_wdr_adjustment: bool
-    supports_hdr_adjustment: bool
 
     is_open_wdr: bool | None = None
     is_open_hdr: bool | None = None
-    is_pet_detection_on: bool | None = None
-    is_car_detection_on: bool | None = None
-    is_human_detection_on: bool | None = None
 
 
 class FoscamCoordinator(DataUpdateCoordinator[FoscamDeviceInfo]):
@@ -114,15 +107,14 @@ class FoscamCoordinator(DataUpdateCoordinator[FoscamDeviceInfo]):
 
         is_open_wdr = None
         is_open_hdr = None
-        reserve3 = product_info.get("reserve4")
+        reserve3 = product_info.get("reserve3")
         reserve3_int = int(reserve3) if reserve3 is not None else 0
-        supports_wdr_adjustment_val = bool(int(reserve3_int & 256))
-        supports_hdr_adjustment_val = bool(int(reserve3_int & 128))
-        if supports_wdr_adjustment_val:
+
+        if (reserve3_int & (1 << 8)) != 0:
             ret_wdr, is_open_wdr_data = self.session.getWdrMode()
             mode = is_open_wdr_data["mode"] if ret_wdr == 0 and is_open_wdr_data else 0
             is_open_wdr = bool(int(mode))
-        elif supports_hdr_adjustment_val:
+        else:
             ret_hdr, is_open_hdr_data = self.session.getHdrMode()
             mode = is_open_hdr_data["mode"] if ret_hdr == 0 and is_open_hdr_data else 0
             is_open_hdr = bool(int(mode))
@@ -134,34 +126,6 @@ class FoscamCoordinator(DataUpdateCoordinator[FoscamDeviceInfo]):
             if ret_sw == 0
             else False
         )
-        pet_adjustment_val = (
-            bool(int(software_capabilities.get("swCapabilities2")) & 512)
-            if ret_sw == 0
-            else False
-        )
-        car_adjustment_val = (
-            bool(int(software_capabilities.get("swCapabilities2")) & 256)
-            if ret_sw == 0
-            else False
-        )
-        ret_md, mothion_config_val = self.session.get_motion_detect_config()
-        if pet_adjustment_val:
-            is_pet_detection_on_val = (
-                mothion_config_val["petEnable"] == "1" if ret_md == 0 else False
-            )
-        else:
-            is_pet_detection_on_val = False
-
-        if car_adjustment_val:
-            is_car_detection_on_val = (
-                mothion_config_val["carEnable"] == "1" if ret_md == 0 else False
-            )
-        else:
-            is_car_detection_on_val = False
-
-        is_human_detection_on_val = (
-            mothion_config_val["humanEnable"] == "1" if ret_md == 0 else False
-        )
 
         return FoscamDeviceInfo(
             dev_info=dev_info,
@@ -177,15 +141,8 @@ class FoscamCoordinator(DataUpdateCoordinator[FoscamDeviceInfo]):
             is_turn_off_volume=is_turn_off_volume_val,
             is_turn_off_light=is_turn_off_light_val,
             supports_speak_volume_adjustment=supports_speak_volume_adjustment_val,
-            supports_pet_adjustment=pet_adjustment_val,
-            supports_car_adjustment=car_adjustment_val,
-            supports_hdr_adjustment=supports_hdr_adjustment_val,
-            supports_wdr_adjustment=supports_wdr_adjustment_val,
             is_open_wdr=is_open_wdr,
             is_open_hdr=is_open_hdr,
-            is_pet_detection_on=is_pet_detection_on_val,
-            is_car_detection_on=is_car_detection_on_val,
-            is_human_detection_on=is_human_detection_on_val,
         )
 
     async def _async_update_data(self) -> FoscamDeviceInfo:

homeassistant/components/foscam/icons.json

@@ -38,15 +38,6 @@
       },
       "wdr_switch": {
         "default": "mdi:alpha-w-box"
-      },
-      "pet_detection": {
-        "default": "mdi:paw"
-      },
-      "car_detection": {
-        "default": "mdi:car-hatchback"
-      },
-      "human_detection": {
-        "default": "mdi:human"
       }
     },
     "number": {

homeassistant/components/foscam/number.py

@@ -22,7 +22,7 @@ class FoscamNumberEntityDescription(NumberEntityDescription):
 
     native_value_fn: Callable[[FoscamCoordinator], int]
     set_value_fn: Callable[[FoscamCamera, float], Any]
-    exists_fn: Callable[[FoscamCoordinator], bool] = lambda _: True
+    exists_fn: Callable[[FoscamCoordinator], bool]
 
 
 NUMBER_DESCRIPTIONS: list[FoscamNumberEntityDescription] = [
@@ -34,6 +34,7 @@ NUMBER_DESCRIPTIONS: list[FoscamNumberEntityDescription] = [
         native_step=1,
         native_value_fn=lambda coordinator: coordinator.data.device_volume,
         set_value_fn=lambda session, value: session.setAudioVolume(value),
+        exists_fn=lambda _: True,
     ),
     FoscamNumberEntityDescription(
         key="speak_volume",

homeassistant/components/foscam/strings.json

@@ -61,15 +61,6 @@
       },
       "wdr_switch": {
         "name": "WDR"
-      },
-      "pet_detection": {
-        "name": "Pet detection"
-      },
-      "car_detection": {
-        "name": "Car detection"
-      },
-      "human_detection": {
-        "name": "Human detection"
       }
     },
     "number": {

homeassistant/components/foscam/switch.py

@@ -30,14 +30,6 @@ def handle_ir_turn_off(session: FoscamCamera) -> None:
     session.close_infra_led()
 
 
-def set_motion_detection(session: FoscamCamera, field: str, enabled: bool) -> None:
-    """Turns on pet detection."""
-    ret, config = session.get_motion_detect_config()
-    if not ret:
-        config[field] = int(enabled)
-        session.set_motion_detect_config(config)
-
-
 @dataclass(frozen=True, kw_only=True)
 class FoscamSwitchEntityDescription(SwitchEntityDescription):
     """A custom entity description that supports a turn_off function."""
@@ -45,7 +37,6 @@ class FoscamSwitchEntityDescription(SwitchEntityDescription):
     native_value_fn: Callable[..., bool]
     turn_off_fn: Callable[[FoscamCamera], None]
     turn_on_fn: Callable[[FoscamCamera], None]
-    exists_fn: Callable[[FoscamCoordinator], bool] = lambda _: True
 
 
 SWITCH_DESCRIPTIONS: list[FoscamSwitchEntityDescription] = [
@@ -111,7 +102,6 @@ SWITCH_DESCRIPTIONS: list[FoscamSwitchEntityDescription] = [
         native_value_fn=lambda data: data.is_open_hdr,
         turn_off_fn=lambda session: session.setHdrMode(0),
         turn_on_fn=lambda session: session.setHdrMode(1),
-        exists_fn=lambda coordinator: coordinator.data.supports_hdr_adjustment,
     ),
     FoscamSwitchEntityDescription(
         key="is_open_wdr",
@@ -119,30 +109,6 @@ SWITCH_DESCRIPTIONS: list[FoscamSwitchEntityDescription] = [
         native_value_fn=lambda data: data.is_open_wdr,
         turn_off_fn=lambda session: session.setWdrMode(0),
         turn_on_fn=lambda session: session.setWdrMode(1),
-        exists_fn=lambda coordinator: coordinator.data.supports_wdr_adjustment,
-    ),
-    FoscamSwitchEntityDescription(
-        key="pet_detection",
-        translation_key="pet_detection",
-        native_value_fn=lambda data: data.is_pet_detection_on,
-        turn_off_fn=lambda session: set_motion_detection(session, "petEnable", False),
-        turn_on_fn=lambda session: set_motion_detection(session, "petEnable", True),
-        exists_fn=lambda coordinator: coordinator.data.supports_pet_adjustment,
-    ),
-    FoscamSwitchEntityDescription(
-        key="car_detection",
-        translation_key="car_detection",
-        native_value_fn=lambda data: data.is_car_detection_on,
-        turn_off_fn=lambda session: set_motion_detection(session, "carEnable", False),
-        turn_on_fn=lambda session: set_motion_detection(session, "carEnable", True),
-        exists_fn=lambda coordinator: coordinator.data.supports_car_adjustment,
-    ),
-    FoscamSwitchEntityDescription(
-        key="human_detection",
-        translation_key="human_detection",
-        native_value_fn=lambda data: data.is_human_detection_on,
-        turn_off_fn=lambda session: set_motion_detection(session, "humanEnable", False),
-        turn_on_fn=lambda session: set_motion_detection(session, "humanEnable", True),
     ),
 ]
 
@@ -156,11 +122,24 @@ async def async_setup_entry(
 
     coordinator = config_entry.runtime_data
 
-    async_add_entities(
-        FoscamGenericSwitch(coordinator, description)
-        for description in SWITCH_DESCRIPTIONS
-        if description.exists_fn(coordinator)
-    )
+    entities = []
+
+    product_info = coordinator.data.product_info
+    reserve3 = product_info.get("reserve3", "0")
+
+    for description in SWITCH_DESCRIPTIONS:
+        if description.key == "is_asleep":
+            if not coordinator.data.is_asleep["supported"]:
+                continue
+        elif description.key == "is_open_hdr":
+            if ((1 << 8) & int(reserve3)) != 0 or ((1 << 7) & int(reserve3)) == 0:
+                continue
+        elif description.key == "is_open_wdr":
+            if ((1 << 8) & int(reserve3)) == 0:
+                continue
+
+        entities.append(FoscamGenericSwitch(coordinator, description))
+    async_add_entities(entities)
 
 
 class FoscamGenericSwitch(FoscamEntity, SwitchEntity):

homeassistant/components/frontend/__init__.py

@@ -453,7 +453,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     hass.http.app.router.register_resource(IndexView(repo_path, hass))
 
     async_register_built_in_panel(hass, "light")
-    async_register_built_in_panel(hass, "safety")
+    async_register_built_in_panel(hass, "security")
     async_register_built_in_panel(hass, "climate")
 
     async_register_built_in_panel(hass, "profile")

homeassistant/components/generic/config_flow.py

@@ -191,9 +191,7 @@ async def async_test_still(
     try:
         async_client = get_async_client(hass, verify_ssl=verify_ssl)
         async with asyncio.timeout(GET_IMAGE_TIMEOUT):
-            response = await async_client.get(
-                url, auth=auth, timeout=GET_IMAGE_TIMEOUT, follow_redirects=True
-            )
+            response = await async_client.get(url, auth=auth, timeout=GET_IMAGE_TIMEOUT)
             response.raise_for_status()
             image = response.content
     except (

homeassistant/components/growatt_server/const.py

@@ -36,7 +36,7 @@ DEFAULT_URL = SERVER_URLS[0]
 
 DOMAIN = "growatt_server"
 
-PLATFORMS = [Platform.SENSOR, Platform.SWITCH]
+PLATFORMS = [Platform.SENSOR]
 
 LOGIN_INVALID_AUTH_CODE = "502"
 

homeassistant/components/growatt_server/sensor/tlx.py

@@ -210,15 +210,6 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         device_class=SensorDeviceClass.POWER,
         precision=1,
     ),
-    GrowattSensorEntityDescription(
-        key="tlx_solar_generation_today",
-        translation_key="tlx_solar_generation_today",
-        api_key="epvToday",
-        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
-        device_class=SensorDeviceClass.ENERGY,
-        state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
-    ),
     GrowattSensorEntityDescription(
         key="tlx_solar_generation_total",
         translation_key="tlx_solar_generation_total",
@@ -439,120 +430,4 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=PERCENTAGE,
         device_class=SensorDeviceClass.BATTERY,
     ),
-    GrowattSensorEntityDescription(
-        key="tlx_pac_to_local_load",
-        translation_key="tlx_pac_to_local_load",
-        api_key="pacToLocalLoad",
-        native_unit_of_measurement=UnitOfPower.WATT,
-        device_class=SensorDeviceClass.POWER,
-        precision=1,
-    ),
-    GrowattSensorEntityDescription(
-        key="tlx_pac_to_user_total",
-        translation_key="tlx_pac_to_user_total",
-        api_key="pacToUserTotal",
-        native_unit_of_measurement=UnitOfPower.WATT,
-        device_class=SensorDeviceClass.POWER,
-        precision=1,
-    ),
-    GrowattSensorEntityDescription(
-        key="tlx_pac_to_grid_total",
-        translation_key="tlx_pac_to_grid_total",
-        api_key="pacToGridTotal",
-        native_unit_of_measurement=UnitOfPower.WATT,
-        device_class=SensorDeviceClass.POWER,
-        precision=1,
-    ),
-    GrowattSensorEntityDescription(
-        key="tlx_system_production_today",
-        translation_key="tlx_system_production_today",
-        api_key="esystemToday",
-        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
-        device_class=SensorDeviceClass.ENERGY,
-        state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
-    ),
-    GrowattSensorEntityDescription(
-        key="tlx_system_production_total",
-        translation_key="tlx_system_production_total",
-        api_key="esystemTotal",
-        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
-        device_class=SensorDeviceClass.ENERGY,
-        state_class=SensorStateClass.TOTAL_INCREASING,
-        never_resets=True,
-        precision=1,
-    ),
-    GrowattSensorEntityDescription(
-        key="tlx_self_consumption_today",
-        translation_key="tlx_self_consumption_today",
-        api_key="eselfToday",
-        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
-        device_class=SensorDeviceClass.ENERGY,
-        state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
-    ),
-    GrowattSensorEntityDescription(
-        key="tlx_self_consumption_total",
-        translation_key="tlx_self_consumption_total",
-        api_key="eselfTotal",
-        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
-        device_class=SensorDeviceClass.ENERGY,
-        state_class=SensorStateClass.TOTAL_INCREASING,
-        never_resets=True,
-        precision=1,
-    ),
-    GrowattSensorEntityDescription(
-        key="tlx_import_from_grid_today",
-        translation_key="tlx_import_from_grid_today",
-        api_key="etoUserToday",
-        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
-        device_class=SensorDeviceClass.ENERGY,
-        state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
-    ),
-    GrowattSensorEntityDescription(
-        key="tlx_import_from_grid_total",
-        translation_key="tlx_import_from_grid_total",
-        api_key="etoUserTotal",
-        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
-        device_class=SensorDeviceClass.ENERGY,
-        state_class=SensorStateClass.TOTAL_INCREASING,
-        never_resets=True,
-        precision=1,
-    ),
-    GrowattSensorEntityDescription(
-        key="tlx_batteries_charged_from_grid_today",
-        translation_key="tlx_batteries_charged_from_grid_today",
-        api_key="eacChargeToday",
-        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
-        device_class=SensorDeviceClass.ENERGY,
-        state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
-    ),
-    GrowattSensorEntityDescription(
-        key="tlx_batteries_charged_from_grid_total",
-        translation_key="tlx_batteries_charged_from_grid_total",
-        api_key="eacChargeTotal",
-        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
-        device_class=SensorDeviceClass.ENERGY,
-        state_class=SensorStateClass.TOTAL_INCREASING,
-        never_resets=True,
-        precision=1,
-    ),
-    GrowattSensorEntityDescription(
-        key="tlx_p_system",
-        translation_key="tlx_p_system",
-        api_key="psystem",
-        native_unit_of_measurement=UnitOfPower.WATT,
-        device_class=SensorDeviceClass.POWER,
-        precision=1,
-    ),
-    GrowattSensorEntityDescription(
-        key="tlx_p_self",
-        translation_key="tlx_p_self",
-        api_key="pself",
-        native_unit_of_measurement=UnitOfPower.WATT,
-        device_class=SensorDeviceClass.POWER,
-        precision=1,
-    ),
 )

homeassistant/components/growatt_server/strings.json

@@ -362,9 +362,6 @@
       "tlx_wattage_input_4": {
         "name": "Input 4 wattage"
       },
-      "tlx_solar_generation_today": {
-        "name": "Solar energy today"
-      },
       "tlx_solar_generation_total": {
         "name": "Lifetime total solar energy"
       },
@@ -446,45 +443,6 @@
       "tlx_statement_of_charge": {
         "name": "State of charge (SoC)"
       },
-      "tlx_pac_to_local_load": {
-        "name": "Local load power"
-      },
-      "tlx_pac_to_user_total": {
-        "name": "Import power"
-      },
-      "tlx_pac_to_grid_total": {
-        "name": "Export power"
-      },
-      "tlx_system_production_today": {
-        "name": "System production today"
-      },
-      "tlx_system_production_total": {
-        "name": "Lifetime system production"
-      },
-      "tlx_self_consumption_today": {
-        "name": "Self consumption today"
-      },
-      "tlx_self_consumption_total": {
-        "name": "Lifetime self consumption"
-      },
-      "tlx_import_from_grid_today": {
-        "name": "Import from grid today"
-      },
-      "tlx_import_from_grid_total": {
-        "name": "Lifetime import from grid"
-      },
-      "tlx_batteries_charged_from_grid_today": {
-        "name": "Batteries charged from grid today"
-      },
-      "tlx_batteries_charged_from_grid_total": {
-        "name": "Lifetime batteries charged from grid"
-      },
-      "tlx_p_system": {
-        "name": "System power"
-      },
-      "tlx_p_self": {
-        "name": "Self power"
-      },
       "total_money_today": {
         "name": "Total money today"
       },
@@ -503,11 +461,6 @@
       "total_maximum_output": {
         "name": "Maximum power"
       }
-    },
-    "switch": {
-      "ac_charge": {
-        "name": "Charge from grid"
-      }
     }
   }
 }

homeassistant/components/growatt_server/switch.py

@@ -1,138 +0,0 @@
-"""Switch platform for Growatt."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-import logging
-from typing import Any
-
-from growattServer import GrowattV1ApiError
-
-from homeassistant.components.switch import SwitchEntity, SwitchEntityDescription
-from homeassistant.const import EntityCategory
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from .const import DOMAIN
-from .coordinator import GrowattConfigEntry, GrowattCoordinator
-from .sensor.sensor_entity_description import GrowattRequiredKeysMixin
-
-_LOGGER = logging.getLogger(__name__)
-
-PARALLEL_UPDATES = (
-    1  # Serialize updates as inverter does not handle concurrent requests
-)
-
-
-@dataclass(frozen=True, kw_only=True)
-class GrowattSwitchEntityDescription(SwitchEntityDescription, GrowattRequiredKeysMixin):
-    """Describes Growatt switch entity."""
-
-    write_key: str | None = None  # Parameter ID for writing (if different from api_key)
-
-
-# Note that the Growatt V1 API uses different keys for reading and writing parameters.
-# Reading values returns camelCase keys, while writing requires snake_case keys.
-
-MIN_SWITCH_TYPES: tuple[GrowattSwitchEntityDescription, ...] = (
-    GrowattSwitchEntityDescription(
-        key="ac_charge",
-        translation_key="ac_charge",
-        api_key="acChargeEnable",  # Key returned by V1 API
-        write_key="ac_charge",  # Key used to write parameter
-    ),
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: GrowattConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Growatt switch entities."""
-    runtime_data = entry.runtime_data
-
-    # Add switch entities for each MIN device (only supported with V1 API)
-    async_add_entities(
-        GrowattSwitch(device_coordinator, description)
-        for device_coordinator in runtime_data.devices.values()
-        if (
-            device_coordinator.device_type == "min"
-            and device_coordinator.api_version == "v1"
-        )
-        for description in MIN_SWITCH_TYPES
-    )
-
-
-class GrowattSwitch(CoordinatorEntity[GrowattCoordinator], SwitchEntity):
-    """Representation of a Growatt switch."""
-
-    _attr_has_entity_name = True
-    _attr_entity_category = EntityCategory.CONFIG
-    entity_description: GrowattSwitchEntityDescription
-
-    def __init__(
-        self,
-        coordinator: GrowattCoordinator,
-        description: GrowattSwitchEntityDescription,
-    ) -> None:
-        """Initialize the switch."""
-        super().__init__(coordinator)
-        self.entity_description = description
-        self._attr_unique_id = f"{coordinator.device_id}_{description.key}"
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, coordinator.device_id)},
-            manufacturer="Growatt",
-            name=coordinator.device_id,
-        )
-
-    @property
-    def is_on(self) -> bool | None:
-        """Return true if the switch is on."""
-        value = self.coordinator.data.get(self.entity_description.api_key)
-        if value is None:
-            return None
-
-        # API returns integer 1 for enabled, 0 for disabled
-        return bool(value)
-
-    async def async_turn_on(self, **kwargs: Any) -> None:
-        """Turn the switch on."""
-        await self._async_set_state(True)
-
-    async def async_turn_off(self, **kwargs: Any) -> None:
-        """Turn the switch off."""
-        await self._async_set_state(False)
-
-    async def _async_set_state(self, state: bool) -> None:
-        """Set the switch state."""
-        # Use write_key if specified, otherwise fall back to api_key
-        parameter_id = (
-            self.entity_description.write_key or self.entity_description.api_key
-        )
-        api_value = int(state)
-
-        try:
-            # Use V1 API to write parameter
-            await self.hass.async_add_executor_job(
-                self.coordinator.api.min_write_parameter,
-                self.coordinator.device_id,
-                parameter_id,
-                api_value,
-            )
-        except GrowattV1ApiError as e:
-            raise HomeAssistantError(f"Error while setting switch state: {e}") from e
-
-        # If no exception was raised, the write was successful
-        _LOGGER.debug(
-            "Set switch %s to %s",
-            parameter_id,
-            api_value,
-        )
-
-        # Update the value in coordinator data (keep as integer like API returns)
-        self.coordinator.data[self.entity_description.api_key] = api_value
-        self.async_write_ha_state()

homeassistant/components/habitica/todo.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 from enum import StrEnum
 import logging
-import math
 from typing import TYPE_CHECKING
 from uuid import UUID
 
@@ -282,7 +281,7 @@ class HabiticaTodosListEntity(BaseHabiticaListEntity):
         return sorted(
             tasks,
             key=lambda task: (
-                math.inf
+                float("inf")
                 if (uid := UUID(task.uid))
                 not in (tasks_order := self.coordinator.data.user.tasksOrder.todos)
                 else tasks_order.index(uid)
@@ -368,7 +367,7 @@ class HabiticaDailiesListEntity(BaseHabiticaListEntity):
         return sorted(
             tasks,
             key=lambda task: (
-                math.inf
+                float("inf")
                 if (uid := UUID(task.uid))
                 not in (tasks_order := self.coordinator.data.user.tasksOrder.dailys)
                 else tasks_order.index(uid)

homeassistant/components/homeassistant_connect_zbt2/config_flow.py

@@ -7,18 +7,11 @@ from typing import TYPE_CHECKING, Any, Protocol
 
 from homeassistant.components import usb
 from homeassistant.components.homeassistant_hardware import firmware_config_flow
-from homeassistant.components.homeassistant_hardware.helpers import (
-    HardwareFirmwareDiscoveryInfo,
-)
 from homeassistant.components.homeassistant_hardware.util import (
     ApplicationType,
     FirmwareInfo,
     ResetTarget,
 )
-from homeassistant.components.usb import (
-    usb_service_info_from_device,
-    usb_unique_id_from_service_info,
-)
 from homeassistant.config_entries import (
     ConfigEntry,
     ConfigEntryBaseFlow,
@@ -130,16 +123,22 @@ class HomeAssistantConnectZBT2ConfigFlow(
 
     async def async_step_usb(self, discovery_info: UsbServiceInfo) -> ConfigFlowResult:
         """Handle usb discovery."""
-        unique_id = usb_unique_id_from_service_info(discovery_info)
+        device = discovery_info.device
+        vid = discovery_info.vid
+        pid = discovery_info.pid
+        serial_number = discovery_info.serial_number
+        manufacturer = discovery_info.manufacturer
+        description = discovery_info.description
+        unique_id = f"{vid}:{pid}_{serial_number}_{manufacturer}_{description}"
 
-        discovery_info.device = await self.hass.async_add_executor_job(
+        device = discovery_info.device = await self.hass.async_add_executor_job(
             usb.get_serial_by_id, discovery_info.device
         )
 
         try:
             await self.async_set_unique_id(unique_id)
         finally:
-            self._abort_if_unique_id_configured(updates={DEVICE: discovery_info.device})
+            self._abort_if_unique_id_configured(updates={DEVICE: device})
 
         self._usb_info = discovery_info
 
@@ -149,24 +148,6 @@ class HomeAssistantConnectZBT2ConfigFlow(
 
         return await self.async_step_confirm()
 
-    async def async_step_import(
-        self, fw_discovery_info: HardwareFirmwareDiscoveryInfo
-    ) -> ConfigFlowResult:
-        """Handle import from ZHA/OTBR firmware notification."""
-        assert fw_discovery_info["usb_device"] is not None
-        usb_info = usb_service_info_from_device(fw_discovery_info["usb_device"])
-        unique_id = usb_unique_id_from_service_info(usb_info)
-
-        if await self.async_set_unique_id(unique_id, raise_on_progress=False):
-            self._abort_if_unique_id_configured(updates={DEVICE: usb_info.device})
-
-        self._usb_info = usb_info
-        self._device = usb_info.device
-        self._hardware_name = HARDWARE_NAME
-        self._probed_firmware_info = fw_discovery_info["firmware_info"]
-
-        return self._async_flow_finished()
-
     def _async_flow_finished(self) -> ConfigFlowResult:
         """Create the config entry."""
         assert self._usb_info is not None

homeassistant/components/homeassistant_hardware/const.py

@@ -19,12 +19,6 @@ DATA_COMPONENT: HassKey[HardwareInfoDispatcher] = HassKey(DOMAIN)
 ZHA_DOMAIN = "zha"
 OTBR_DOMAIN = "otbr"
 
-HARDWARE_INTEGRATION_DOMAINS = {
-    "homeassistant_sky_connect",
-    "homeassistant_connect_zbt2",
-    "homeassistant_yellow",
-}
-
 OTBR_ADDON_NAME = "OpenThread Border Router"
 OTBR_ADDON_MANAGER_DATA = "openthread_border_router"
 OTBR_ADDON_SLUG = "core_openthread_border_router"

homeassistant/components/homeassistant_hardware/helpers.py

@@ -6,33 +6,19 @@ from collections import defaultdict
 from collections.abc import AsyncIterator, Awaitable, Callable
 from contextlib import asynccontextmanager
 import logging
-from typing import TYPE_CHECKING, Protocol, TypedDict
+from typing import TYPE_CHECKING, Protocol
 
-from homeassistant.components.usb import (
-    USBDevice,
-    async_get_usb_matchers_for_device,
-    usb_device_from_path,
-)
-from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback as hass_callback
 
 from . import DATA_COMPONENT
-from .const import HARDWARE_INTEGRATION_DOMAINS
 
 if TYPE_CHECKING:
     from .util import FirmwareInfo
 
-
 _LOGGER = logging.getLogger(__name__)
 
 
-class HardwareFirmwareDiscoveryInfo(TypedDict):
-    """Data for triggering hardware integration discovery via firmware notification."""
-
-    usb_device: USBDevice | None
-    firmware_info: FirmwareInfo
-
-
 class SyncHardwareFirmwareInfoModule(Protocol):
     """Protocol type for Home Assistant Hardware firmware info platform modules."""
 
@@ -60,23 +46,6 @@ type HardwareFirmwareInfoModule = (
 )
 
 
-@hass_callback
-def async_get_hardware_domain_for_usb_device(
-    hass: HomeAssistant, usb_device: USBDevice
-) -> str | None:
-    """Identify which hardware domain should handle a USB device."""
-    matched = async_get_usb_matchers_for_device(hass, usb_device)
-    hw_domains = {match["domain"] for match in matched} & HARDWARE_INTEGRATION_DOMAINS
-
-    if not hw_domains:
-        return None
-
-    # We can never have two hardware integrations overlap in discovery
-    assert len(hw_domains) == 1
-
-    return list(hw_domains)[0]
-
-
 class HardwareInfoDispatcher:
     """Central dispatcher for hardware/firmware information."""
 
@@ -125,7 +94,7 @@ class HardwareInfoDispatcher:
             "Received firmware info notification from %r: %s", domain, firmware_info
         )
 
-        for callback in list(self._notification_callbacks[firmware_info.device]):
+        for callback in self._notification_callbacks.get(firmware_info.device, []):
             try:
                 callback(firmware_info)
             except Exception:
@@ -133,48 +102,6 @@ class HardwareInfoDispatcher:
                     "Error while notifying firmware info listener %s", callback
                 )
 
-        await self._async_trigger_hardware_discovery(firmware_info)
-
-    async def _async_trigger_hardware_discovery(
-        self, firmware_info: FirmwareInfo
-    ) -> None:
-        """Trigger hardware integration config flows from firmware info.
-
-        Identifies which hardware integration should handle the device based on
-        USB matchers, then triggers an import flow for only that integration.
-        """
-
-        usb_device = await self.hass.async_add_executor_job(
-            usb_device_from_path, firmware_info.device
-        )
-
-        if usb_device is None:
-            _LOGGER.debug("Cannot find USB for path %s", firmware_info.device)
-            return
-
-        hardware_domain = async_get_hardware_domain_for_usb_device(
-            self.hass, usb_device
-        )
-
-        if hardware_domain is None:
-            _LOGGER.debug("No hardware integration found for device %s", usb_device)
-            return
-
-        _LOGGER.debug(
-            "Triggering %s import flow for device %s",
-            hardware_domain,
-            firmware_info.device,
-        )
-
-        await self.hass.config_entries.flow.async_init(
-            hardware_domain,
-            context={"source": SOURCE_IMPORT},
-            data=HardwareFirmwareDiscoveryInfo(
-                usb_device=usb_device,
-                firmware_info=firmware_info,
-            ),
-        )
-
     async def iter_firmware_info(self) -> AsyncIterator[FirmwareInfo]:
         """Iterate over all firmware information for all hardware."""
         for domain, fw_info_module in self._providers.items():

homeassistant/components/homeassistant_hardware/manifest.json

@@ -3,7 +3,6 @@
   "name": "Home Assistant Hardware",
   "after_dependencies": ["hassio"],
   "codeowners": ["@home-assistant/core"],
-  "dependencies": ["usb"],
   "documentation": "https://www.home-assistant.io/integrations/homeassistant_hardware",
   "integration_type": "system",
   "requirements": [

homeassistant/components/homeassistant_sky_connect/config_flow.py

@@ -10,17 +10,10 @@ from homeassistant.components.homeassistant_hardware import (
     firmware_config_flow,
     silabs_multiprotocol_addon,
 )
-from homeassistant.components.homeassistant_hardware.helpers import (
-    HardwareFirmwareDiscoveryInfo,
-)
 from homeassistant.components.homeassistant_hardware.util import (
     ApplicationType,
     FirmwareInfo,
 )
-from homeassistant.components.usb import (
-    usb_service_info_from_device,
-    usb_unique_id_from_service_info,
-)
 from homeassistant.config_entries import (
     ConfigEntry,
     ConfigEntryBaseFlow,
@@ -149,10 +142,16 @@ class HomeAssistantSkyConnectConfigFlow(
 
     async def async_step_usb(self, discovery_info: UsbServiceInfo) -> ConfigFlowResult:
         """Handle usb discovery."""
-        unique_id = usb_unique_id_from_service_info(discovery_info)
+        device = discovery_info.device
+        vid = discovery_info.vid
+        pid = discovery_info.pid
+        serial_number = discovery_info.serial_number
+        manufacturer = discovery_info.manufacturer
+        description = discovery_info.description
+        unique_id = f"{vid}:{pid}_{serial_number}_{manufacturer}_{description}"
 
         if await self.async_set_unique_id(unique_id):
-            self._abort_if_unique_id_configured(updates={DEVICE: discovery_info.device})
+            self._abort_if_unique_id_configured(updates={DEVICE: device})
 
         discovery_info.device = await self.hass.async_add_executor_job(
             usb.get_serial_by_id, discovery_info.device
@@ -160,10 +159,8 @@ class HomeAssistantSkyConnectConfigFlow(
 
         self._usb_info = discovery_info
 
-        assert discovery_info.description is not None
-        self._hw_variant = HardwareVariant.from_usb_product_name(
-            discovery_info.description
-        )
+        assert description is not None
+        self._hw_variant = HardwareVariant.from_usb_product_name(description)
 
         # Set parent class attributes
         self._device = self._usb_info.device
@@ -171,26 +168,6 @@ class HomeAssistantSkyConnectConfigFlow(
 
         return await self.async_step_confirm()
 
-    async def async_step_import(
-        self, fw_discovery_info: HardwareFirmwareDiscoveryInfo
-    ) -> ConfigFlowResult:
-        """Handle import from ZHA/OTBR firmware notification."""
-        assert fw_discovery_info["usb_device"] is not None
-        usb_info = usb_service_info_from_device(fw_discovery_info["usb_device"])
-        unique_id = usb_unique_id_from_service_info(usb_info)
-
-        if await self.async_set_unique_id(unique_id, raise_on_progress=False):
-            self._abort_if_unique_id_configured(updates={DEVICE: usb_info.device})
-
-        self._usb_info = usb_info
-        assert usb_info.description is not None
-        self._hw_variant = HardwareVariant.from_usb_product_name(usb_info.description)
-        self._device = usb_info.device
-        self._hardware_name = self._hw_variant.full_name
-        self._probed_firmware_info = fw_discovery_info["firmware_info"]
-
-        return self._async_flow_finished()
-
     def _async_flow_finished(self) -> ConfigFlowResult:
         """Create the config entry."""
         assert self._usb_info is not None

homeassistant/components/homeassistant_yellow/__init__.py

@@ -41,7 +41,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
     firmware = ApplicationType(entry.data[FIRMWARE])
 
-    # Auto start the multiprotocol addon if it is in use
     if firmware is ApplicationType.CPC:
         try:
             await check_multi_pan_addon(hass)

homeassistant/components/huawei_lte/config_flow.py

@@ -112,9 +112,6 @@ class HuaweiLteConfigFlow(ConfigFlow, domain=DOMAIN):
                 }
             ),
             errors=errors or {},
-            description_placeholders={
-                "sample_ip": "http://192.168.X.1",
-            },
         )
 
     async def _async_show_reauth_form(
@@ -135,9 +132,6 @@ class HuaweiLteConfigFlow(ConfigFlow, domain=DOMAIN):
                 }
             ),
             errors=errors or {},
-            description_placeholders={
-                "sample_ip": "http://192.168.X.1",
-            },
         )
 
     async def _connect(
@@ -412,10 +406,4 @@ class HuaweiLteOptionsFlow(OptionsFlow):
                 ): bool,
             }
         )
-        return self.async_show_form(
-            step_id="init",
-            data_schema=data_schema,
-            description_placeholders={
-                "sample_ip": "http://192.168.X.1",
-            },
-        )
+        return self.async_show_form(step_id="init", data_schema=data_schema)

homeassistant/components/huawei_lte/strings.json

@@ -41,7 +41,7 @@
         },
         "data_description": {
           "password": "Password for accessing the router's API. Typically, the same as the one used for the router's web interface.",
-          "url": "Base URL to the API of the router. Typically, something like `{sample_ip}`. This is the beginning of the location shown in a browser when accessing the router's web interface.",
+          "url": "Base URL to the API of the router. Typically, something like `http://192.168.X.1`. This is the beginning of the location shown in a browser when accessing the router's web interface.",
           "username": "Username for accessing the router's API. Typically, the same as the one used for the router's web interface. Usually, either `admin`, or left empty (recommended if that works).",
           "verify_ssl": "Whether to verify the SSL certificate of the router when accessing it. Applicable only if the router is accessed via HTTPS."
         },

homeassistant/components/hue/strings.json

@@ -68,7 +68,6 @@
       "initial_press": "\"{subtype}\" pressed initially",
       "repeat": "\"{subtype}\" held down",
       "short_release": "\"{subtype}\" released after short press",
-      "long_press": "\"{subtype}\" long pressed",
       "long_release": "[%key:component::hue::device_automation::trigger_type::remote_button_long_release%]",
       "double_short_release": "[%key:component::hue::device_automation::trigger_type::remote_double_button_short_press%]",
       "start": "[%key:component::hue::device_automation::trigger_type::initial_press%]"

homeassistant/components/icloud/account.py

@@ -125,8 +125,9 @@ class IcloudAccount:
             return
 
         try:
+            api_devices = self.api.devices
             # Gets device owners infos
-            user_info = self.api.devices.user_info
+            user_info = api_devices.response["userInfo"]
         except (
             PyiCloudServiceNotActivatedException,
             PyiCloudNoDevicesException,

homeassistant/components/icloud/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/icloud",
   "iot_class": "cloud_polling",
   "loggers": ["keyrings.alt", "pyicloud"],
-  "requirements": ["pyicloud==2.1.0"]
+  "requirements": ["pyicloud==2.0.3"]
 }

homeassistant/components/igloohome/config_flow.py

@@ -13,7 +13,7 @@ from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
 from homeassistant.const import CONF_CLIENT_ID, CONF_CLIENT_SECRET
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
-from .const import API_ACCESS_URL, DOMAIN
+from .const import DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -57,8 +57,5 @@ class IgloohomeConfigFlow(ConfigFlow, domain=DOMAIN):
                 )
 
         return self.async_show_form(
-            step_id="user",
-            data_schema=STEP_USER_DATA_SCHEMA,
-            errors=errors,
-            description_placeholders={"api_access_url": API_ACCESS_URL},
+            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
         )

homeassistant/components/igloohome/const.py

@@ -1,4 +1,3 @@
 """Constants for the igloohome integration."""
 
 DOMAIN = "igloohome"
-API_ACCESS_URL = "https://access.igloocompany.co/api-access"

homeassistant/components/igloohome/strings.json

@@ -2,7 +2,7 @@
   "config": {
     "step": {
       "user": {
-        "description": "Copy & paste your [API access credentials]({api_access_url}) to give Home Assistant access to your account.",
+        "description": "Copy & paste your [API access credentials](https://access.igloocompany.co/api-access) to give Home Assistant access to your account.",
         "data": {
           "client_id": "Client ID",
           "client_secret": "Client secret"

homeassistant/components/improv_ble/config_flow.py

@@ -138,23 +138,11 @@ class ImprovBLEConfigFlow(ConfigFlow, domain=DOMAIN):
             _LOGGER.debug(
                 (
                     "Aborting improv flow, device with bluetooth address '%s' is "
-                    "already provisioned: %s; clearing match history to allow "
-                    "rediscovery if device is factory reset"
+                    "already provisioned: %s"
                 ),
                 self._discovery_info.address,
                 improv_service_data.state,
             )
-            # Clear match history so device can be rediscovered if factory reset.
-            # This is safe to do on every abort because:
-            # 1. While device stays provisioned, the Bluetooth matcher won't trigger
-            #    new discoveries since the advertisement content hasn't changed
-            # 2. If device is factory reset (state changes to authorized), the
-            #    matcher will see new content and trigger discovery since we cleared
-            #    the history
-            # 3. No ongoing monitoring or callbacks - zero performance overhead
-            bluetooth.async_clear_address_from_match_history(
-                self.hass, self._discovery_info.address
-            )
             raise AbortFlow("already_provisioned")
 
     @callback
@@ -170,12 +158,6 @@ class ImprovBLEConfigFlow(ConfigFlow, domain=DOMAIN):
         )
 
         self._discovery_info = service_info
-
-        # Update title placeholders if name changed
-        name = service_info.name or service_info.address
-        if self.context.get("title_placeholders", {}).get("name") != name:
-            self.async_update_title_placeholders({"name": name})
-
         try:
             self._abort_if_provisioned()
         except AbortFlow:
@@ -198,14 +180,6 @@ class ImprovBLEConfigFlow(ConfigFlow, domain=DOMAIN):
         self._abort_if_unique_id_configured()
         self._abort_if_provisioned()
 
-        # Clear match history at the start of discovery flow.
-        # This ensures that if the user never provisions the device and it
-        # disappears (powers down), the discovery flow gets cleaned up,
-        # and then the device comes back later, it can be rediscovered.
-        bluetooth.async_clear_address_from_match_history(
-            self.hass, discovery_info.address
-        )
-
         self._remove_bluetooth_callback = bluetooth.async_register_callback(
             self.hass,
             self._async_update_ble,
@@ -343,13 +317,6 @@ class ImprovBLEConfigFlow(ConfigFlow, domain=DOMAIN):
                     return
             else:
                 _LOGGER.debug("Provision successful, redirect URL: %s", redirect_url)
-                # Clear match history so device can be rediscovered if factory reset.
-                # This ensures that if the device is factory reset in the future,
-                # it will trigger a new discovery flow.
-                assert self._discovery_info is not None
-                bluetooth.async_clear_address_from_match_history(
-                    self.hass, self._discovery_info.address
-                )
                 # Abort all flows in progress with same unique ID
                 for flow in self._async_in_progress(include_uninitialized=True):
                     flow_unique_id = flow["context"].get("unique_id")

homeassistant/components/intellifire/manifest.json

@@ -11,5 +11,5 @@
   "documentation": "https://www.home-assistant.io/integrations/intellifire",
   "iot_class": "local_polling",
   "loggers": ["intellifire4py"],
-  "requirements": ["intellifire4py==4.2.1"]
+  "requirements": ["intellifire4py==4.1.9"]
 }

homeassistant/components/knx/binary_sensor.py

@@ -84,11 +84,11 @@ class _KnxBinarySensor(BinarySensorEntity, RestoreEntity):
 
     async def async_added_to_hass(self) -> None:
         """Restore last state."""
+        await super().async_added_to_hass()
         if (
             last_state := await self.async_get_last_state()
         ) and last_state.state not in (STATE_UNKNOWN, STATE_UNAVAILABLE):
             self._device.remote_value.update_value(last_state.state == STATE_ON)
-        await super().async_added_to_hass()
 
     @property
     def is_on(self) -> bool:
@@ -125,7 +125,6 @@ class KnxYamlBinarySensor(_KnxBinarySensor, KnxYamlEntity):
                 ignore_internal_state=config[CONF_IGNORE_INTERNAL_STATE],
                 context_timeout=config.get(CONF_CONTEXT_TIMEOUT),
                 reset_after=config.get(CONF_RESET_AFTER),
-                always_callback=True,
             ),
         )
         self._attr_entity_category = config.get(CONF_ENTITY_CATEGORY)
@@ -160,6 +159,5 @@ class KnxUiBinarySensor(_KnxBinarySensor, KnxUiEntity):
             ),
             context_timeout=knx_conf.get(CONF_CONTEXT_TIMEOUT),
             reset_after=knx_conf.get(CONF_RESET_AFTER),
-            always_callback=True,
         )
         self._attr_force_update = self._device.ignore_internal_state

homeassistant/components/knx/manifest.json

@@ -11,7 +11,7 @@
   "loggers": ["xknx", "xknxproject"],
   "quality_scale": "silver",
   "requirements": [
-    "xknx==3.10.0",
+    "xknx==3.9.1",
     "xknxproject==3.8.2",
     "knx-frontend==2025.10.9.185845"
   ],

homeassistant/components/knx/schema.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 from abc import ABC
 from collections import OrderedDict
-import math
 from typing import ClassVar, Final
 
 import voluptuous as vol
@@ -87,7 +86,7 @@ def number_limit_sub_validator(entity_config: OrderedDict) -> OrderedDict:
         raise vol.Invalid(f"'type: {value_type}' is not a valid numeric sensor type.")
     # Infinity is not supported by Home Assistant frontend so user defined
     # config is required if if xknx DPTNumeric subclass defines it as limit.
-    if min_config is None and dpt_class.value_min == -math.inf:
+    if min_config is None and dpt_class.value_min == float("-inf"):
         raise vol.Invalid(f"'min' key required for value type '{value_type}'")
     if min_config is not None and min_config < dpt_class.value_min:
         raise vol.Invalid(
@@ -95,7 +94,7 @@ def number_limit_sub_validator(entity_config: OrderedDict) -> OrderedDict:
             f" of value type '{value_type}': {dpt_class.value_min}"
         )
 
-    if max_config is None and dpt_class.value_max == math.inf:
+    if max_config is None and dpt_class.value_max == float("inf"):
         raise vol.Invalid(f"'max' key required for value type '{value_type}'")
     if max_config is not None and max_config > dpt_class.value_max:
         raise vol.Invalid(

homeassistant/components/knx/sensor.py

@@ -6,15 +6,15 @@ from collections.abc import Callable
 from dataclasses import dataclass
 from datetime import datetime, timedelta
 from functools import partial
+from typing import Any
 
 from xknx import XKNX
 from xknx.core.connection_state import XknxConnectionState, XknxConnectionType
-from xknx.devices import Device as XknxDevice, Sensor as XknxSensor
+from xknx.devices import Sensor as XknxSensor
 
 from homeassistant import config_entries
 from homeassistant.components.sensor import (
     CONF_STATE_CLASS,
-    RestoreSensor,
     SensorDeviceClass,
     SensorEntity,
     SensorEntityDescription,
@@ -25,8 +25,6 @@ from homeassistant.const import (
     CONF_ENTITY_CATEGORY,
     CONF_NAME,
     CONF_TYPE,
-    STATE_UNAVAILABLE,
-    STATE_UNKNOWN,
     EntityCategory,
     Platform,
 )
@@ -143,7 +141,7 @@ def _create_sensor(xknx: XKNX, config: ConfigType) -> XknxSensor:
     )
 
 
-class KNXSensor(KnxYamlEntity, RestoreSensor):
+class KNXSensor(KnxYamlEntity, SensorEntity):
     """Representation of a KNX sensor."""
 
     _device: XknxSensor
@@ -166,30 +164,20 @@ class KNXSensor(KnxYamlEntity, RestoreSensor):
         self._attr_unique_id = str(self._device.sensor_value.group_address_state)
         self._attr_native_unit_of_measurement = self._device.unit_of_measurement()
         self._attr_state_class = config.get(CONF_STATE_CLASS)
-        self._attr_extra_state_attributes = {}
 
-    async def async_added_to_hass(self) -> None:
-        """Restore last state."""
-        if (
-            (last_state := await self.async_get_last_state())
-            and last_state.state not in (STATE_UNKNOWN, STATE_UNAVAILABLE)
-            and (
-                (last_sensor_data := await self.async_get_last_sensor_data())
-                is not None
-            )
-        ):
-            self._attr_native_value = last_sensor_data.native_value
-            self._attr_extra_state_attributes.update(last_state.attributes)
-        await super().async_added_to_hass()
+    @property
+    def native_value(self) -> StateType:
+        """Return the state of the sensor."""
+        return self._device.resolve_state()
 
-    def after_update_callback(self, device: XknxDevice) -> None:
-        """Call after device was updated."""
-        self._attr_native_value = self._device.resolve_state()
-        if telegram := self._device.last_telegram:
-            self._attr_extra_state_attributes[ATTR_SOURCE] = str(
-                telegram.source_address
-            )
-        super().after_update_callback(device)
+    @property
+    def extra_state_attributes(self) -> dict[str, Any] | None:
+        """Return device specific state attributes."""
+        attr: dict[str, Any] = {}
+
+        if self._device.last_telegram is not None:
+            attr[ATTR_SOURCE] = str(self._device.last_telegram.source_address)
+        return attr
 
 
 class KNXSystemSensor(SensorEntity):

homeassistant/components/luci/device_tracker.py

@@ -84,12 +84,9 @@ class LuciDeviceScanner(DeviceScanner):
         (ip), reachable status (reachable), associated router
         (host), hostname if known (hostname) among others.
         """
-        if not (
-            device := next(
-                (result for result in self.last_results if result.mac == device), None
-            )
-        ):
-            return {}
+        device = next(
+            (result for result in self.last_results if result.mac == device), None
+        )
         return device._asdict()
 
     def _update_info(self):

homeassistant/components/lunatone/__init__.py

@@ -45,7 +45,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: LunatoneConfigEntry) ->
         hw_version=info_api.data.device.pcb,
         configuration_url=entry.data[CONF_URL],
         serial_number=str(info_api.serial_number),
-        model=info_api.product_name,
         model_id=(
             f"{info_api.data.device.article_number}{info_api.data.device.article_info}"
         ),

homeassistant/components/lunatone/manifest.json

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

homeassistant/components/matter/binary_sensor.py

@@ -35,7 +35,7 @@ async def async_setup_entry(
     matter.register_platform_handler(Platform.BINARY_SENSOR, async_add_entities)
 
 
-@dataclass(frozen=True, kw_only=True)
+@dataclass(frozen=True)
 class MatterBinarySensorEntityDescription(
     BinarySensorEntityDescription, MatterEntityDescription
 ):

homeassistant/components/matter/button.py

@@ -33,7 +33,7 @@ async def async_setup_entry(
     matter.register_platform_handler(Platform.BUTTON, async_add_entities)
 
 
-@dataclass(frozen=True, kw_only=True)
+@dataclass(frozen=True)
 class MatterButtonEntityDescription(ButtonEntityDescription, MatterEntityDescription):
     """Describe Matter Button entities."""
 

homeassistant/components/matter/climate.py

@@ -183,7 +183,7 @@ async def async_setup_entry(
     matter.register_platform_handler(Platform.CLIMATE, async_add_entities)
 
 
-@dataclass(frozen=True, kw_only=True)
+@dataclass(frozen=True)
 class MatterClimateEntityDescription(ClimateEntityDescription, MatterEntityDescription):
     """Describe Matter Climate entities."""
 

homeassistant/components/matter/cover.py

@@ -62,7 +62,7 @@ async def async_setup_entry(
     matter.register_platform_handler(Platform.COVER, async_add_entities)
 
 
-@dataclass(frozen=True, kw_only=True)
+@dataclass(frozen=True)
 class MatterCoverEntityDescription(CoverEntityDescription, MatterEntityDescription):
     """Describe Matter Cover entities."""
 

homeassistant/components/matter/entity.py

@@ -54,7 +54,7 @@ def catch_matter_error[_R, **P](
     return wrapper
 
 
-@dataclass(frozen=True, kw_only=True)
+@dataclass(frozen=True)
 class MatterEntityDescription(EntityDescription):
     """Describe the Matter entity."""
 

homeassistant/components/matter/event.py

@@ -47,7 +47,7 @@ async def async_setup_entry(
     matter.register_platform_handler(Platform.EVENT, async_add_entities)
 
 
-@dataclass(frozen=True, kw_only=True)
+@dataclass(frozen=True)
 class MatterEventEntityDescription(EventEntityDescription, MatterEntityDescription):
     """Describe Matter Event entities."""
 

homeassistant/components/matter/fan.py

@@ -53,7 +53,7 @@ async def async_setup_entry(
     matter.register_platform_handler(Platform.FAN, async_add_entities)
 
 
-@dataclass(frozen=True, kw_only=True)
+@dataclass(frozen=True)
 class MatterFanEntityDescription(FanEntityDescription, MatterEntityDescription):
     """Describe Matter Fan entities."""
 

homeassistant/components/matter/light.py

@@ -86,7 +86,7 @@ async def async_setup_entry(
     matter.register_platform_handler(Platform.LIGHT, async_add_entities)
 
 
-@dataclass(frozen=True, kw_only=True)
+@dataclass(frozen=True)
 class MatterLightEntityDescription(LightEntityDescription, MatterEntityDescription):
     """Describe Matter Light entities."""
 

homeassistant/components/matter/lock.py

@@ -53,7 +53,7 @@ async def async_setup_entry(
     matter.register_platform_handler(Platform.LOCK, async_add_entities)
 
 
-@dataclass(frozen=True, kw_only=True)
+@dataclass(frozen=True)
 class MatterLockEntityDescription(LockEntityDescription, MatterEntityDescription):
     """Describe Matter Lock entities."""
 

homeassistant/components/matter/number.py

@@ -44,7 +44,7 @@ async def async_setup_entry(
     matter.register_platform_handler(Platform.NUMBER, async_add_entities)
 
 
-@dataclass(frozen=True, kw_only=True)
+@dataclass(frozen=True)
 class MatterNumberEntityDescription(NumberEntityDescription, MatterEntityDescription):
     """Describe Matter Number Input entities."""
 

homeassistant/components/matter/select.py

@@ -62,7 +62,7 @@ async def async_setup_entry(
     matter.register_platform_handler(Platform.SELECT, async_add_entities)
 
 
-@dataclass(frozen=True, kw_only=True)
+@dataclass(frozen=True)
 class MatterSelectEntityDescription(SelectEntityDescription, MatterEntityDescription):
     """Describe Matter select entities."""
 

homeassistant/components/matter/sensor.py

@@ -166,7 +166,7 @@ async def async_setup_entry(
     matter.register_platform_handler(Platform.SENSOR, async_add_entities)
 
 
-@dataclass(frozen=True, kw_only=True)
+@dataclass(frozen=True)
 class MatterSensorEntityDescription(SensorEntityDescription, MatterEntityDescription):
     """Describe Matter sensor entities."""
 

homeassistant/components/matter/switch.py

@@ -42,7 +42,7 @@ async def async_setup_entry(
     matter.register_platform_handler(Platform.SWITCH, async_add_entities)
 
 
-@dataclass(frozen=True, kw_only=True)
+@dataclass(frozen=True)
 class MatterSwitchEntityDescription(SwitchEntityDescription, MatterEntityDescription):
     """Describe Matter Switch entities."""
 
@@ -120,7 +120,7 @@ class MatterGenericCommandSwitch(MatterSwitch):
         )
 
 
-@dataclass(frozen=True, kw_only=True)
+@dataclass(frozen=True)
 class MatterGenericCommandSwitchEntityDescription(
     SwitchEntityDescription, MatterEntityDescription
 ):
@@ -132,7 +132,7 @@ class MatterGenericCommandSwitchEntityDescription(
     command_timeout: int | None = None
 
 
-@dataclass(frozen=True, kw_only=True)
+@dataclass(frozen=True)
 class MatterNumericSwitchEntityDescription(
     SwitchEntityDescription, MatterEntityDescription
 ):

homeassistant/components/matter/update.py

@@ -67,7 +67,7 @@ async def async_setup_entry(
     matter.register_platform_handler(Platform.UPDATE, async_add_entities)
 
 
-@dataclass(frozen=True, kw_only=True)
+@dataclass(frozen=True)
 class MatterUpdateEntityDescription(UpdateEntityDescription, MatterEntityDescription):
     """Describe Matter Update entities."""
 

homeassistant/components/matter/vacuum.py

@@ -59,7 +59,7 @@ async def async_setup_entry(
     matter.register_platform_handler(Platform.VACUUM, async_add_entities)
 
 
-@dataclass(frozen=True, kw_only=True)
+@dataclass(frozen=True)
 class MatterStateVacuumEntityDescription(
     StateVacuumEntityDescription, MatterEntityDescription
 ):

homeassistant/components/matter/valve.py

@@ -36,7 +36,7 @@ async def async_setup_entry(
     matter.register_platform_handler(Platform.VALVE, async_add_entities)
 
 
-@dataclass(frozen=True, kw_only=True)
+@dataclass(frozen=True)
 class MatterValveEntityDescription(ValveEntityDescription, MatterEntityDescription):
     """Describe Matter Valve entities."""