homeassistant 2025.9.4__py3-none-any.whl → 2025.10.0b1__py3-none-any.whl

homeassistant/components/volvo/coordinator.py

@@ -5,9 +5,10 @@ from __future__ import annotations
 from abc import abstractmethod
 import asyncio
 from collections.abc import Callable, Coroutine
+from dataclasses import dataclass
 from datetime import timedelta
 import logging
-from typing import Any, cast
+from typing import Any, Generic, TypeVar, cast
 
 from volvocarsapi.api import VolvoCarsApi
 from volvocarsapi.models import (
@@ -34,7 +35,22 @@ FAST_INTERVAL = 1
 _LOGGER = logging.getLogger(__name__)
 
 
-type VolvoConfigEntry = ConfigEntry[tuple[VolvoBaseCoordinator, ...]]
+@dataclass
+class VolvoContext:
+    """Volvo context."""
+
+    api: VolvoCarsApi
+    vehicle: VolvoCarsVehicle
+
+
+@dataclass
+class VolvoRuntimeData:
+    """Volvo runtime data."""
+
+    interval_coordinators: tuple[VolvoBaseIntervalCoordinator, ...]
+
+
+type VolvoConfigEntry = ConfigEntry[VolvoRuntimeData]
 type CoordinatorData = dict[str, VolvoCarsApiBaseModel | None]
 
 
@@ -48,7 +64,10 @@ def _is_invalid_api_field(field: VolvoCarsApiBaseModel | None) -> bool:
     return False
 
 
-class VolvoBaseCoordinator(DataUpdateCoordinator[CoordinatorData]):
+T = TypeVar("T", bound=dict, default=dict[str, Any])
+
+
+class VolvoBaseCoordinator(DataUpdateCoordinator[T], Generic[T]):
     """Volvo base coordinator."""
 
     config_entry: VolvoConfigEntry
@@ -57,9 +76,8 @@ class VolvoBaseCoordinator(DataUpdateCoordinator[CoordinatorData]):
         self,
         hass: HomeAssistant,
         entry: VolvoConfigEntry,
-        api: VolvoCarsApi,
-        vehicle: VolvoCarsVehicle,
-        update_interval: timedelta,
+        context: VolvoContext,
+        update_interval: timedelta | None,
         name: str,
     ) -> None:
         """Initialize the coordinator."""
@@ -72,8 +90,34 @@ class VolvoBaseCoordinator(DataUpdateCoordinator[CoordinatorData]):
             update_interval=update_interval,
         )
 
-        self.api = api
-        self.vehicle = vehicle
+        self.context = context
+
+    def get_api_field(self, api_field: str | None) -> VolvoCarsApiBaseModel | None:
+        """Get the API field based on the entity description."""
+
+        return self.data.get(api_field) if api_field else None
+
+
+class VolvoBaseIntervalCoordinator(VolvoBaseCoordinator[CoordinatorData]):
+    """Volvo base interval coordinator."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        entry: VolvoConfigEntry,
+        context: VolvoContext,
+        update_interval: timedelta,
+        name: str,
+    ) -> None:
+        """Initialize the coordinator."""
+
+        super().__init__(
+            hass,
+            entry,
+            context,
+            update_interval,
+            name,
+        )
 
         self._api_calls: list[Callable[[], Coroutine[Any, Any, Any]]] = []
 
@@ -151,11 +195,6 @@ class VolvoBaseCoordinator(DataUpdateCoordinator[CoordinatorData]):
 
         return data
 
-    def get_api_field(self, api_field: str | None) -> VolvoCarsApiBaseModel | None:
-        """Get the API field based on the entity description."""
-
-        return self.data.get(api_field) if api_field else None
-
     @abstractmethod
     async def _async_determine_api_calls(
         self,
@@ -163,23 +202,21 @@ class VolvoBaseCoordinator(DataUpdateCoordinator[CoordinatorData]):
         raise NotImplementedError
 
 
-class VolvoVerySlowIntervalCoordinator(VolvoBaseCoordinator):
+class VolvoVerySlowIntervalCoordinator(VolvoBaseIntervalCoordinator):
     """Volvo coordinator with very slow update rate."""
 
     def __init__(
         self,
         hass: HomeAssistant,
         entry: VolvoConfigEntry,
-        api: VolvoCarsApi,
-        vehicle: VolvoCarsVehicle,
+        context: VolvoContext,
     ) -> None:
         """Initialize the coordinator."""
 
         super().__init__(
             hass,
             entry,
-            api,
-            vehicle,
+            context,
             timedelta(minutes=VERY_SLOW_INTERVAL),
             "Volvo very slow interval coordinator",
         )
@@ -187,47 +224,47 @@ class VolvoVerySlowIntervalCoordinator(VolvoBaseCoordinator):
     async def _async_determine_api_calls(
         self,
     ) -> list[Callable[[], Coroutine[Any, Any, Any]]]:
+        api = self.context.api
+
         return [
-            self.api.async_get_brakes_status,
-            self.api.async_get_diagnostics,
-            self.api.async_get_engine_warnings,
-            self.api.async_get_odometer,
-            self.api.async_get_statistics,
-            self.api.async_get_tyre_states,
-            self.api.async_get_warnings,
+            api.async_get_brakes_status,
+            api.async_get_diagnostics,
+            api.async_get_engine_warnings,
+            api.async_get_odometer,
+            api.async_get_statistics,
+            api.async_get_tyre_states,
+            api.async_get_warnings,
         ]
 
     async def _async_update_data(self) -> CoordinatorData:
         data = await super()._async_update_data()
 
         # Add static values
-        if self.vehicle.has_battery_engine():
+        if self.context.vehicle.has_battery_engine():
             data[DATA_BATTERY_CAPACITY] = VolvoCarsValue.from_dict(
                 {
-                    "value": self.vehicle.battery_capacity_kwh,
+                    "value": self.context.vehicle.battery_capacity_kwh,
                 }
             )
 
         return data
 
 
-class VolvoSlowIntervalCoordinator(VolvoBaseCoordinator):
+class VolvoSlowIntervalCoordinator(VolvoBaseIntervalCoordinator):
     """Volvo coordinator with slow update rate."""
 
     def __init__(
         self,
         hass: HomeAssistant,
         entry: VolvoConfigEntry,
-        api: VolvoCarsApi,
-        vehicle: VolvoCarsVehicle,
+        context: VolvoContext,
     ) -> None:
         """Initialize the coordinator."""
 
         super().__init__(
             hass,
             entry,
-            api,
-            vehicle,
+            context,
             timedelta(minutes=SLOW_INTERVAL),
             "Volvo slow interval coordinator",
         )
@@ -235,32 +272,32 @@ class VolvoSlowIntervalCoordinator(VolvoBaseCoordinator):
     async def _async_determine_api_calls(
         self,
     ) -> list[Callable[[], Coroutine[Any, Any, Any]]]:
-        if self.vehicle.has_combustion_engine():
+        api = self.context.api
+
+        if self.context.vehicle.has_combustion_engine():
             return [
-                self.api.async_get_command_accessibility,
-                self.api.async_get_fuel_status,
+                api.async_get_command_accessibility,
+                api.async_get_fuel_status,
             ]
 
-        return [self.api.async_get_command_accessibility]
+        return [api.async_get_command_accessibility]
 
 
-class VolvoMediumIntervalCoordinator(VolvoBaseCoordinator):
+class VolvoMediumIntervalCoordinator(VolvoBaseIntervalCoordinator):
     """Volvo coordinator with medium update rate."""
 
     def __init__(
         self,
         hass: HomeAssistant,
         entry: VolvoConfigEntry,
-        api: VolvoCarsApi,
-        vehicle: VolvoCarsVehicle,
+        context: VolvoContext,
     ) -> None:
         """Initialize the coordinator."""
 
         super().__init__(
             hass,
             entry,
-            api,
-            vehicle,
+            context,
             timedelta(minutes=MEDIUM_INTERVAL),
             "Volvo medium interval coordinator",
         )
@@ -271,9 +308,11 @@ class VolvoMediumIntervalCoordinator(VolvoBaseCoordinator):
         self,
     ) -> list[Callable[[], Coroutine[Any, Any, Any]]]:
         api_calls: list[Any] = []
+        api = self.context.api
+        vehicle = self.context.vehicle
 
-        if self.vehicle.has_battery_engine():
-            capabilities = await self.api.async_get_energy_capabilities()
+        if vehicle.has_battery_engine():
+            capabilities = await api.async_get_energy_capabilities()
 
             if capabilities.get("isSupported", False):
 
@@ -288,8 +327,8 @@ class VolvoMediumIntervalCoordinator(VolvoBaseCoordinator):
 
                 api_calls.append(self._async_get_energy_state)
 
-        if self.vehicle.has_combustion_engine():
-            api_calls.append(self.api.async_get_engine_status)
+        if vehicle.has_combustion_engine():
+            api_calls.append(api.async_get_engine_status)
 
         return api_calls
 
@@ -304,7 +343,7 @@ class VolvoMediumIntervalCoordinator(VolvoBaseCoordinator):
 
             return field
 
-        energy_state = await self.api.async_get_energy_state()
+        energy_state = await self.context.api.async_get_energy_state()
 
         return {
             key: _mark_ok(value)
@@ -313,23 +352,21 @@ class VolvoMediumIntervalCoordinator(VolvoBaseCoordinator):
         }
 
 
-class VolvoFastIntervalCoordinator(VolvoBaseCoordinator):
+class VolvoFastIntervalCoordinator(VolvoBaseIntervalCoordinator):
     """Volvo coordinator with fast update rate."""
 
     def __init__(
         self,
         hass: HomeAssistant,
         entry: VolvoConfigEntry,
-        api: VolvoCarsApi,
-        vehicle: VolvoCarsVehicle,
+        context: VolvoContext,
     ) -> None:
         """Initialize the coordinator."""
 
         super().__init__(
             hass,
             entry,
-            api,
-            vehicle,
+            context,
             timedelta(minutes=FAST_INTERVAL),
             "Volvo fast interval coordinator",
         )
@@ -337,7 +374,9 @@ class VolvoFastIntervalCoordinator(VolvoBaseCoordinator):
     async def _async_determine_api_calls(
         self,
     ) -> list[Callable[[], Coroutine[Any, Any, Any]]]:
+        api = self.context.api
+
         return [
-            self.api.async_get_doors_status,
-            self.api.async_get_window_states,
+            api.async_get_doors_status,
+            api.async_get_window_states,
         ]

homeassistant/components/volvo/entity.py

@@ -54,7 +54,7 @@ class VolvoEntity(CoordinatorEntity[VolvoBaseCoordinator]):
             coordinator.config_entry.data[CONF_VIN], description.key
         )
 
-        vehicle = coordinator.vehicle
+        vehicle = coordinator.context.vehicle
         model = (
             f"{vehicle.description.model} ({vehicle.model_year})"
             if vehicle.fuel_type == "NONE"

homeassistant/components/volvo/sensor.py

@@ -354,7 +354,7 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up sensors."""
-    coordinators = entry.runtime_data
+    coordinators = entry.runtime_data.interval_coordinators
     async_add_entities(
         VolvoSensor(coordinator, description)
         for coordinator in coordinators

homeassistant/components/volvo/translations/en-GB.json

@@ -58,7 +58,7 @@
                 "name": "Brake fluid"
             },
             "brake_light_center_warning": {
-                "name": "Brake light center"
+                "name": "Brake light centre"
             },
             "brake_light_left_warning": {
                 "name": "Brake light left"

homeassistant/components/volvo/translations/pt.json

@@ -32,7 +32,7 @@
                 "data_description": {
                     "api_key": "A chave API dos programadores da Volvo"
                 },
-                "description": "Obtenha a sua chave API no [Volvo developer portal] ({volvo_dev_portal})."
+                "description": "Obtenha a sua chave API no [portal de programador Volvo] ({volvo_dev_portal})."
             },
             "pick_implementation": {
                 "title": "Escolha o m\u00e9todo de autentica\u00e7\u00e3o"

homeassistant/components/volvooncall/__init__.py

@@ -1,71 +1,46 @@
-"""Support for Volvo On Call."""
+"""The Volvo On Call integration."""
 
-from volvooncall import Connection
+from __future__ import annotations
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import (
-    CONF_PASSWORD,
-    CONF_REGION,
-    CONF_UNIT_SYSTEM,
-    CONF_USERNAME,
-)
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers import issue_registry as ir
 
-from .const import (
-    CONF_SCANDINAVIAN_MILES,
-    DOMAIN,
-    PLATFORMS,
-    UNIT_SYSTEM_METRIC,
-    UNIT_SYSTEM_SCANDINAVIAN_MILES,
-)
-from .coordinator import VolvoUpdateCoordinator
-from .models import VolvoData
+from .const import DOMAIN
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
-    """Set up the Volvo On Call component from a ConfigEntry."""
-
-    # added CONF_UNIT_SYSTEM / deprecated CONF_SCANDINAVIAN_MILES in 2022.10 to support imperial units
-    if CONF_UNIT_SYSTEM not in entry.data:
-        new_conf = {**entry.data}
-
-        scandinavian_miles: bool = entry.data[CONF_SCANDINAVIAN_MILES]
-
-        new_conf[CONF_UNIT_SYSTEM] = (
-            UNIT_SYSTEM_SCANDINAVIAN_MILES if scandinavian_miles else UNIT_SYSTEM_METRIC
-        )
-
-        hass.config_entries.async_update_entry(entry, data=new_conf)
-
-    session = async_get_clientsession(hass)
-
-    connection = Connection(
-        session=session,
-        username=entry.data[CONF_USERNAME],
-        password=entry.data[CONF_PASSWORD],
-        service_url=None,
-        region=entry.data[CONF_REGION],
+    """Set up Volvo On Call integration."""
+
+    # Create repair issue pointing to the new volvo integration
+    ir.async_create_issue(
+        hass,
+        DOMAIN,
+        "volvooncall_deprecated",
+        breaks_in_ha_version="2026.3",
+        is_fixable=False,
+        severity=ir.IssueSeverity.WARNING,
+        translation_key="volvooncall_deprecated",
     )
 
-    hass.data.setdefault(DOMAIN, {})
-
-    volvo_data = VolvoData(hass, connection, entry)
-
-    coordinator = VolvoUpdateCoordinator(hass, entry, volvo_data)
-
-    await coordinator.async_config_entry_first_refresh()
-
-    hass.data[DOMAIN][entry.entry_id] = coordinator
-
-    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
-
     return True
 
 
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
-    if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
-        hass.data[DOMAIN].pop(entry.entry_id)
 
-    return unload_ok
+    # Only delete the repair issue if this is the last config entry for this domain
+    remaining_entries = [
+        config_entry
+        for config_entry in hass.config_entries.async_entries(DOMAIN)
+        if config_entry.entry_id != entry.entry_id
+    ]
+
+    if not remaining_entries:
+        ir.async_delete_issue(
+            hass,
+            DOMAIN,
+            "volvooncall_deprecated",
+        )
+
+    return True

homeassistant/components/volvooncall/config_flow.py

@@ -2,127 +2,21 @@
 
 from __future__ import annotations
 
-from collections.abc import Mapping
-import logging
 from typing import Any
 
-import voluptuous as vol
-from volvooncall import Connection
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
 
-from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlow, ConfigFlowResult
-from homeassistant.const import (
-    CONF_PASSWORD,
-    CONF_REGION,
-    CONF_UNIT_SYSTEM,
-    CONF_USERNAME,
-)
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-
-from .const import (
-    CONF_MUTABLE,
-    DOMAIN,
-    UNIT_SYSTEM_IMPERIAL,
-    UNIT_SYSTEM_METRIC,
-    UNIT_SYSTEM_SCANDINAVIAN_MILES,
-)
-from .errors import InvalidAuth
-from .models import VolvoData
-
-_LOGGER = logging.getLogger(__name__)
+from .const import DOMAIN
 
 
 class VolvoOnCallConfigFlow(ConfigFlow, domain=DOMAIN):
-    """VolvoOnCall config flow."""
+    """Handle a config flow for Volvo On Call."""
 
     VERSION = 1
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
-        """Handle user step."""
-        errors = {}
-        defaults = {
-            CONF_USERNAME: "",
-            CONF_PASSWORD: "",
-            CONF_REGION: None,
-            CONF_MUTABLE: True,
-            CONF_UNIT_SYSTEM: UNIT_SYSTEM_METRIC,
-        }
-
-        if user_input is not None:
-            await self.async_set_unique_id(user_input[CONF_USERNAME])
-
-            if self.source != SOURCE_REAUTH:
-                self._abort_if_unique_id_configured()
-
-            try:
-                await self.is_valid(user_input)
-            except InvalidAuth:
-                errors["base"] = "invalid_auth"
-            except Exception:
-                _LOGGER.exception("Unhandled exception in user step")
-                errors["base"] = "unknown"
-            if not errors:
-                if self.source == SOURCE_REAUTH:
-                    return self.async_update_reload_and_abort(
-                        self._get_reauth_entry(), data_updates=user_input
-                    )
-
-                return self.async_create_entry(
-                    title=user_input[CONF_USERNAME], data=user_input
-                )
-        elif self.source == SOURCE_REAUTH:
-            reauth_entry = self._get_reauth_entry()
-            for key in defaults:
-                defaults[key] = reauth_entry.data.get(key)
-
-        user_schema = vol.Schema(
-            {
-                vol.Required(CONF_USERNAME, default=defaults[CONF_USERNAME]): str,
-                vol.Required(CONF_PASSWORD, default=defaults[CONF_PASSWORD]): str,
-                vol.Required(CONF_REGION, default=defaults[CONF_REGION]): vol.In(
-                    {"na": "North America", "cn": "China", None: "Rest of world"}
-                ),
-                vol.Optional(
-                    CONF_UNIT_SYSTEM, default=defaults[CONF_UNIT_SYSTEM]
-                ): vol.In(
-                    {
-                        UNIT_SYSTEM_METRIC: "Metric",
-                        UNIT_SYSTEM_SCANDINAVIAN_MILES: (
-                            "Metric with Scandinavian Miles"
-                        ),
-                        UNIT_SYSTEM_IMPERIAL: "Imperial",
-                    }
-                ),
-                vol.Optional(CONF_MUTABLE, default=defaults[CONF_MUTABLE]): bool,
-            },
-        )
-
-        return self.async_show_form(
-            step_id="user", data_schema=user_schema, errors=errors
-        )
-
-    async def async_step_reauth(
-        self, entry_data: Mapping[str, Any]
-    ) -> ConfigFlowResult:
-        """Perform reauth upon an API authentication error."""
-        return await self.async_step_user()
-
-    async def is_valid(self, user_input):
-        """Check for user input errors."""
-
-        session = async_get_clientsession(self.hass)
-
-        region: str | None = user_input.get(CONF_REGION)
-
-        connection = Connection(
-            session=session,
-            username=user_input[CONF_USERNAME],
-            password=user_input[CONF_PASSWORD],
-            service_url=None,
-            region=region,
-        )
-
-        test_volvo_data = VolvoData(self.hass, connection, user_input)
+        """Handle the initial step."""
 
-        await test_volvo_data.auth_is_valid()
+        return self.async_abort(reason="deprecated")

homeassistant/components/volvooncall/const.py

@@ -1,66 +1,3 @@
-"""Constants for volvooncall."""
-
-from datetime import timedelta
+"""Constants for the Volvo On Call integration."""
 
 DOMAIN = "volvooncall"
-
-DEFAULT_UPDATE_INTERVAL = timedelta(minutes=1)
-
-CONF_SERVICE_URL = "service_url"
-CONF_SCANDINAVIAN_MILES = "scandinavian_miles"
-CONF_MUTABLE = "mutable"
-
-UNIT_SYSTEM_SCANDINAVIAN_MILES = "scandinavian_miles"
-UNIT_SYSTEM_METRIC = "metric"
-UNIT_SYSTEM_IMPERIAL = "imperial"
-
-PLATFORMS = {
-    "sensor": "sensor",
-    "binary_sensor": "binary_sensor",
-    "lock": "lock",
-    "device_tracker": "device_tracker",
-    "switch": "switch",
-}
-
-RESOURCES = [
-    "position",
-    "lock",
-    "heater",
-    "odometer",
-    "trip_meter1",
-    "trip_meter2",
-    "average_speed",
-    "fuel_amount",
-    "fuel_amount_level",
-    "average_fuel_consumption",
-    "distance_to_empty",
-    "washer_fluid_level",
-    "brake_fluid",
-    "service_warning_status",
-    "bulb_failures",
-    "battery_range",
-    "battery_level",
-    "time_to_fully_charged",
-    "battery_charge_status",
-    "engine_start",
-    "last_trip",
-    "is_engine_running",
-    "doors_hood_open",
-    "doors_tailgate_open",
-    "doors_front_left_door_open",
-    "doors_front_right_door_open",
-    "doors_rear_left_door_open",
-    "doors_rear_right_door_open",
-    "windows_front_left_window_open",
-    "windows_front_right_window_open",
-    "windows_rear_left_window_open",
-    "windows_rear_right_window_open",
-    "tyre_pressure_front_left_tyre_pressure",
-    "tyre_pressure_front_right_tyre_pressure",
-    "tyre_pressure_rear_left_tyre_pressure",
-    "tyre_pressure_rear_right_tyre_pressure",
-    "any_door_open",
-    "any_window_open",
-]
-
-VOLVO_DISCOVERY_NEW = "volvo_discovery_new"

homeassistant/components/volvooncall/manifest.json

@@ -1,10 +1,9 @@
 {
   "domain": "volvooncall",
   "name": "Volvo On Call",
-  "codeowners": ["@molobrakos"],
+  "codeowners": ["@molobrakos", "@svrooij"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/volvooncall",
   "iot_class": "cloud_polling",
-  "loggers": ["geopy", "hbmqtt", "volvooncall"],
-  "requirements": ["volvooncall==0.10.3"]
+  "quality_scale": "legacy"
 }