Update to Home Assistant 2025.10.2 (#84)

* Update to Home Assistant 2025.10.2

* Add test suite

---------

Co-authored-by: rikroe <42204099+rikroe@users.noreply.github.com>

Author: github-actions[bot]

custom_components/bmw_connected_drive/__init__.py

@@ -2,24 +2,21 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
 import logging
 
 import voluptuous as vol
 
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_DEVICE_ID, CONF_ENTITY_ID, CONF_NAME, Platform
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import (
+    config_validation as cv,
     device_registry as dr,
     discovery,
     entity_registry as er,
-    issue_registry as ir,
 )
-import homeassistant.helpers.config_validation as cv
 
 from .const import ATTR_VIN, CONF_READ_ONLY, DOMAIN
-from .coordinator import BMWDataUpdateCoordinator
+from .coordinator import BMWConfigEntry, BMWDataUpdateCoordinator
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -50,19 +47,9 @@
 SERVICE_UPDATE_STATE = "update_state"
 
 
-type BMWConfigEntry = ConfigEntry[BMWData]
-
-
-@dataclass
-class BMWData:
-    """Class to store BMW runtime data."""
-
-    coordinator: BMWDataUpdateCoordinator
-
-
 @callback
 def _async_migrate_options_from_data_if_missing(
-    hass: HomeAssistant, entry: ConfigEntry
+    hass: HomeAssistant, entry: BMWConfigEntry
 ) -> None:
     data = dict(entry.data)
     options = dict(entry.options)
@@ -86,23 +73,29 @@ async def _async_migrate_entries(
     @callback
     def update_unique_id(entry: er.RegistryEntry) -> dict[str, str] | None:
         replacements = {
-            "charging_level_hv": "fuel_and_battery.remaining_battery_percent",
-            "fuel_percent": "fuel_and_battery.remaining_fuel_percent",
-            "ac_current_limit": "charging_profile.ac_current_limit",
-            "charging_start_time": "fuel_and_battery.charging_start_time",
-            "charging_end_time": "fuel_and_battery.charging_end_time",
-            "charging_status": "fuel_and_battery.charging_status",
-            "charging_target": "fuel_and_battery.charging_target",
-            "remaining_battery_percent": "fuel_and_battery.remaining_battery_percent",
-            "remaining_range_total": "fuel_and_battery.remaining_range_total",
-            "remaining_range_electric": "fuel_and_battery.remaining_range_electric",
-            "remaining_range_fuel": "fuel_and_battery.remaining_range_fuel",
-            "remaining_fuel": "fuel_and_battery.remaining_fuel",
-            "remaining_fuel_percent": "fuel_and_battery.remaining_fuel_percent",
-            "activity": "climate.activity",
+            Platform.SENSOR.value: {
+                "charging_level_hv": "fuel_and_battery.remaining_battery_percent",
+                "fuel_percent": "fuel_and_battery.remaining_fuel_percent",
+                "ac_current_limit": "charging_profile.ac_current_limit",
+                "charging_start_time": "fuel_and_battery.charging_start_time",
+                "charging_end_time": "fuel_and_battery.charging_end_time",
+                "charging_status": "fuel_and_battery.charging_status",
+                "charging_target": "fuel_and_battery.charging_target",
+                "remaining_battery_percent": "fuel_and_battery.remaining_battery_percent",
+                "remaining_range_total": "fuel_and_battery.remaining_range_total",
+                "remaining_range_electric": "fuel_and_battery.remaining_range_electric",
+                "remaining_range_fuel": "fuel_and_battery.remaining_range_fuel",
+                "remaining_fuel": "fuel_and_battery.remaining_fuel",
+                "remaining_fuel_percent": "fuel_and_battery.remaining_fuel_percent",
+                "activity": "climate.activity",
+            }
         }
-        if (key := entry.unique_id.split("-")[-1]) in replacements:
-            new_unique_id = entry.unique_id.replace(key, replacements[key])
+        if (key := entry.unique_id.split("-")[-1]) in replacements.get(
+            entry.domain, []
+        ):
+            new_unique_id = entry.unique_id.replace(
+                key, replacements[entry.domain][key]
+            )
             _LOGGER.debug(
                 "Migrating entity '%s' unique_id from '%s' to '%s'",
                 entry.entity_id,
@@ -128,30 +121,21 @@ def update_unique_id(entry: er.RegistryEntry) -> dict[str, str] | None:
     return True
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_setup_entry(hass: HomeAssistant, entry: BMWConfigEntry) -> bool:
     """Set up BMW Connected Drive from a config entry."""
 
-    ir.async_create_issue(
-        hass,
-        DOMAIN,
-        "stop_using_custom_component",
-        is_fixable=False,
-        severity=ir.IssueSeverity.ERROR,
-        translation_key="stop_using_custom_component",
-    )
-
     _async_migrate_options_from_data_if_missing(hass, entry)
 
     await _async_migrate_entries(hass, entry)
 
     # Set up one data coordinator per account/config entry
     coordinator = BMWDataUpdateCoordinator(
         hass,
-        entry=entry,
+        config_entry=entry,
     )
     await coordinator.async_config_entry_first_refresh()
 
-    entry.runtime_data = BMWData(coordinator)
+    entry.runtime_data = coordinator
 
     # Set up all platforms except notify
     await hass.config_entries.async_forward_entry_setups(
@@ -185,7 +169,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: BMWConfigEntry) -> bool:
     """Unload a config entry."""
 
     return await hass.config_entries.async_unload_platforms(

custom_components/bmw_connected_drive/binary_sensor.py

@@ -18,14 +18,16 @@
     BinarySensorEntityDescription,
 )
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util.unit_system import UnitSystem
 
 from . import BMWConfigEntry
 from .const import UNIT_MAP
 from .coordinator import BMWDataUpdateCoordinator
 from .entity import BMWBaseEntity
 
+PARALLEL_UPDATES = 0
+
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -198,10 +200,10 @@ class BMWBinarySensorEntityDescription(BinarySensorEntityDescription):
 async def async_setup_entry(
     hass: HomeAssistant,
     config_entry: BMWConfigEntry,
-    async_add_entities: AddEntitiesCallback,
+    async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the BMW binary sensors from config entry."""
-    coordinator = config_entry.runtime_data.coordinator
+    coordinator = config_entry.runtime_data
 
     entities = [
         BMWBinarySensor(coordinator, vehicle, description, hass.config.units)

custom_components/bmw_connected_drive/button.py

@@ -14,14 +14,16 @@
 from homeassistant.components.button import ButtonEntity, ButtonEntityDescription
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from . import BMWConfigEntry
+from . import DOMAIN, BMWConfigEntry
 from .entity import BMWBaseEntity
 
 if TYPE_CHECKING:
     from .coordinator import BMWDataUpdateCoordinator
 
+PARALLEL_UPDATES = 1
+
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -53,7 +55,6 @@ class BMWButtonEntityDescription(ButtonEntityDescription):
     BMWButtonEntityDescription(
         key="deactivate_air_conditioning",
         translation_key="deactivate_air_conditioning",
-        name="Deactivate air conditioning",
         remote_function=lambda vehicle: vehicle.remote_services.trigger_remote_air_conditioning_stop(),
         is_available=lambda vehicle: vehicle.is_remote_climate_stop_enabled,
     ),
@@ -68,10 +69,10 @@ class BMWButtonEntityDescription(ButtonEntityDescription):
 async def async_setup_entry(
     hass: HomeAssistant,
     config_entry: BMWConfigEntry,
-    async_add_entities: AddEntitiesCallback,
+    async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the BMW buttons from config entry."""
-    coordinator = config_entry.runtime_data.coordinator
+    coordinator = config_entry.runtime_data
 
     entities: list[BMWButton] = []
 
@@ -109,6 +110,10 @@ async def async_press(self) -> None:
         try:
             await self.entity_description.remote_function(self.vehicle)
         except MyBMWAPIError as ex:
-            raise HomeAssistantError(ex) from ex
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="remote_service_error",
+                translation_placeholders={"exception": str(ex)},
+            ) from ex
 
         self.coordinator.async_update_listeners()

custom_components/bmw_connected_drive/config_flow.py

@@ -18,7 +18,6 @@
 from homeassistant.config_entries import (
     SOURCE_REAUTH,
     SOURCE_RECONFIGURE,
-    ConfigEntry,
     ConfigFlow,
     ConfigFlowResult,
     OptionsFlow,
@@ -39,6 +38,7 @@
     CONF_READ_ONLY,
     CONF_REFRESH_TOKEN,
 )
+from .coordinator import BMWConfigEntry
 
 DATA_SCHEMA = vol.Schema(
     {
@@ -53,6 +53,12 @@
     },
     extra=vol.REMOVE_EXTRA,
 )
+RECONFIGURE_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_PASSWORD): str,
+    },
+    extra=vol.REMOVE_EXTRA,
+)
 CAPTCHA_SCHEMA = vol.Schema(
     {
         vol.Required(CONF_CAPTCHA_TOKEN): str,
@@ -97,9 +103,10 @@ class BMWConfigFlow(ConfigFlow, domain=DOMAIN):
 
     VERSION = 1
 
-    data: dict[str, Any] = {}
-
-    _existing_entry_data: Mapping[str, Any] | None = None
+    def __init__(self) -> None:
+        """Initialize the config flow."""
+        self.data: dict[str, Any] = {}
+        self._existing_entry_data: dict[str, Any] = {}
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
@@ -111,9 +118,8 @@ async def async_step_user(
             unique_id = f"{user_input[CONF_REGION]}-{user_input[CONF_USERNAME]}"
             await self.async_set_unique_id(unique_id)
 
-            if self.source in {SOURCE_REAUTH, SOURCE_RECONFIGURE}:
-                self._abort_if_unique_id_mismatch(reason="account_mismatch")
-            else:
+            # Unique ID cannot change for reauth/reconfigure
+            if self.source not in {SOURCE_REAUTH, SOURCE_RECONFIGURE}:
                 self._abort_if_unique_id_configured()
 
             # Store user input for later use
@@ -166,19 +172,35 @@ async def async_step_user(
 
         return self.async_show_form(step_id="user", data_schema=schema, errors=errors)
 
+    async def async_step_change_password(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Show the change password step."""
+        if user_input is not None:
+            return await self.async_step_user(self._existing_entry_data | user_input)
+
+        return self.async_show_form(
+            step_id="change_password",
+            data_schema=RECONFIGURE_SCHEMA,
+            description_placeholders={
+                CONF_USERNAME: self._existing_entry_data[CONF_USERNAME],
+                CONF_REGION: self._existing_entry_data[CONF_REGION],
+            },
+        )
+
     async def async_step_reauth(
         self, entry_data: Mapping[str, Any]
     ) -> ConfigFlowResult:
         """Handle configuration by re-auth."""
-        self._existing_entry_data = entry_data
-        return await self.async_step_user()
+        self._existing_entry_data = dict(entry_data)
+        return await self.async_step_change_password()
 
     async def async_step_reconfigure(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Handle a reconfiguration flow initialized by the user."""
-        self._existing_entry_data = self._get_reconfigure_entry().data
-        return await self.async_step_user()
+        self._existing_entry_data = dict(self._get_reconfigure_entry().data)
+        return await self.async_step_change_password()
 
     async def async_step_captcha(
         self, user_input: dict[str, Any] | None = None
@@ -199,7 +221,7 @@ async def async_step_captcha(
     @staticmethod
     @callback
     def async_get_options_flow(
-        config_entry: ConfigEntry,
+        config_entry: BMWConfigEntry,
     ) -> BMWOptionsFlow:
         """Return a MyBMW option flow."""
         return BMWOptionsFlow()