volkswagencarnet 5.0.0b3__py3-none-any.whl → 5.0.0b4__py3-none-any.whl

volkswagencarnet/vw_vehicle.py

@@ -1,15 +1,14 @@
 #!/usr/bin/env python3
-"""Vehicle class for Volkswagen Connect."""
-
+"""Vehicle class for We Connect."""
 from __future__ import annotations
 
 import asyncio
+import logging
 from collections import OrderedDict
-from datetime import UTC, datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from json import dumps as to_json
-import logging
 
-from .vw_const import Services, VehicleStatusParameter as P
+from .vw_const import VehicleStatusParameter as P, Services
 from .vw_utilities import find_path, is_valid_path
 
 # TODO
@@ -25,21 +24,15 @@ _LOGGER = logging.getLogger(__name__)
 ENGINE_TYPE_ELECTRIC = "electric"
 ENGINE_TYPE_DIESEL = "diesel"
 ENGINE_TYPE_GASOLINE = "gasoline"
-ENGINE_TYPE_CNG = "cng"
 ENGINE_TYPE_HYBRID = "hybrid"
-ENGINE_TYPE_COMBUSTION = [
-    ENGINE_TYPE_DIESEL,
-    ENGINE_TYPE_GASOLINE,
-    ENGINE_TYPE_CNG,
-]
-ENGINE_TYPE_GAS = [ENGINE_TYPE_CNG]
+ENGINE_TYPE_COMBUSTION = [ENGINE_TYPE_DIESEL, ENGINE_TYPE_GASOLINE]
 DEFAULT_TARGET_TEMP = 24
 
 
 class Vehicle:
     """Vehicle contains the state of sensors and methods for interacting with the car."""
 
-    def __init__(self, conn, url) -> None:
+    def __init__(self, conn, url):
         """Initialize the Vehicle with default values."""
         self._connection = conn
         self._url = url
@@ -47,17 +40,18 @@ class Vehicle:
         self._discovered = False
         self._states = {}
         self._requests: dict[str, object] = {
-            "departuretimer": {"status": "", "timestamp": datetime.now(UTC)},
-            "batterycharge": {"status": "", "timestamp": datetime.now(UTC)},
-            "climatisation": {"status": "", "timestamp": datetime.now(UTC)},
-            "refresh": {"status": "", "timestamp": datetime.now(UTC)},
-            "lock": {"status": "", "timestamp": datetime.now(UTC)},
+            "departuretimer": {"status": "", "timestamp": datetime.now(timezone.utc)},
+            "batterycharge": {"status": "", "timestamp": datetime.now(timezone.utc)},
+            "climatisation": {"status": "", "timestamp": datetime.now(timezone.utc)},
+            "refresh": {"status": "", "timestamp": datetime.now(timezone.utc)},
+            "lock": {"status": "", "timestamp": datetime.now(timezone.utc)},
             "latest": "",
             "state": "",
         }
 
         # API Endpoints that might be enabled for car (that we support)
         self._services: dict[str, dict[str, object]] = {
+            # TODO needs a complete rework...
             Services.ACCESS: {"active": False},
             Services.BATTERY_CHARGING_CARE: {"active": False},
             Services.BATTERY_SUPPORT: {"active": False},
@@ -79,50 +73,33 @@ class Vehicle:
         """Check if request is already in progress."""
         if self._requests.get(topic, {}).get("id", False):
             timestamp = self._requests.get(topic, {}).get(
-                "timestamp",
-                datetime.now(UTC) - timedelta(minutes=unknown_offset),
+                "timestamp", datetime.now(timezone.utc) - timedelta(minutes=unknown_offset)
             )
-            if timestamp + timedelta(minutes=3) < datetime.now(UTC):
+            if timestamp + timedelta(minutes=3) < datetime.now(timezone.utc):
                 self._requests.get(topic, {}).pop("id")
             else:
-                _LOGGER.info("Action (%s) already in progress", topic)
+                _LOGGER.info(f"Action ({topic}) already in progress")
                 return True
         return False
 
-    async def _handle_response(
-        self, response, topic: str, error_msg: str | None = None
-    ) -> bool:
+    async def _handle_response(self, response, topic: str, error_msg: str | None = None) -> bool:
         """Handle errors in response and get requests remaining."""
         if not response:
+            self._requests[topic] = {"status": "Failed", "timestamp": datetime.now(timezone.utc)}
+            _LOGGER.error(error_msg if error_msg is not None else f"Failed to perform {topic} action")
+            raise Exception(error_msg if error_msg is not None else f"Failed to perform {topic} action")
+        else:
             self._requests[topic] = {
-                "status": "Failed",
-                "timestamp": datetime.now(UTC),
+                "timestamp": datetime.now(timezone.utc),
+                "status": response.get("state", "Unknown"),
+                "id": response.get("id", 0),
             }
-            _LOGGER.error(
-                error_msg
-                if error_msg is not None
-                else f"Failed to perform {topic} action"
-            )
-            # pylint: disable=broad-exception-raised
-            raise Exception(
-                error_msg
-                if error_msg is not None
-                else f"Failed to perform {topic} action"
-            )
-        self._requests[topic] = {
-            "timestamp": datetime.now(UTC),
-            "status": response.get("state", "Unknown"),
-            "id": response.get("id", 0),
-        }
-        if response.get("state", None) == "Throttled":
-            status = "Throttled"
-            _LOGGER.warning("Request throttled (%s)", topic)
-        else:
-            status = await self.wait_for_request(request=response.get("id", 0))
-        self._requests[topic] = {
-            "status": status,
-            "timestamp": datetime.now(UTC),
-        }
+            if response.get("state", None) == "Throttled":
+                status = "Throttled"
+                _LOGGER.warning(f"Request throttled ({topic}")
+            else:
+                status = await self.wait_for_request(request=response.get("id", 0))
+            self._requests[topic] = {"status": status, "timestamp": datetime.now(timezone.utc)}
         return True
 
     # API get and set functions #
@@ -130,64 +107,43 @@ class Vehicle:
     async def discover(self):
         """Discover vehicle and initial data."""
 
-        _LOGGER.debug("Attempting discovery of supported API endpoints for vehicle")
-
+        _LOGGER.debug("Attempting discovery of supported API endpoints for vehicle.")
         capabilities_response = await self._connection.getOperationList(self.vin)
         parameters_list = capabilities_response.get("parameters", {})
         capabilities_list = capabilities_response.get("capabilities", {})
-
-        # Update services with parameters
         if parameters_list:
             self._services[Services.PARAMETERS].update(parameters_list)
-
-        # If there are no capabilities, log a warning
-        if not capabilities_list:
-            _LOGGER.warning(
-                "Could not determine available API endpoints for %s", self.vin
-            )
-            self._discovered = True
-            return
-
-        for service_id, service in capabilities_list.items():
-            if service_id not in self._services:
-                continue
-
-            service_name = service.get("id", "Unknown Service")
-            data = {}
-
-            if service.get("isEnabled", False):
-                data["active"] = True
-                _LOGGER.debug("Discovered enabled service: %s", service_name)
-
-                expiration_date = service.get("expirationDate", None)
-                if expiration_date:
-                    data["expiration"] = expiration_date
-
-                operations = service.get("operations", {})
-                data["operations"] = [op.get("id", None) for op in operations.values()]
-
-                parameters = service.get("parameters", [])
-                data["parameters"] = parameters
-
-            else:
-                reason = service.get("status", "Unknown reason")
-                _LOGGER.debug(
-                    "Service: %s is disabled due to: %s", service_name, reason
-                )
-                data["active"] = False
-
-            # Update the service data
-            try:
-                self._services[service_name].update(data)
-            except Exception as error:  # pylint: disable=broad-exception-caught
-                _LOGGER.warning(
-                    'Exception "%s" while updating service "%s": %s',
-                    error,
-                    service_name,
-                    data,
-                )
-
-        _LOGGER.debug("API endpoints: %s", self._services)
+        if capabilities_list:
+            for service_id in capabilities_list.keys():
+                try:
+                    if service_id in self._services.keys():
+                        service = capabilities_list[service_id]
+                        data = {}
+                        service_name = service.get("id", None)
+                        if service.get("isEnabled", False):
+                            _LOGGER.debug(f"Discovered enabled service: {service_name}")
+                            data["active"] = True
+                            if service.get("expirationDate", False):
+                                data["expiration"] = service.get("expirationDate", None)
+                            if service.get("operations", False):
+                                data.update({"operations": []})
+                                for operation_id in service.get("operations", []).keys():
+                                    operation = service.get("operations").get(operation_id)
+                                    data["operations"].append(operation.get("id", None))
+                            if service.get("parameters", False):
+                                data.update({"parameters": []})
+                                for parameter in service.get("parameters", []):
+                                    data["parameters"].append(parameter)
+                        else:
+                            reason = service.get("status", "Unknown")
+                            _LOGGER.debug(f"Service: {service_name} is disabled because of reason: {reason}")
+                            data["active"] = False
+                        self._services[service_name].update(data)
+                except Exception as error:
+                    _LOGGER.warning(f'Encountered exception: "{error}" while parsing service item: {service}')
+        else:
+            _LOGGER.warning(f"Could not determine available API endpoints for {self.vin}")
+        _LOGGER.debug(f"API endpoints: {self._services}")
         self._discovered = True
 
     async def update(self):
@@ -219,7 +175,7 @@ class Vehicle:
             )
             await asyncio.gather(self.get_service_status())
         else:
-            _LOGGER.info("Vehicle with VIN %s is deactivated", self.vin)
+            _LOGGER.info(f"Vehicle with VIN {self.vin} is deactivated.")
 
     # Data collection functions
     async def get_selectivestatus(self, services):
@@ -258,28 +214,26 @@ class Vehicle:
         """Update status of outstanding requests."""
         retry_count -= 1
         if retry_count == 0:
-            _LOGGER.info("Timeout while waiting for result of %s", request.requestId)
+            _LOGGER.info(f"Timeout while waiting for result of {request.requestId}.")
             return "Timeout"
         try:
             status = await self._connection.get_request_status(self.vin, request)
-            _LOGGER.debug("Request ID %s: %s", request, status)
+            _LOGGER.debug(f"Request ID {request}: {status}")
             self._requests["state"] = status
             if status == "In Progress":
                 await asyncio.sleep(10)
                 return await self.wait_for_request(request, retry_count)
-        except Exception as error:  # pylint: disable=broad-exception-caught
-            _LOGGER.warning(
-                "Exception encountered while waiting for request status: %s", error
-            )
+            else:
+                return status
+        except Exception as error:
+            _LOGGER.warning(f"Exception encountered while waiting for request status: {error}")
             return "Exception"
-        else:
-            return status
 
     async def wait_for_data_refresh(self, retry_count=18):
         """Update status of outstanding requests."""
         retry_count -= 1
         if retry_count == 0:
-            _LOGGER.info("Timeout while waiting for data refresh")
+            _LOGGER.info("Timeout while waiting for data refresh.")
             return "Timeout"
         try:
             await self.get_selectivestatus([Services.MEASUREMENTS])
@@ -287,32 +241,41 @@ class Vehicle:
             if self.last_connected < refresh_trigger_time:
                 await asyncio.sleep(10)
                 return await self.wait_for_data_refresh(retry_count)
-
-        except Exception as error:  # pylint: disable=broad-exception-caught
-            _LOGGER.warning(
-                "Exception encountered while waiting for data refresh: %s", error
-            )
+            else:
+                return "successful"
+        except Exception as error:
+            _LOGGER.warning(f"Exception encountered while waiting for data refresh: {error}")
             return "Exception"
-        else:
-            return "successful"
 
     # Data set functions
     # Charging (BATTERYCHARGE)
+    async def set_charger_current(self, value):
+        """Set charger current."""
+        if self.is_charging_supported:
+            if 1 <= int(value) <= 255:
+                data = {"action": {"settings": {"maxChargeCurrent": int(value)}, "type": "setSettings"}}
+            else:
+                _LOGGER.error(f"Set charger maximum current to {value} is not supported.")
+                raise Exception(f"Set charger maximum current to {value} is not supported.")
+            return await self.set_charger(data)
+        else:
+            _LOGGER.error("No charger support.")
+            raise Exception("No charger support.")
+
     async def set_charger(self, action) -> bool:
         """Turn on/off charging."""
         if self.is_charging_supported:
             if action not in ["start", "stop"]:
-                _LOGGER.error('Charging action "%s" is not supported', action)
-                raise Exception(f'Charging action "{action}" is not supported.')  # pylint: disable=broad-exception-raised
+                _LOGGER.error(f'Charging action "{action}" is not supported.')
+                raise Exception(f'Charging action "{action}" is not supported.')
             self._requests["latest"] = "Batterycharge"
             response = await self._connection.setCharging(self.vin, (action == "start"))
             return await self._handle_response(
-                response=response,
-                topic="charging",
-                error_msg=f"Failed to {action} charging",
+                response=response, topic="charging", error_msg=f"Failed to {action} charging"
             )
-        _LOGGER.error("No charging support")
-        raise Exception("No charging support.")  # pylint: disable=broad-exception-raised
+        else:
+            _LOGGER.error("No charging support.")
+            raise Exception("No charging support.")
 
     async def set_charging_settings(self, setting, value):
         """Set charging settings."""
@@ -320,96 +283,62 @@ class Vehicle:
             self.is_charge_max_ac_setting_supported
             or self.is_auto_release_ac_connector_supported
             or self.is_battery_target_charge_level_supported
-            or self.is_charge_max_ac_ampere_supported
         ):
             if setting == "reduced_ac_charging" and value not in ["reduced", "maximum"]:
-                _LOGGER.error('Charging setting "%s" is not supported', value)
-                raise Exception(f'Charging setting "{value}" is not supported.')  # pylint: disable=broad-exception-raised
-            if setting == "max_charge_amperage" and int(value) not in [5, 10, 13, 32]:
-                _LOGGER.error(
-                    "Setting maximum charge amperage to %s is not supported", value
-                )
-                # pylint: disable=broad-exception-raised
-                raise Exception(
-                    f"Setting maximum charge amperage to {value} is not supported."
-                )
+                _LOGGER.error(f'Charging setting "{value}" is not supported.')
+                raise Exception(f'Charging setting "{value}" is not supported.')
             data = {}
-            if (
-                self.is_charge_max_ac_setting_supported
-                and setting != "max_charge_amperage"
-            ):
-                data["maxChargeCurrentAC"] = (
-                    value
-                    if setting == "reduced_ac_charging"
-                    else self.charge_max_ac_setting
-                )
+            if self.is_charge_max_ac_setting_supported:
+                data["maxChargeCurrentAC"] = value if setting == "reduced_ac_charging" else self.charge_max_ac_setting
             if self.is_auto_release_ac_connector_supported:
                 data["autoUnlockPlugWhenChargedAC"] = (
-                    value
-                    if setting == "auto_release_ac_connector"
-                    else self.auto_release_ac_connector_state
+                    value if setting == "auto_release_ac_connector" else self.auto_release_ac_connector_state
                 )
             if self.is_battery_target_charge_level_supported:
-                self.battery_target_charge_level = value
+                self._battery_target_charge_level = value
                 data["targetSOC_pct"] = (
-                    value
-                    if setting == "battery_target_charge_level"
-                    else self.battery_target_charge_level
-                )
-            if (
-                self.is_charge_max_ac_ampere_supported
-                and setting != "reduced_ac_charging"
-            ):
-                data["maxChargeCurrentAC_A"] = (
-                    int(value)
-                    if setting == "max_charge_amperage"
-                    else self.charge_max_ac_ampere
+                    value if setting == "battery_target_charge_level" else self.battery_target_charge_level
                 )
             self._requests["latest"] = "Batterycharge"
             response = await self._connection.setChargingSettings(self.vin, data)
             return await self._handle_response(
-                response=response,
-                topic="charging",
-                error_msg="Failed to change charging settings",
+                response=response, topic="charging", error_msg="Failed to change charging settings"
             )
-        _LOGGER.error("Charging settings are not supported")
-        raise Exception("Charging settings are not supported.")  # pylint: disable=broad-exception-raised
+        else:
+            _LOGGER.error("Charging settings are not supported.")
+            raise Exception("Charging settings are not supported.")
 
     async def set_charging_care_settings(self, value):
         """Set charging care settings."""
         if self.is_battery_care_mode_supported:
             if value not in ["activated", "deactivated"]:
-                _LOGGER.error('Charging care mode "%s" is not supported', value)
-                raise Exception(f'Charging care mode "{value}" is not supported.')  # pylint: disable=broad-exception-raised
+                _LOGGER.error(f'Charging care mode "{value}" is not supported.')
+                raise Exception(f'Charging care mode "{value}" is not supported.')
             data = {"batteryCareMode": value}
             self._requests["latest"] = "Batterycharge"
-            response = await self._connection.setChargingCareModeSettings(
-                self.vin, data
-            )
+            response = await self._connection.setChargingCareModeSettings(self.vin, data)
             return await self._handle_response(
-                response=response,
-                topic="charging",
-                error_msg="Failed to change charging care settings",
+                response=response, topic="charging", error_msg="Failed to change charging care settings"
             )
-        _LOGGER.error("Charging care settings are not supported")
-        raise Exception("Charging care settings are not supported.")  # pylint: disable=broad-exception-raised
+        else:
+            _LOGGER.error("Charging care settings are not supported.")
+            raise Exception("Charging care settings are not supported.")
 
     async def set_readiness_battery_support(self, value):
         """Set readiness battery support settings."""
         if self.is_optimised_battery_use_supported:
             if value not in [True, False]:
-                _LOGGER.error('Battery support mode "%s" is not supported', value)
-                raise Exception(f'Battery support mode "{value}" is not supported.')  # pylint: disable=broad-exception-raised
+                _LOGGER.error(f'Battery support mode "{value}" is not supported.')
+                raise Exception(f'Battery support mode "{value}" is not supported.')
             data = {"batterySupportEnabled": value}
             self._requests["latest"] = "Batterycharge"
             response = await self._connection.setReadinessBatterySupport(self.vin, data)
             return await self._handle_response(
-                response=response,
-                topic="charging",
-                error_msg="Failed to change battery support settings",
+                response=response, topic="charging", error_msg="Failed to change battery support settings"
             )
-        _LOGGER.error("Battery support settings are not supported")
-        raise Exception("Battery support settings are not supported.")  # pylint: disable=broad-exception-raised
+        else:
+            _LOGGER.error("Battery support settings are not supported.")
+            raise Exception("Battery support settings are not supported.")
 
     # Climatisation electric/auxiliary/windows (CLIMATISATION)
     async def set_climatisation_settings(self, setting, value):
@@ -456,26 +385,16 @@ class Vehicle:
                     )
                 if self.is_auxiliary_air_conditioning_supported:
                     data["climatizationAtUnlock"] = (
-                        value
-                        if setting == "auxiliary_air_conditioning"
-                        else self.auxiliary_air_conditioning
+                        value if setting == "auxiliary_air_conditioning" else self.auxiliary_air_conditioning
                     )
                 if self.is_automatic_window_heating_supported:
                     data["windowHeatingEnabled"] = (
-                        value
-                        if setting == "automatic_window_heating"
-                        else self.automatic_window_heating
+                        value if setting == "automatic_window_heating" else self.automatic_window_heating
                     )
                 if self.is_zone_front_left_supported:
-                    data["zoneFrontLeftEnabled"] = (
-                        value if setting == "zone_front_left" else self.zone_front_left
-                    )
+                    data["zoneFrontLeftEnabled"] = value if setting == "zone_front_left" else self.zone_front_left
                 if self.is_zone_front_right_supported:
-                    data["zoneFrontRightEnabled"] = (
-                        value
-                        if setting == "zone_front_right"
-                        else self.zone_front_right
-                    )
+                    data["zoneFrontRightEnabled"] = value if setting == "zone_front_right" else self.zone_front_right
                 self._requests["latest"] = "Climatisation"
                 response = await self._connection.setClimaterSettings(self.vin, data)
                 return await self._handle_response(
@@ -483,28 +402,27 @@ class Vehicle:
                     topic="climatisation",
                     error_msg="Failed to set climatisation settings",
                 )
-            _LOGGER.error('Set climatisation setting to "%s" is not supported', value)
-            raise Exception(f'Set climatisation setting to "{value}" is not supported.')  # pylint: disable=broad-exception-raised
-        _LOGGER.error("Climatisation settings are not supported")
-        raise Exception("Climatisation settings are not supported.")  # pylint: disable=broad-exception-raised
+            else:
+                _LOGGER.error(f'Set climatisation setting to "{value}" is not supported.')
+                raise Exception(f'Set climatisation setting to "{value}" is not supported.')
+        else:
+            _LOGGER.error("Climatisation settings are not supported.")
+            raise Exception("Climatisation settings are not supported.")
 
     async def set_window_heating(self, action="stop"):
         """Turn on/off window heater."""
         if self.is_window_heater_supported:
             if action not in ["start", "stop"]:
-                _LOGGER.error('Window heater action "%s" is not supported', action)
-                raise Exception(f'Window heater action "{action}" is not supported.')  # pylint: disable=broad-exception-raised
+                _LOGGER.error(f'Window heater action "{action}" is not supported.')
+                raise Exception(f'Window heater action "{action}" is not supported.')
             self._requests["latest"] = "Climatisation"
-            response = await self._connection.setWindowHeater(
-                self.vin, (action == "start")
-            )
+            response = await self._connection.setWindowHeater(self.vin, (action == "start"))
             return await self._handle_response(
-                response=response,
-                topic="climatisation",
-                error_msg=f"Failed to {action} window heating",
+                response=response, topic="climatisation", error_msg=f"Failed to {action} window heating"
             )
-        _LOGGER.error("No climatisation support")
-        raise Exception("No climatisation support.")  # pylint: disable=broad-exception-raised
+        else:
+            _LOGGER.error("No climatisation support.")
+            raise Exception("No climatisation support.")
 
     async def set_climatisation(self, action="stop"):
         """Turn on/off climatisation with electric heater."""
@@ -515,9 +433,7 @@ class Vehicle:
                     "targetTemperatureUnit": "celsius",
                 }
                 if self.is_climatisation_without_external_power_supported:
-                    data["climatisationWithoutExternalPower"] = (
-                        self.climatisation_without_external_power
-                    )
+                    data["climatisationWithoutExternalPower"] = self.climatisation_without_external_power
                 if self.is_auxiliary_air_conditioning_supported:
                     data["climatizationAtUnlock"] = self.auxiliary_air_conditioning
                 if self.is_automatic_window_heating_supported:
@@ -529,19 +445,18 @@ class Vehicle:
             elif action == "stop":
                 data = {}
             else:
-                _LOGGER.error("Invalid climatisation action: %s", action)
-                raise Exception(f"Invalid climatisation action: {action}")  # pylint: disable=broad-exception-raised
+                _LOGGER.error(f"Invalid climatisation action: {action}")
+                raise Exception(f"Invalid climatisation action: {action}")
             self._requests["latest"] = "Climatisation"
-            response = await self._connection.setClimater(
-                self.vin, data, (action == "start")
-            )
+            response = await self._connection.setClimater(self.vin, data, (action == "start"))
             return await self._handle_response(
                 response=response,
                 topic="climatisation",
                 error_msg=f"Failed to {action} climatisation with electric heater.",
             )
-        _LOGGER.error("No climatisation support")
-        raise Exception("No climatisation support.")  # pylint: disable=broad-exception-raised
+        else:
+            _LOGGER.error("No climatisation support.")
+            raise Exception("No climatisation support.")
 
     async def set_auxiliary_climatisation(self, action, spin):
         """Turn on/off climatisation with auxiliary heater."""
@@ -553,102 +468,72 @@ class Vehicle:
             elif action == "stop":
                 data = {}
             else:
-                _LOGGER.error("Invalid auxiliary heater action: %s", action)
-                raise Exception(f"Invalid auxiliary heater action: {action}")  # pylint: disable=broad-exception-raised
+                _LOGGER.error(f"Invalid auxiliary heater action: {action}")
+                raise Exception(f"Invalid auxiliary heater action: {action}")
             self._requests["latest"] = "Climatisation"
-            response = await self._connection.setAuxiliary(
-                self.vin, data, (action == "start")
-            )
+            response = await self._connection.setAuxiliary(self.vin, data, (action == "start"))
             return await self._handle_response(
                 response=response,
                 topic="climatisation",
                 error_msg=f"Failed to {action} climatisation with auxiliary heater.",
             )
-        _LOGGER.error("No climatisation support")
-        raise Exception("No climatisation support.")  # pylint: disable=broad-exception-raised
+        else:
+            _LOGGER.error("No climatisation support.")
+            raise Exception("No climatisation support.")
 
     async def set_departure_timer(self, timer_id, spin, enable) -> bool:
         """Turn on/off departure timer."""
         if self.is_departure_timer_supported(timer_id):
-            if not isinstance(enable, bool):
-                _LOGGER.error("Charging departure timers setting is not supported")
-                raise Exception("Charging departure timers setting is not supported.")  # pylint: disable=broad-exception-raised
+            if type(enable) is not bool:
+                _LOGGER.error("Charging departure timers setting is not supported.")
+                raise Exception("Charging departure timers setting is not supported.")
             data = None
             response = None
             if is_valid_path(
-                self.attrs,
-                f"{Services.DEPARTURE_PROFILES}.departureProfilesStatus.value.timers",
-            ) and is_valid_path(
-                self.attrs,
-                f"{Services.DEPARTURE_PROFILES}.departureProfilesStatus.value.profiles",
-            ):
-                timers = find_path(
-                    self.attrs,
-                    f"{Services.DEPARTURE_PROFILES}.departureProfilesStatus.value.timers",
-                )
+                self.attrs, f"{Services.DEPARTURE_PROFILES}.departureProfilesStatus.value.timers"
+            ) and is_valid_path(self.attrs, f"{Services.DEPARTURE_PROFILES}.departureProfilesStatus.value.profiles"):
+                timers = find_path(self.attrs, f"{Services.DEPARTURE_PROFILES}.departureProfilesStatus.value.timers")
                 profiles = find_path(
-                    self.attrs,
-                    f"{Services.DEPARTURE_PROFILES}.departureProfilesStatus.value.profiles",
+                    self.attrs, f"{Services.DEPARTURE_PROFILES}.departureProfilesStatus.value.profiles"
                 )
-                for index, timer in enumerate(timers):
-                    if timer.get("id", 0) == timer_id:
-                        timers[index]["enabled"] = enable
+                for i in range(len(timers)):
+                    if timers[i].get("id", 0) == timer_id:
+                        timers[i]["enabled"] = enable
                 data = {"timers": timers, "profiles": profiles}
                 response = await self._connection.setDepartureProfiles(self.vin, data)
-            if is_valid_path(
-                self.attrs,
-                f"{Services.CLIMATISATION_TIMERS}.auxiliaryHeatingTimersStatus.value.timers",
-            ):
+            if is_valid_path(self.attrs, f"{Services.CLIMATISATION_TIMERS}.auxiliaryHeatingTimersStatus.value.timers"):
                 timers = find_path(
-                    self.attrs,
-                    f"{Services.CLIMATISATION_TIMERS}.auxiliaryHeatingTimersStatus.value.timers",
+                    self.attrs, f"{Services.CLIMATISATION_TIMERS}.auxiliaryHeatingTimersStatus.value.timers"
                 )
-                for index, timer in enumerate(timers):
-                    if timer.get("id", 0) == timer_id:
-                        timers[index]["enabled"] = enable
+                for i in range(len(timers)):
+                    if timers[i].get("id", 0) == timer_id:
+                        timers[i]["enabled"] = enable
                 data = {"spin": spin, "timers": timers}
-                response = await self._connection.setAuxiliaryHeatingTimers(
-                    self.vin, data
-                )
-            if is_valid_path(
-                self.attrs,
-                f"{Services.DEPARTURE_TIMERS}.departureTimersStatus.value.timers",
-            ):
-                timers = find_path(
-                    self.attrs,
-                    f"{Services.DEPARTURE_TIMERS}.departureTimersStatus.value.timers",
-                )
-                for index, timer in enumerate(timers):
-                    if timer.get("id", 0) == timer_id:
-                        timers[index]["enabled"] = enable
+                response = await self._connection.setAuxiliaryHeatingTimers(self.vin, data)
+            if is_valid_path(self.attrs, f"{Services.DEPARTURE_TIMERS}.departureTimersStatus.value.timers"):
+                timers = find_path(self.attrs, f"{Services.DEPARTURE_TIMERS}.departureTimersStatus.value.timers")
+                for i in range(len(timers)):
+                    if timers[i].get("id", 0) == timer_id:
+                        timers[i]["enabled"] = enable
                 data = {"timers": timers}
                 response = await self._connection.setDepartureTimers(self.vin, data)
             return await self._handle_response(
-                response=response,
-                topic="departuretimer",
-                error_msg="Failed to change departure timers setting.",
+                response=response, topic="departuretimer", error_msg="Failed to change departure timers setting."
             )
-        _LOGGER.error("Departure timers are not supported")
-        raise Exception("Departure timers are not supported.")  # pylint: disable=broad-exception-raised
+        else:
+            _LOGGER.error("Departure timers are not supported.")
+            raise Exception("Departure timers are not supported.")
 
     async def set_ac_departure_timer(self, timer_id, enable) -> bool:
         """Turn on/off ac departure timer."""
         if self.is_ac_departure_timer_supported(timer_id):
-            if not isinstance(enable, bool):
-                _LOGGER.error(
-                    "Charging climatisation departure timers setting is not supported"
-                )
-                # pylint: disable=broad-exception-raised
-                raise Exception(
-                    "Charging climatisation departure timers setting is not supported."
-                )
-            timers = find_path(
-                self.attrs,
-                f"{Services.CLIMATISATION_TIMERS}.climatisationTimersStatus.value.timers",
-            )
-            for index, timer in enumerate(timers):
-                if timer.get("id", 0) == timer_id:
-                    timers[index]["enabled"] = enable
+            if type(enable) is not bool:
+                _LOGGER.error("Charging climatisation departure timers setting is not supported.")
+                raise Exception("Charging climatisation departure timers setting is not supported.")
+            timers = find_path(self.attrs, f"{Services.CLIMATISATION_TIMERS}.climatisationTimersStatus.value.timers")
+            for i in range(len(timers)):
+                if timers[i].get("id", 0) == timer_id:
+                    timers[i]["enabled"] = enable
             data = {"timers": timers}
             response = await self._connection.setClimatisationTimers(self.vin, data)
             return await self._handle_response(
@@ -656,38 +541,32 @@ class Vehicle:
                 topic="departuretimer",
                 error_msg="Failed to change climatisation departure timers setting.",
             )
-        _LOGGER.error("Climatisation departure timers are not supported")
-        raise Exception("Climatisation departure timers are not supported.")  # pylint: disable=broad-exception-raised
+        else:
+            _LOGGER.error("Climatisation departure timers are not supported.")
+            raise Exception("Climatisation departure timers are not supported.")
 
     # Lock (RLU)
     async def set_lock(self, action, spin):
         """Remote lock and unlock actions."""
         if not self._services.get(Services.ACCESS, {}).get("active", False):
-            _LOGGER.info("Remote lock/unlock is not supported")
-            raise Exception("Remote lock/unlock is not supported.")  # pylint: disable=broad-exception-raised
+            _LOGGER.info("Remote lock/unlock is not supported.")
+            raise Exception("Remote lock/unlock is not supported.")
         if self._in_progress("lock", unknown_offset=-5):
             return False
         if action not in ["lock", "unlock"]:
-            _LOGGER.error("Invalid lock action: %s", action)
-            raise Exception(f"Invalid lock action: {action}")  # pylint: disable=broad-exception-raised
+            _LOGGER.error(f"Invalid lock action: {action}")
+            raise Exception(f"Invalid lock action: {action}")
 
         try:
             self._requests["latest"] = "Lock"
-            response = await self._connection.setLock(
-                self.vin, (action == "lock"), spin
-            )
+            response = await self._connection.setLock(self.vin, (action == "lock"), spin)
             return await self._handle_response(
-                response=response,
-                topic="access",
-                error_msg=f"Failed to {action} vehicle",
+                response=response, topic="access", error_msg=f"Failed to {action} vehicle"
             )
-        except Exception as error:  # pylint: disable=broad-exception-caught
-            _LOGGER.warning("Failed to %s vehicle - %s", action, error)
-            self._requests["lock"] = {
-                "status": "Exception",
-                "timestamp": datetime.now(UTC),
-            }
-        raise Exception("Lock action failed")  # pylint: disable=broad-exception-raised
+        except Exception as error:
+            _LOGGER.warning(f"Failed to {action} vehicle - {error}")
+            self._requests["lock"] = {"status": "Exception", "timestamp": datetime.now(timezone.utc)}
+        raise Exception("Lock action failed")
 
     # Refresh vehicle data (VSR)
     async def set_refresh(self):
@@ -701,46 +580,40 @@ class Vehicle:
                 if response.status == 204:
                     self._requests["state"] = "in_progress"
                     self._requests["refresh"] = {
-                        "timestamp": datetime.now(UTC),
+                        "timestamp": datetime.now(timezone.utc),
                         "status": "in_progress",
                         "id": 0,
                     }
                     status = await self.wait_for_data_refresh()
                 elif response.status == 429:
                     status = "Throttled"
-                    _LOGGER.debug("Server side throttled. Try again later")
+                    _LOGGER.debug("Server side throttled. Try again later.")
                 else:
-                    _LOGGER.debug(
-                        "Unable to refresh the data. Incorrect response code: %s",
-                        response.status,
-                    )
+                    _LOGGER.debug(f"Unable to refresh the data. Incorrect response code: {response.status}")
                 self._requests["state"] = status
-                self._requests["refresh"] = {
-                    "status": status,
-                    "timestamp": datetime.now(UTC),
-                }
+                self._requests["refresh"] = {"status": status, "timestamp": datetime.now(timezone.utc)}
                 return True
-            _LOGGER.debug("Unable to refresh the data")
-        except Exception as error:  # pylint: disable=broad-exception-caught
-            _LOGGER.warning("Failed to execute data refresh - %s", error)
-            self._requests["refresh"] = {
-                "status": "Exception",
-                "timestamp": datetime.now(UTC),
-            }
-        raise Exception("Data refresh failed")  # pylint: disable=broad-exception-raised
+            else:
+                _LOGGER.debug("Unable to refresh the data.")
+        except Exception as error:
+            _LOGGER.warning(f"Failed to execute data refresh - {error}")
+            self._requests["refresh"] = {"status": "Exception", "timestamp": datetime.now(timezone.utc)}
+        raise Exception("Data refresh failed")
 
     # Vehicle class helpers #
     # Vehicle info
     @property
     def attrs(self):
-        """Return all attributes.
+        """
+        Return all attributes.
 
         :return:
         """
         return self._states
 
     def has_attr(self, attr) -> bool:
-        """Return true if attribute exists.
+        """
+        Return true if attribute exists.
 
         :param attr:
         :return:
@@ -748,7 +621,8 @@ class Vehicle:
         return is_valid_path(self.attrs, attr)
 
     def get_attr(self, attr):
-        """Return a specific attribute.
+        """
+        Return a specific attribute.
 
         :param attr:
         :return:
@@ -758,44 +632,41 @@ class Vehicle:
     async def expired(self, service):
         """Check if access to service has expired."""
         try:
-            now = datetime.now(UTC)
+            now = datetime.utcnow()
             if self._services.get(service, {}).get("expiration", False):
                 expiration = self._services.get(service, {}).get("expiration", False)
                 if not expiration:
-                    expiration = datetime.neow(UTC) + timedelta(days=1)
+                    expiration = datetime.utcnow() + timedelta(days=1)
             else:
-                _LOGGER.debug(
-                    "Could not determine end of access for service %s, assuming it is valid",
-                    service,
-                )
-                expiration = datetime.now(UTC) + timedelta(days=1)
+                _LOGGER.debug(f"Could not determine end of access for service {service}, assuming it is valid")
+                expiration = datetime.utcnow() + timedelta(days=1)
             expiration = expiration.replace(tzinfo=None)
             if now >= expiration:
-                _LOGGER.warning("Access to %s has expired!", service)
+                _LOGGER.warning(f"Access to {service} has expired!")
                 self._discovered = False
                 return True
-        except Exception:  # pylint: disable=broad-exception-caught
-            _LOGGER.debug(
-                "Exception. Could not determine end of access for service %s, assuming it is valid",
-                service,
-            )
-            return False
-        else:
+            else:
+                return False
+        except Exception:
+            _LOGGER.debug(f"Exception. Could not determine end of access for service {service}, assuming it is valid")
             return False
 
     def dashboard(self, **config):
-        """Return dashboard with specified configuration.
+        """
+        Return dashboard with specified configuration.
 
         :param config:
         :return:
         """
-        from .vw_dashboard import Dashboard  # pylint: disable=import-outside-toplevel
+        # Classic python notation
+        from .vw_dashboard import Dashboard
 
         return Dashboard(self, **config)
 
     @property
     def vin(self) -> str:
-        """Vehicle identification number.
+        """
+        Vehicle identification number.
 
         :return:
         """
@@ -803,7 +674,8 @@ class Vehicle:
 
     @property
     def unique_id(self) -> str:
-        """Return unique id for the vehicle (vin).
+        """
+        Return unique id for the vehicle (vin).
 
         :return:
         """
@@ -813,7 +685,8 @@ class Vehicle:
     # Car information
     @property
     def nickname(self) -> str | None:
-        """Return nickname of the vehicle.
+        """
+        Return nickname of the vehicle.
 
         :return:
         """
@@ -821,7 +694,8 @@ class Vehicle:
 
     @property
     def is_nickname_supported(self) -> bool:
-        """Return true if naming the vehicle is supported.
+        """
+        Return true if naming the vehicle is supported.
 
         :return:
         """
@@ -829,7 +703,8 @@ class Vehicle:
 
     @property
     def deactivated(self) -> bool | None:
-        """Return true if service is deactivated.
+        """
+        Return true if service is deactivated.
 
         :return:
         """
@@ -837,7 +712,8 @@ class Vehicle:
 
     @property
     def is_deactivated_supported(self) -> bool:
-        """Return true if service deactivation status is supported.
+        """
+        Return true if service deactivation status is supported.
 
         :return:
         """
@@ -871,7 +747,8 @@ class Vehicle:
 
     @property
     def is_model_image_supported(self) -> bool:
-        """Return true if vehicle model image is supported.
+        """
+        Return true if vehicle model image is supported.
 
         :return:
         """
@@ -882,27 +759,17 @@ class Vehicle:
     @property
     def parking_light(self) -> bool:
         """Return true if parking light is on."""
-        lights = (
-            self.attrs.get(Services.VEHICLE_LIGHTS)
-            .get("lightsStatus")
-            .get("value")
-            .get("lights")
-        )
+        lights = self.attrs.get(Services.VEHICLE_LIGHTS).get("lightsStatus").get("value").get("lights")
         lights_on_count = 0
         for light in lights:
             if light["status"] == "on":
                 lights_on_count = lights_on_count + 1
-        return lights_on_count == 2
+        return lights_on_count == 1
 
     @property
     def parking_light_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return (
-            self.attrs.get(Services.VEHICLE_LIGHTS)
-            .get("lightsStatus")
-            .get("value")
-            .get("carCapturedTimestamp")
-        )
+        return self.attrs.get(Services.VEHICLE_LIGHTS).get("lightsStatus").get("value").get("carCapturedTimestamp")
 
     @property
     def is_parking_light_supported(self) -> bool:
@@ -918,35 +785,33 @@ class Vehicle:
         # this field is only a dirty hack, because there is no overarching information for the car anymore,
         # only information per service, so we just use the one for fuelStatus.rangeStatus when car is ideling
         # and charing.batteryStatus when electic car is charging
-        # Return attribute last updated timestamp.
+        """Return attribute last updated timestamp."""
         if self.is_battery_level_supported and self.charging:
             return self.battery_level_last_updated
-        if self.is_distance_supported:
-            if isinstance(self.distance_last_updated, str):
+        elif self.is_distance_supported:
+            if type(self.distance_last_updated) is str:
                 return (
-                    datetime.strptime(
-                        self.distance_last_updated, "%Y-%m-%dT%H:%M:%S.%fZ"
-                    )
+                    datetime.strptime(self.distance_last_updated, "%Y-%m-%dT%H:%M:%S.%fZ")
                     .replace(microsecond=0)
-                    .replace(tzinfo=UTC)
+                    .replace(tzinfo=timezone.utc)
                 )
-            return self.distance_last_updated
+            else:
+                return self.distance_last_updated
 
     @property
     def last_connected_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
         if self.is_battery_level_supported and self.charging:
             return self.battery_level_last_updated
-        if self.is_distance_supported:
-            if isinstance(self.distance_last_updated, str):
+        elif self.is_distance_supported:
+            if type(self.distance_last_updated) is str:
                 return (
-                    datetime.strptime(
-                        self.distance_last_updated, "%Y-%m-%dT%H:%M:%S.%fZ"
-                    )
+                    datetime.strptime(self.distance_last_updated, "%Y-%m-%dT%H:%M:%S.%fZ")
                     .replace(microsecond=0)
-                    .replace(tzinfo=UTC)
+                    .replace(tzinfo=timezone.utc)
                 )
-            return self.distance_last_updated
+            else:
+                return self.distance_last_updated
 
     @property
     def is_last_connected_supported(self) -> bool:
@@ -957,495 +822,326 @@ class Vehicle:
     @property
     def distance(self) -> int | None:
         """Return vehicle odometer."""
-        return find_path(
-            self.attrs, f"{Services.MEASUREMENTS}.odometerStatus.value.odometer"
-        )
+        return find_path(self.attrs, f"{Services.MEASUREMENTS}.odometerStatus.value.odometer")
 
     @property
     def distance_last_updated(self) -> datetime:
         """Return last updated timestamp."""
-        return find_path(
-            self.attrs,
-            f"{Services.MEASUREMENTS}.odometerStatus.value.carCapturedTimestamp",
-        )
+        return find_path(self.attrs, f"{Services.MEASUREMENTS}.odometerStatus.value.carCapturedTimestamp")
 
     @property
     def is_distance_supported(self) -> bool:
         """Return true if odometer is supported."""
-        return is_valid_path(
-            self.attrs, f"{Services.MEASUREMENTS}.odometerStatus.value.odometer"
-        )
+        return is_valid_path(self.attrs, f"{Services.MEASUREMENTS}.odometerStatus.value.odometer")
 
     @property
     def service_inspection(self):
         """Return time left for service inspection."""
-        return find_path(
-            self.attrs,
-            f"{Services.VEHICLE_HEALTH_INSPECTION}.maintenanceStatus.value.inspectionDue_days",
-        )
+        return find_path(self.attrs, f"{Services.VEHICLE_HEALTH_INSPECTION}.maintenanceStatus.value.inspectionDue_days")
 
     @property
     def service_inspection_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
         return find_path(
-            self.attrs,
-            f"{Services.VEHICLE_HEALTH_INSPECTION}.maintenanceStatus.value.carCapturedTimestamp",
+            self.attrs, f"{Services.VEHICLE_HEALTH_INSPECTION}.maintenanceStatus.value.carCapturedTimestamp"
         )
 
     @property
     def is_service_inspection_supported(self) -> bool:
-        """Return true if days to service inspection is supported.
+        """
+        Return true if days to service inspection is supported.
 
         :return:
         """
         return is_valid_path(
-            self.attrs,
-            f"{Services.VEHICLE_HEALTH_INSPECTION}.maintenanceStatus.value.inspectionDue_days",
+            self.attrs, f"{Services.VEHICLE_HEALTH_INSPECTION}.maintenanceStatus.value.inspectionDue_days"
         )
 
     @property
     def service_inspection_distance(self):
         """Return distance left for service inspection."""
-        return find_path(
-            self.attrs,
-            f"{Services.VEHICLE_HEALTH_INSPECTION}.maintenanceStatus.value.inspectionDue_km",
-        )
+        return find_path(self.attrs, f"{Services.VEHICLE_HEALTH_INSPECTION}.maintenanceStatus.value.inspectionDue_km")
 
     @property
     def service_inspection_distance_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
         return find_path(
-            self.attrs,
-            f"{Services.VEHICLE_HEALTH_INSPECTION}.maintenanceStatus.value.carCapturedTimestamp",
+            self.attrs, f"{Services.VEHICLE_HEALTH_INSPECTION}.maintenanceStatus.value.carCapturedTimestamp"
         )
 
     @property
     def is_service_inspection_distance_supported(self) -> bool:
-        """Return true if distance to service inspection is supported.
+        """
+        Return true if distance to service inspection is supported.
 
         :return:
         """
         return is_valid_path(
-            self.attrs,
-            f"{Services.VEHICLE_HEALTH_INSPECTION}.maintenanceStatus.value.inspectionDue_km",
+            self.attrs, f"{Services.VEHICLE_HEALTH_INSPECTION}.maintenanceStatus.value.inspectionDue_km"
         )
 
     @property
     def oil_inspection(self):
         """Return time left for oil inspection."""
-        return find_path(
-            self.attrs,
-            f"{Services.VEHICLE_HEALTH_INSPECTION}.maintenanceStatus.value.oilServiceDue_days",
-        )
+        return find_path(self.attrs, f"{Services.VEHICLE_HEALTH_INSPECTION}.maintenanceStatus.value.oilServiceDue_days")
 
     @property
     def oil_inspection_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
         return find_path(
-            self.attrs,
-            f"{Services.VEHICLE_HEALTH_INSPECTION}.maintenanceStatus.value.carCapturedTimestamp",
+            self.attrs, f"{Services.VEHICLE_HEALTH_INSPECTION}.maintenanceStatus.value.carCapturedTimestamp"
         )
 
     @property
     def is_oil_inspection_supported(self) -> bool:
-        """Return true if days to oil inspection is supported.
+        """
+        Return true if days to oil inspection is supported.
 
         :return:
         """
         if not self.has_combustion_engine:
             return False
         return is_valid_path(
-            self.attrs,
-            f"{Services.VEHICLE_HEALTH_INSPECTION}.maintenanceStatus.value.oilServiceDue_days",
+            self.attrs, f"{Services.VEHICLE_HEALTH_INSPECTION}.maintenanceStatus.value.oilServiceDue_days"
         )
 
     @property
     def oil_inspection_distance(self):
         """Return distance left for oil inspection."""
-        return find_path(
-            self.attrs,
-            f"{Services.VEHICLE_HEALTH_INSPECTION}.maintenanceStatus.value.oilServiceDue_km",
-        )
+        return find_path(self.attrs, f"{Services.VEHICLE_HEALTH_INSPECTION}.maintenanceStatus.value.oilServiceDue_km")
 
     @property
     def oil_inspection_distance_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
         return find_path(
-            self.attrs,
-            f"{Services.VEHICLE_HEALTH_INSPECTION}.maintenanceStatus.value.carCapturedTimestamp",
+            self.attrs, f"{Services.VEHICLE_HEALTH_INSPECTION}.maintenanceStatus.value.carCapturedTimestamp"
         )
 
     @property
     def is_oil_inspection_distance_supported(self) -> bool:
-        """Return true if oil inspection distance is supported.
+        """
+        Return true if oil inspection distance is supported.
 
         :return:
         """
         if not self.has_combustion_engine:
             return False
         return is_valid_path(
-            self.attrs,
-            f"{Services.VEHICLE_HEALTH_INSPECTION}.maintenanceStatus.value.oilServiceDue_km",
+            self.attrs, f"{Services.VEHICLE_HEALTH_INSPECTION}.maintenanceStatus.value.oilServiceDue_km"
         )
 
     @property
     def adblue_level(self) -> int:
         """Return adblue level."""
-        return find_path(
-            self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.adBlueRange"
-        )
+        return find_path(self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.adBlueRange")
 
     @property
     def adblue_level_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return find_path(
-            self.attrs,
-            f"{Services.MEASUREMENTS}.rangeStatus.value.carCapturedTimestamp",
-        )
+        return find_path(self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.carCapturedTimestamp")
 
     @property
     def is_adblue_level_supported(self) -> bool:
         """Return true if adblue level is supported."""
-        return is_valid_path(
-            self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.adBlueRange"
-        )
+        return is_valid_path(self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.adBlueRange")
 
     # Charger related states for EV and PHEV
     @property
     def charging(self) -> bool:
         """Return charging state."""
-        cstate = find_path(
-            self.attrs, f"{Services.CHARGING}.chargingStatus.value.chargingState"
-        )
+        cstate = find_path(self.attrs, f"{Services.CHARGING}.chargingStatus.value.chargingState")
         return cstate == "charging"
 
     @property
     def charging_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return find_path(
-            self.attrs, f"{Services.CHARGING}.chargingStatus.value.carCapturedTimestamp"
-        )
+        return find_path(self.attrs, f"{Services.CHARGING}.chargingStatus.value.carCapturedTimestamp")
 
     @property
     def is_charging_supported(self) -> bool:
         """Return true if charging is supported."""
-        return is_valid_path(
-            self.attrs, f"{Services.CHARGING}.chargingStatus.value.chargingState"
-        )
+        return is_valid_path(self.attrs, f"{Services.CHARGING}.chargingStatus.value.chargingState")
 
     @property
     def charging_power(self) -> int:
         """Return charging power."""
-        return find_path(
-            self.attrs, f"{Services.CHARGING}.chargingStatus.value.chargePower_kW"
-        )
+        return find_path(self.attrs, f"{Services.CHARGING}.chargingStatus.value.chargePower_kW")
 
     @property
     def charging_power_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return find_path(
-            self.attrs, f"{Services.CHARGING}.chargingStatus.value.carCapturedTimestamp"
-        )
+        return find_path(self.attrs, f"{Services.CHARGING}.chargingStatus.value.carCapturedTimestamp")
 
     @property
     def is_charging_power_supported(self) -> bool:
         """Return true if charging power is supported."""
-        return is_valid_path(
-            self.attrs, f"{Services.CHARGING}.chargingStatus.value.chargePower_kW"
-        )
+        return is_valid_path(self.attrs, f"{Services.CHARGING}.chargingStatus.value.chargePower_kW")
 
     @property
     def charging_rate(self) -> int:
         """Return charging rate."""
-        return find_path(
-            self.attrs, f"{Services.CHARGING}.chargingStatus.value.chargeRate_kmph"
-        )
+        return find_path(self.attrs, f"{Services.CHARGING}.chargingStatus.value.chargeRate_kmph")
 
     @property
     def charging_rate_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return find_path(
-            self.attrs, f"{Services.CHARGING}.chargingStatus.value.carCapturedTimestamp"
-        )
+        return find_path(self.attrs, f"{Services.CHARGING}.chargingStatus.value.carCapturedTimestamp")
 
     @property
     def is_charging_rate_supported(self) -> bool:
         """Return true if charging rate is supported."""
-        return is_valid_path(
-            self.attrs, f"{Services.CHARGING}.chargingStatus.value.chargeRate_kmph"
-        )
+        return is_valid_path(self.attrs, f"{Services.CHARGING}.chargingStatus.value.chargeRate_kmph")
 
     @property
     def charger_type(self) -> str:
         """Return charger type."""
-        charger_type = find_path(
-            self.attrs, f"{Services.CHARGING}.chargingStatus.value.chargeType"
-        )
+        charger_type = find_path(self.attrs, f"{Services.CHARGING}.chargingStatus.value.chargeType")
         if charger_type == "ac":
             return "AC"
-        if charger_type == "dc":
+        elif charger_type == "dc":
             return "DC"
         return "Unknown"
 
     @property
     def charger_type_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return find_path(
-            self.attrs, f"{Services.CHARGING}.chargingStatus.value.carCapturedTimestamp"
-        )
+        return find_path(self.attrs, f"{Services.CHARGING}.chargingStatus.value.carCapturedTimestamp")
 
     @property
     def is_charger_type_supported(self) -> bool:
         """Return true if charger type is supported."""
-        return is_valid_path(
-            self.attrs, f"{Services.CHARGING}.chargingStatus.value.chargeType"
-        )
+        return is_valid_path(self.attrs, f"{Services.CHARGING}.chargingStatus.value.chargeType")
 
     @property
     def battery_level(self) -> int:
         """Return battery level."""
-        return find_path(
-            self.attrs, f"{Services.CHARGING}.batteryStatus.value.currentSOC_pct"
-        )
+        return find_path(self.attrs, f"{Services.CHARGING}.batteryStatus.value.currentSOC_pct")
 
     @property
     def battery_level_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return find_path(
-            self.attrs, f"{Services.CHARGING}.batteryStatus.value.carCapturedTimestamp"
-        )
+        return find_path(self.attrs, f"{Services.CHARGING}.batteryStatus.value.carCapturedTimestamp")
 
     @property
     def is_battery_level_supported(self) -> bool:
         """Return true if battery level is supported."""
-        return is_valid_path(
-            self.attrs, f"{Services.CHARGING}.batteryStatus.value.currentSOC_pct"
-        )
+        return is_valid_path(self.attrs, f"{Services.CHARGING}.batteryStatus.value.currentSOC_pct")
 
     @property
     def battery_target_charge_level(self) -> int:
         """Return target charge level."""
-        return find_path(
-            self.attrs, f"{Services.CHARGING}.chargingSettings.value.targetSOC_pct"
-        )
+        return find_path(self.attrs, f"{Services.CHARGING}.chargingSettings.value.targetSOC_pct")
 
     @property
     def battery_target_charge_level_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return find_path(
-            self.attrs,
-            f"{Services.CHARGING}.chargingSettings.value.carCapturedTimestamp",
-        )
+        return find_path(self.attrs, f"{Services.CHARGING}.chargingSettings.value.carCapturedTimestamp")
 
     @property
     def is_battery_target_charge_level_supported(self) -> bool:
         """Return true if target charge level is supported."""
-        return is_valid_path(
-            self.attrs, f"{Services.CHARGING}.chargingSettings.value.targetSOC_pct"
-        )
-
-    @property
-    def hv_battery_min_temperature(self) -> int:
-        """Return HV battery min temperature."""
-        return (
-            float(
-                find_path(
-                    self.attrs,
-                    f"{Services.MEASUREMENTS}.temperatureBatteryStatus.value.temperatureHvBatteryMin_K",
-                )
-            )
-            - 273.15
-        )
-
-    @property
-    def hv_battery_min_temperature_last_updated(self) -> datetime:
-        """Return attribute last updated timestamp."""
-        return find_path(
-            self.attrs,
-            f"{Services.MEASUREMENTS}.temperatureBatteryStatus.value.carCapturedTimestamp",
-        )
-
-    @property
-    def is_hv_battery_min_temperature_supported(self) -> bool:
-        """Return true if HV battery min temperature is supported."""
-        return is_valid_path(
-            self.attrs,
-            f"{Services.MEASUREMENTS}.temperatureBatteryStatus.value.temperatureHvBatteryMin_K",
-        )
-
-    @property
-    def hv_battery_max_temperature(self) -> int:
-        """Return HV battery max temperature."""
-        return (
-            float(
-                find_path(
-                    self.attrs,
-                    f"{Services.MEASUREMENTS}.temperatureBatteryStatus.value.temperatureHvBatteryMax_K",
-                )
-            )
-            - 273.15
-        )
-
-    @property
-    def hv_battery_max_temperature_last_updated(self) -> datetime:
-        """Return attribute last updated timestamp."""
-        return find_path(
-            self.attrs,
-            f"{Services.MEASUREMENTS}.temperatureBatteryStatus.value.carCapturedTimestamp",
-        )
-
-    @property
-    def is_hv_battery_max_temperature_supported(self) -> bool:
-        """Return true if HV battery max temperature is supported."""
-        return is_valid_path(
-            self.attrs,
-            f"{Services.MEASUREMENTS}.temperatureBatteryStatus.value.temperatureHvBatteryMax_K",
-        )
+        return is_valid_path(self.attrs, f"{Services.CHARGING}.chargingSettings.value.targetSOC_pct")
 
     @property
     def charge_max_ac_setting(self) -> str | int:
         """Return charger max ampere setting."""
-        return find_path(
-            self.attrs, f"{Services.CHARGING}.chargingSettings.value.maxChargeCurrentAC"
-        )
+        value = find_path(self.attrs, f"{Services.CHARGING}.chargingSettings.value.maxChargeCurrentAC")
+        return value
 
     @property
     def charge_max_ac_setting_last_updated(self) -> datetime:
         """Return charger max ampere last updated."""
-        return find_path(
-            self.attrs,
-            f"{Services.CHARGING}.chargingSettings.value.carCapturedTimestamp",
-        )
+        return find_path(self.attrs, f"{Services.CHARGING}.chargingSettings.value.carCapturedTimestamp")
 
     @property
     def is_charge_max_ac_setting_supported(self) -> bool:
         """Return true if Charger Max Ampere is supported."""
-        if is_valid_path(
-            self.attrs, f"{Services.CHARGING}.chargingSettings.value.maxChargeCurrentAC"
-        ):
-            value = find_path(
-                self.attrs,
-                f"{Services.CHARGING}.chargingSettings.value.maxChargeCurrentAC",
-            )
+        if is_valid_path(self.attrs, f"{Services.CHARGING}.chargingSettings.value.maxChargeCurrentAC"):
+            value = find_path(self.attrs, f"{Services.CHARGING}.chargingSettings.value.maxChargeCurrentAC")
             return value in ["reduced", "maximum", "invalid"]
         return False
 
     @property
     def charge_max_ac_ampere(self) -> str | int:
         """Return charger max ampere setting."""
-        return find_path(
-            self.attrs,
-            f"{Services.CHARGING}.chargingSettings.value.maxChargeCurrentAC_A",
-        )
+        return find_path(self.attrs, f"{Services.CHARGING}.chargingSettings.value.maxChargeCurrentAC_A")
 
     @property
     def charge_max_ac_ampere_last_updated(self) -> datetime:
         """Return charger max ampere last updated."""
-        return find_path(
-            self.attrs,
-            f"{Services.CHARGING}.chargingSettings.value.carCapturedTimestamp",
-        )
+        return find_path(self.attrs, f"{Services.CHARGING}.chargingSettings.value.carCapturedTimestamp")
 
     @property
     def is_charge_max_ac_ampere_supported(self) -> bool:
         """Return true if Charger Max Ampere is supported."""
-        return is_valid_path(
-            self.attrs,
-            f"{Services.CHARGING}.chargingSettings.value.maxChargeCurrentAC_A",
-        )
+        return is_valid_path(self.attrs, f"{Services.CHARGING}.chargingSettings.value.maxChargeCurrentAC_A")
 
     @property
     def charging_cable_locked(self) -> bool:
         """Return plug locked state."""
-        response = find_path(
-            self.attrs, f"{Services.CHARGING}.plugStatus.value.plugLockState"
-        )
+        response = find_path(self.attrs, f"{Services.CHARGING}.plugStatus.value.plugLockState")
         return response == "locked"
 
     @property
     def charging_cable_locked_last_updated(self) -> datetime:
         """Return plug locked state."""
-        return find_path(
-            self.attrs, f"{Services.CHARGING}.plugStatus.value.carCapturedTimestamp"
-        )
+        return find_path(self.attrs, f"{Services.CHARGING}.plugStatus.value.carCapturedTimestamp")
 
     @property
     def is_charging_cable_locked_supported(self) -> bool:
         """Return true if plug locked state is supported."""
-        return is_valid_path(
-            self.attrs, f"{Services.CHARGING}.plugStatus.value.plugLockState"
-        )
+        return is_valid_path(self.attrs, f"{Services.CHARGING}.plugStatus.value.plugLockState")
 
     @property
     def charging_cable_connected(self) -> bool:
         """Return plug connected state."""
-        response = find_path(
-            self.attrs, f"{Services.CHARGING}.plugStatus.value.plugConnectionState"
-        )
+        response = find_path(self.attrs, f"{Services.CHARGING}.plugStatus.value.plugConnectionState")
         return response == "connected"
 
     @property
     def charging_cable_connected_last_updated(self) -> datetime:
         """Return plug connected state last updated."""
-        return find_path(
-            self.attrs, f"{Services.CHARGING}.plugStatus.value.carCapturedTimestamp"
-        )
+        return find_path(self.attrs, f"{Services.CHARGING}.plugStatus.value.carCapturedTimestamp")
 
     @property
     def is_charging_cable_connected_supported(self) -> bool:
         """Return true if supported."""
-        return is_valid_path(
-            self.attrs, f"{Services.CHARGING}.plugStatus.value.plugConnectionState"
-        )
+        return is_valid_path(self.attrs, f"{Services.CHARGING}.plugStatus.value.plugConnectionState")
 
     @property
     def charging_time_left(self) -> int:
         """Return minutes to charging complete."""
-        if is_valid_path(
-            self.attrs,
-            f"{Services.CHARGING}.chargingStatus.value.remainingChargingTimeToComplete_min",
-        ):
+        if is_valid_path(self.attrs, f"{Services.CHARGING}.chargingStatus.value.remainingChargingTimeToComplete_min"):
             return find_path(
-                self.attrs,
-                f"{Services.CHARGING}.chargingStatus.value.remainingChargingTimeToComplete_min",
+                self.attrs, f"{Services.CHARGING}.chargingStatus.value.remainingChargingTimeToComplete_min"
             )
         return None
 
     @property
     def charging_time_left_last_updated(self) -> datetime:
         """Return minutes to charging complete last updated."""
-        return find_path(
-            self.attrs, f"{Services.CHARGING}.chargingStatus.value.carCapturedTimestamp"
-        )
+        return find_path(self.attrs, f"{Services.CHARGING}.chargingStatus.value.carCapturedTimestamp")
 
     @property
     def is_charging_time_left_supported(self) -> bool:
         """Return true if charging is supported."""
-        return is_valid_path(
-            self.attrs, f"{Services.CHARGING}.chargingStatus.value.chargingState"
-        )
+        return is_valid_path(self.attrs, f"{Services.CHARGING}.chargingStatus.value.chargingState")
 
     @property
     def external_power(self) -> bool:
         """Return true if external power is connected."""
-        check = find_path(
-            self.attrs, f"{Services.CHARGING}.plugStatus.value.externalPower"
-        )
+        check = find_path(self.attrs, f"{Services.CHARGING}.plugStatus.value.externalPower")
         return check in ["stationConnected", "available", "ready"]
 
     @property
     def external_power_last_updated(self) -> datetime:
         """Return external power last updated."""
-        return find_path(
-            self.attrs, f"{Services.CHARGING}.plugStatus.value.carCapturedTimestamp"
-        )
+        return find_path(self.attrs, f"{Services.CHARGING}.plugStatus.value.carCapturedTimestamp")
 
     @property
     def is_external_power_supported(self) -> bool:
         """External power supported."""
-        return is_valid_path(
-            self.attrs, f"{Services.CHARGING}.plugStatus.value.externalPower"
-        )
+        return is_valid_path(self.attrs, f"{Services.CHARGING}.plugStatus.value.externalPower")
 
     @property
     def reduced_ac_charging(self) -> bool:
@@ -1465,89 +1161,64 @@ class Vehicle:
     @property
     def auto_release_ac_connector_state(self) -> str:
         """Return auto release ac connector state value."""
-        return find_path(
-            self.attrs,
-            f"{Services.CHARGING}.chargingSettings.value.autoUnlockPlugWhenChargedAC",
-        )
+        return find_path(self.attrs, f"{Services.CHARGING}.chargingSettings.value.autoUnlockPlugWhenChargedAC")
 
     @property
     def auto_release_ac_connector(self) -> bool:
         """Return auto release ac connector state."""
         return (
-            find_path(
-                self.attrs,
-                f"{Services.CHARGING}.chargingSettings.value.autoUnlockPlugWhenChargedAC",
-            )
+            find_path(self.attrs, f"{Services.CHARGING}.chargingSettings.value.autoUnlockPlugWhenChargedAC")
             == "permanent"
         )
 
     @property
     def auto_release_ac_connector_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return find_path(
-            self.attrs,
-            f"{Services.CHARGING}.chargingSettings.value.carCapturedTimestamp",
-        )
+        return find_path(self.attrs, f"{Services.CHARGING}.chargingSettings.value.carCapturedTimestamp")
 
     @property
     def is_auto_release_ac_connector_supported(self) -> bool:
         """Return true if auto release ac connector is supported."""
-        return is_valid_path(
-            self.attrs,
-            f"{Services.CHARGING}.chargingSettings.value.autoUnlockPlugWhenChargedAC",
-        )
+        return is_valid_path(self.attrs, f"{Services.CHARGING}.chargingSettings.value.autoUnlockPlugWhenChargedAC")
 
     @property
     def battery_care_mode(self) -> bool:
         """Return battery care mode state."""
         return (
-            find_path(
-                self.attrs,
-                f"{Services.BATTERY_CHARGING_CARE}.chargingCareSettings.value.batteryCareMode",
-            )
+            find_path(self.attrs, f"{Services.BATTERY_CHARGING_CARE}.chargingCareSettings.value.batteryCareMode")
             == "activated"
         )
 
     @property
     def battery_care_mode_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return datetime.now(UTC)
+        return datetime.now(timezone.utc)
 
     @property
     def is_battery_care_mode_supported(self) -> bool:
         """Return true if battery care mode is supported."""
-        return is_valid_path(
-            self.attrs,
-            f"{Services.BATTERY_CHARGING_CARE}.chargingCareSettings.value.batteryCareMode",
-        )
+        return is_valid_path(self.attrs, f"{Services.BATTERY_CHARGING_CARE}.chargingCareSettings.value.batteryCareMode")
 
     @property
     def optimised_battery_use(self) -> bool:
         """Return optimised battery use state."""
         return (
-            find_path(
-                self.attrs,
-                f"{Services.BATTERY_SUPPORT}.batterySupportStatus.value.batterySupport",
-            )
-            == "enabled"
+            find_path(self.attrs, f"{Services.BATTERY_SUPPORT}.batterySupportStatus.value.batterySupport") == "enabled"
         )
 
     @property
     def optimised_battery_use_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return datetime.now(UTC)
+        return datetime.now(timezone.utc)
 
     @property
     def is_optimised_battery_use_supported(self) -> bool:
         """Return true if optimised battery use is supported."""
-        return is_valid_path(
-            self.attrs,
-            f"{Services.BATTERY_SUPPORT}.batterySupportStatus.value.batterySupport",
-        )
+        return is_valid_path(self.attrs, f"{Services.BATTERY_SUPPORT}.batterySupportStatus.value.batterySupport")
 
     @property
     def energy_flow(self):
-        # TODO untouched # pylint: disable=fixme
+        # TODO untouched
         """Return true if energy is flowing through charging port."""
         check = (
             self.attrs.get("charger", {})
@@ -1560,7 +1231,7 @@ class Vehicle:
 
     @property
     def energy_flow_last_updated(self) -> datetime:
-        # TODO untouched # pylint: disable=fixme
+        # TODO untouched
         """Return energy flow last updated."""
         return (
             self.attrs.get("charger", {})
@@ -1572,14 +1243,9 @@ class Vehicle:
 
     @property
     def is_energy_flow_supported(self) -> bool:
-        # TODO untouched # pylint: disable=fixme
+        # TODO untouched
         """Energy flow supported."""
-        return (
-            self.attrs.get("charger", {})
-            .get("status", {})
-            .get("chargingStatusData", {})
-            .get("energyFlow", False)
-        )
+        return self.attrs.get("charger", {}).get("status", {}).get("chargingStatusData", {}).get("energyFlow", False)
 
     # Vehicle location states
     @property
@@ -1592,11 +1258,9 @@ class Vehicle:
             else:
                 lat = float(find_path(self.attrs, "parkingposition.lat"))
                 lng = float(find_path(self.attrs, "parkingposition.lon"))
-                parking_time = find_path(
-                    self.attrs, "parkingposition.carCapturedTimestamp"
-                )
+                parking_time = find_path(self.attrs, "parkingposition.carCapturedTimestamp")
                 output = {"lat": lat, "lng": lng, "timestamp": parking_time}
-        except Exception:  # pylint: disable=broad-exception-caught
+        except Exception:
             output = {
                 "lat": "?",
                 "lng": "?",
@@ -1606,16 +1270,12 @@ class Vehicle:
     @property
     def position_last_updated(self) -> datetime:
         """Return  position last updated."""
-        return self.attrs.get("parkingposition", {}).get(
-            "carCapturedTimestamp", "Unknown"
-        )
+        return self.attrs.get("parkingposition", {}).get("carCapturedTimestamp", "Unknown")
 
     @property
     def is_position_supported(self) -> bool:
         """Return true if position is available."""
-        return is_valid_path(
-            self.attrs, "parkingposition.carCapturedTimestamp"
-        ) or self.attrs.get("isMoving", False)
+        return is_valid_path(self.attrs, "parkingposition.carCapturedTimestamp") or self.attrs.get("isMoving", False)
 
     @property
     def vehicle_moving(self) -> bool:
@@ -1653,64 +1313,43 @@ class Vehicle:
     # Vehicle fuel level and range
     @property
     def electric_range(self) -> int:
-        """Return electric range.
+        """
+        Return electric range.
 
         :return:
         """
-        if is_valid_path(
-            self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.electricRange"
-        ):
-            return find_path(
-                self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.electricRange"
-            )
-        return find_path(
-            self.attrs,
-            f"{Services.FUEL_STATUS}.rangeStatus.value.primaryEngine.remainingRange_km",
-        )
+        if is_valid_path(self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.electricRange"):
+            return find_path(self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.electricRange")
+        return find_path(self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.primaryEngine.remainingRange_km")
 
     @property
     def electric_range_last_updated(self) -> datetime:
         """Return electric range last updated."""
-        if is_valid_path(
-            self.attrs,
-            f"{Services.MEASUREMENTS}.rangeStatus.value.carCapturedTimestamp",
-        ):
-            return find_path(
-                self.attrs,
-                f"{Services.MEASUREMENTS}.rangeStatus.value.carCapturedTimestamp",
-            )
-        return find_path(
-            self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carCapturedTimestamp"
-        )
+        if is_valid_path(self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.carCapturedTimestamp"):
+            return find_path(self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.carCapturedTimestamp")
+        return find_path(self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carCapturedTimestamp")
 
     @property
     def is_electric_range_supported(self) -> bool:
-        """Return true if electric range is supported.
+        """
+        Return true if electric range is supported.
 
         :return:
         """
-        return is_valid_path(
-            self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.electricRange"
-        ) or (
+        return is_valid_path(self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.electricRange") or (
             self.is_car_type_electric
-            and is_valid_path(
-                self.attrs,
-                f"{Services.FUEL_STATUS}.rangeStatus.value.primaryEngine.remainingRange_km",
-            )
+            and is_valid_path(self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.primaryEngine.remainingRange_km")
         )
 
     @property
     def combustion_range(self) -> int:
-        """Return combustion engine range.
+        """
+        Return combustion engine range.
 
         :return:
         """
         DIESEL_RANGE = f"{Services.MEASUREMENTS}.rangeStatus.value.dieselRange"
         GASOLINE_RANGE = f"{Services.MEASUREMENTS}.rangeStatus.value.gasolineRange"
-        CNG_RANGE = f"{Services.MEASUREMENTS}.rangeStatus.value.cngRange"
-        TOTAL_RANGE = f"{Services.MEASUREMENTS}.rangeStatus.value.totalRange_km"
-        if is_valid_path(self.attrs, CNG_RANGE):
-            return find_path(self.attrs, TOTAL_RANGE)
         if is_valid_path(self.attrs, DIESEL_RANGE):
             return find_path(self.attrs, DIESEL_RANGE)
         if is_valid_path(self.attrs, GASOLINE_RANGE):
@@ -1720,179 +1359,83 @@ class Vehicle:
     @property
     def combustion_range_last_updated(self) -> datetime | None:
         """Return combustion engine range last updated."""
-        return find_path(
-            self.attrs,
-            f"{Services.MEASUREMENTS}.rangeStatus.value.carCapturedTimestamp",
-        )
+        return find_path(self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.carCapturedTimestamp")
 
     @property
     def is_combustion_range_supported(self) -> bool:
-        """Return true if combustion range is supported, i.e. false for EVs.
-
-        :return:
         """
-        return (
-            is_valid_path(
-                self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.dieselRange"
-            )
-            or is_valid_path(
-                self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.gasolineRange"
-            )
-            or is_valid_path(
-                self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.cngRange"
-            )
-        )
-
-    @property
-    def fuel_range(self) -> int:
-        """Return fuel engine range.
+        Return true if combustion range is supported, i.e. false for EVs.
 
         :return:
         """
-        DIESEL_RANGE = f"{Services.MEASUREMENTS}.rangeStatus.value.dieselRange"
-        GASOLINE_RANGE = f"{Services.MEASUREMENTS}.rangeStatus.value.gasolineRange"
-        if is_valid_path(self.attrs, DIESEL_RANGE):
-            return find_path(self.attrs, DIESEL_RANGE)
-        if is_valid_path(self.attrs, GASOLINE_RANGE):
-            return find_path(self.attrs, GASOLINE_RANGE)
-        return -1
-
-    @property
-    def fuel_range_last_updated(self) -> datetime | None:
-        """Return fuel engine range last updated."""
-        return find_path(
-            self.attrs,
-            f"{Services.MEASUREMENTS}.rangeStatus.value.carCapturedTimestamp",
-        )
-
-    @property
-    def is_fuel_range_supported(self) -> bool:
-        """Return true if fuel range is supported, i.e. false for EVs.
-
-        :return:
-        """
-        return is_valid_path(
-            self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.dieselRange"
-        ) or is_valid_path(
+        return is_valid_path(self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.dieselRange") or is_valid_path(
             self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.gasolineRange"
         )
 
-    @property
-    def gas_range(self) -> int:
-        """Return gas engine range.
-
-        :return:
-        """
-        CNG_RANGE = f"{Services.MEASUREMENTS}.rangeStatus.value.cngRange"
-        if is_valid_path(self.attrs, CNG_RANGE):
-            return find_path(self.attrs, CNG_RANGE)
-        return -1
-
-    @property
-    def gas_range_last_updated(self) -> datetime | None:
-        """Return gas engine range last updated."""
-        return find_path(
-            self.attrs,
-            f"{Services.MEASUREMENTS}.rangeStatus.value.carCapturedTimestamp",
-        )
-
-    @property
-    def is_gas_range_supported(self) -> bool:
-        """Return true if gas range is supported, i.e. false for EVs.
-
-        :return:
-        """
-        return is_valid_path(
-            self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.cngRange"
-        )
-
     @property
     def combined_range(self) -> int:
-        """Return combined range.
+        """
+        Return combined range.
 
         :return:
         """
-        return find_path(
-            self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.totalRange_km"
-        )
+        return find_path(self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.totalRange_km")
 
     @property
     def combined_range_last_updated(self) -> datetime | None:
         """Return combined range last updated."""
-        return find_path(
-            self.attrs,
-            f"{Services.MEASUREMENTS}.rangeStatus.value.carCapturedTimestamp",
-        )
+        return find_path(self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.carCapturedTimestamp")
 
     @property
     def is_combined_range_supported(self) -> bool:
-        """Return true if combined range is supported.
+        """
+        Return true if combined range is supported.
 
         :return:
         """
-        if is_valid_path(
-            self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.totalRange_km"
-        ):
-            return (
-                self.is_electric_range_supported and self.is_combustion_range_supported
-            )
+        if is_valid_path(self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.totalRange_km"):
+            return self.is_electric_range_supported and self.is_combustion_range_supported
         return False
 
     @property
     def battery_cruising_range(self) -> int:
-        """Return battery cruising range.
+        """
+        Return battery cruising range.
 
         :return:
         """
-        return find_path(
-            self.attrs,
-            f"{Services.CHARGING}.batteryStatus.value.cruisingRangeElectric_km",
-        )
+        return find_path(self.attrs, f"{Services.CHARGING}.batteryStatus.value.cruisingRangeElectric_km")
 
     @property
     def battery_cruising_range_last_updated(self) -> datetime | None:
         """Return battery cruising range last updated."""
-        return find_path(
-            self.attrs, f"{Services.CHARGING}.batteryStatus.value.carCapturedTimestamp"
-        )
+        return find_path(self.attrs, f"{Services.CHARGING}.batteryStatus.value.carCapturedTimestamp")
 
     @property
     def is_battery_cruising_range_supported(self) -> bool:
-        """Return true if battery cruising range is supported.
+        """
+        Return true if battery cruising range is supported.
 
         :return:
         """
-        return is_valid_path(
-            self.attrs,
-            f"{Services.CHARGING}.batteryStatus.value.cruisingRangeElectric_km",
-        )
+        return is_valid_path(self.attrs, f"{Services.CHARGING}.batteryStatus.value.cruisingRangeElectric_km")
 
     @property
     def fuel_level(self) -> int:
-        """Return fuel level.
+        """
+        Return fuel level.
 
         :return:
         """
         fuel_level_pct = ""
-        if (
-            is_valid_path(
-                self.attrs,
-                f"{Services.FUEL_STATUS}.rangeStatus.value.primaryEngine.currentFuelLevel_pct",
-            )
-            and not self.is_primary_drive_gas()
-        ):
+        if is_valid_path(self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.primaryEngine.currentFuelLevel_pct"):
             fuel_level_pct = find_path(
-                self.attrs,
-                f"{Services.FUEL_STATUS}.rangeStatus.value.primaryEngine.currentFuelLevel_pct",
+                self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.primaryEngine.currentFuelLevel_pct"
             )
 
-        if is_valid_path(
-            self.attrs,
-            f"{Services.MEASUREMENTS}.fuelLevelStatus.value.currentFuelLevel_pct",
-        ):
+        if is_valid_path(self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.currentFuelLevel_pct"):
             fuel_level_pct = find_path(
-                self.attrs,
-                f"{Services.MEASUREMENTS}.fuelLevelStatus.value.currentFuelLevel_pct",
+                self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.currentFuelLevel_pct"
             )
         return fuel_level_pct
 
@@ -1900,162 +1443,58 @@ class Vehicle:
     def fuel_level_last_updated(self) -> datetime:
         """Return fuel level last updated."""
         fuel_level_lastupdated = ""
-        if is_valid_path(
-            self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carCapturedTimestamp"
-        ):
+        if is_valid_path(self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carCapturedTimestamp"):
             fuel_level_lastupdated = find_path(
-                self.attrs,
-                f"{Services.FUEL_STATUS}.rangeStatus.value.carCapturedTimestamp",
+                self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carCapturedTimestamp"
             )
 
-        if is_valid_path(
-            self.attrs,
-            f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carCapturedTimestamp",
-        ):
+        if is_valid_path(self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carCapturedTimestamp"):
             fuel_level_lastupdated = find_path(
-                self.attrs,
-                f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carCapturedTimestamp",
+                self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carCapturedTimestamp"
             )
         return fuel_level_lastupdated
 
     @property
     def is_fuel_level_supported(self) -> bool:
-        """Return true if fuel level reporting is supported.
-
-        :return:
         """
-        return (
-            is_valid_path(
-                self.attrs,
-                f"{Services.FUEL_STATUS}.rangeStatus.value.primaryEngine.currentFuelLevel_pct",
-            )
-            and not self.is_primary_drive_gas()
-        ) or is_valid_path(
-            self.attrs,
-            f"{Services.MEASUREMENTS}.fuelLevelStatus.value.currentFuelLevel_pct",
-        )
-
-    @property
-    def gas_level(self) -> int:
-        """Return gas level.
-
-        :return:
-        """
-        gas_level_pct = ""
-        if (
-            is_valid_path(
-                self.attrs,
-                f"{Services.FUEL_STATUS}.rangeStatus.value.primaryEngine.currentFuelLevel_pct",
-            )
-            and self.is_primary_drive_gas()
-        ):
-            gas_level_pct = find_path(
-                self.attrs,
-                f"{Services.FUEL_STATUS}.rangeStatus.value.primaryEngine.currentFuelLevel_pct",
-            )
-
-        if is_valid_path(
-            self.attrs,
-            f"{Services.MEASUREMENTS}.fuelLevelStatus.value.currentCngLevel_pct",
-        ):
-            gas_level_pct = find_path(
-                self.attrs,
-                f"{Services.MEASUREMENTS}.fuelLevelStatus.value.currentCngLevel_pct",
-            )
-        return gas_level_pct
-
-    @property
-    def gas_level_last_updated(self) -> datetime:
-        """Return gas level last updated."""
-        gas_level_lastupdated = ""
-        if (
-            is_valid_path(
-                self.attrs,
-                f"{Services.FUEL_STATUS}.rangeStatus.value.carCapturedTimestamp",
-            )
-            and self.is_primary_drive_gas()
-        ):
-            gas_level_lastupdated = find_path(
-                self.attrs,
-                f"{Services.FUEL_STATUS}.rangeStatus.value.carCapturedTimestamp",
-            )
-
-        if is_valid_path(
-            self.attrs,
-            f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carCapturedTimestamp",
-        ):
-            gas_level_lastupdated = find_path(
-                self.attrs,
-                f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carCapturedTimestamp",
-            )
-        return gas_level_lastupdated
-
-    @property
-    def is_gas_level_supported(self) -> bool:
-        """Return true if gas level reporting is supported.
+        Return true if fuel level reporting is supported.
 
         :return:
         """
-        return (
-            is_valid_path(
-                self.attrs,
-                f"{Services.FUEL_STATUS}.rangeStatus.value.primaryEngine.currentFuelLevel_pct",
-            )
-            and self.is_primary_drive_gas()
-        ) or is_valid_path(
-            self.attrs,
-            f"{Services.MEASUREMENTS}.fuelLevelStatus.value.currentCngLevel_pct",
-        )
+        return is_valid_path(
+            self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.currentFuelLevel_pct"
+        ) or is_valid_path(self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.primaryEngine.currentFuelLevel_pct")
 
     @property
     def car_type(self) -> str:
-        """Return car type.
+        """
+        Return car type.
 
         :return:
         """
-        if is_valid_path(
-            self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carType"
-        ):
-            return find_path(
-                self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carType"
-            ).capitalize()
-        if is_valid_path(
-            self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carType"
-        ):
-            return find_path(
-                self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carType"
-            ).capitalize()
+        if is_valid_path(self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carType"):
+            return find_path(self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carType").capitalize()
+        if is_valid_path(self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carType"):
+            return find_path(self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carType").capitalize()
         return "Unknown"
 
     @property
     def car_type_last_updated(self) -> datetime | None:
         """Return car type last updated."""
-        if is_valid_path(
-            self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carCapturedTimestamp"
-        ):
-            return find_path(
-                self.attrs,
-                f"{Services.FUEL_STATUS}.rangeStatus.value.carCapturedTimestamp",
-            )
-        if is_valid_path(
-            self.attrs,
-            f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carCapturedTimestamp",
-        ):
-            return find_path(
-                self.attrs,
-                f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carCapturedTimestamp",
-            )
+        if is_valid_path(self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carCapturedTimestamp"):
+            return find_path(self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carCapturedTimestamp")
+        if is_valid_path(self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carCapturedTimestamp"):
+            return find_path(self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carCapturedTimestamp")
         return None
 
     @property
     def is_car_type_supported(self) -> bool:
-        """Return true if car type is supported.
+        """
+        Return true if car type is supported.
 
         :return:
         """
-        return is_valid_path(
-            self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carType"
-        ) or is_valid_path(
+        return is_valid_path(self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carType") or is_valid_path(
             self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carType"
         )
 
@@ -2063,167 +1502,109 @@ class Vehicle:
     @property
     def climatisation_target_temperature(self) -> float | None:
         """Return the target temperature from climater."""
-        # TODO should we handle Fahrenheit?? # pylint: disable=fixme
-        return float(
-            find_path(
-                self.attrs,
-                f"{Services.CLIMATISATION}.climatisationSettings.value.targetTemperature_C",
-            )
-        )
+        # TODO should we handle Fahrenheit??
+        return float(find_path(self.attrs, f"{Services.CLIMATISATION}.climatisationSettings.value.targetTemperature_C"))
 
     @property
     def climatisation_target_temperature_last_updated(self) -> datetime:
         """Return the target temperature from climater last updated."""
-        return find_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationSettings.value.carCapturedTimestamp",
-        )
+        return find_path(self.attrs, f"{Services.CLIMATISATION}.climatisationSettings.value.carCapturedTimestamp")
 
     @property
     def is_climatisation_target_temperature_supported(self) -> bool:
         """Return true if climatisation target temperature is supported."""
-        return is_valid_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationSettings.value.targetTemperature_C",
-        )
+        return is_valid_path(self.attrs, f"{Services.CLIMATISATION}.climatisationSettings.value.targetTemperature_C")
 
     @property
     def climatisation_without_external_power(self):
         """Return state of climatisation from battery power."""
         return find_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationSettings.value.climatisationWithoutExternalPower",
+            self.attrs, f"{Services.CLIMATISATION}.climatisationSettings.value.climatisationWithoutExternalPower"
         )
 
     @property
     def climatisation_without_external_power_last_updated(self) -> datetime:
         """Return state of climatisation from battery power last updated."""
-        return find_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationSettings.value.carCapturedTimestamp",
-        )
+        return find_path(self.attrs, f"{Services.CLIMATISATION}.climatisationSettings.value.carCapturedTimestamp")
 
     @property
     def is_climatisation_without_external_power_supported(self) -> bool:
         """Return true if climatisation on battery power is supported."""
         return is_valid_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationSettings.value.climatisationWithoutExternalPower",
+            self.attrs, f"{Services.CLIMATISATION}.climatisationSettings.value.climatisationWithoutExternalPower"
         )
 
     @property
     def auxiliary_air_conditioning(self):
         """Return state of auxiliary air conditioning."""
-        return find_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationSettings.value.climatizationAtUnlock",
-        )
+        return find_path(self.attrs, f"{Services.CLIMATISATION}.climatisationSettings.value.climatizationAtUnlock")
 
     @property
     def auxiliary_air_conditioning_last_updated(self) -> datetime:
         """Return state of auxiliary air conditioning last updated."""
-        return find_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationSettings.value.carCapturedTimestamp",
-        )
+        return find_path(self.attrs, f"{Services.CLIMATISATION}.climatisationSettings.value.carCapturedTimestamp")
 
     @property
     def is_auxiliary_air_conditioning_supported(self) -> bool:
         """Return true if auxiliary air conditioning is supported."""
-        return is_valid_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationSettings.value.climatizationAtUnlock",
-        )
+        return is_valid_path(self.attrs, f"{Services.CLIMATISATION}.climatisationSettings.value.climatizationAtUnlock")
 
     @property
     def automatic_window_heating(self):
         """Return state of automatic window heating."""
-        return find_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationSettings.value.windowHeatingEnabled",
-        )
+        return find_path(self.attrs, f"{Services.CLIMATISATION}.climatisationSettings.value.windowHeatingEnabled")
 
     @property
     def automatic_window_heating_last_updated(self) -> datetime:
         """Return state of automatic window heating last updated."""
-        return find_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationSettings.value.carCapturedTimestamp",
-        )
+        return find_path(self.attrs, f"{Services.CLIMATISATION}.climatisationSettings.value.carCapturedTimestamp")
 
     @property
     def is_automatic_window_heating_supported(self) -> bool:
         """Return true if automatic window heating is supported."""
-        return is_valid_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationSettings.value.windowHeatingEnabled",
-        )
+        return is_valid_path(self.attrs, f"{Services.CLIMATISATION}.climatisationSettings.value.windowHeatingEnabled")
 
     @property
     def zone_front_left(self):
         """Return state of zone front left."""
-        return find_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationSettings.value.zoneFrontLeftEnabled",
-        )
+        return find_path(self.attrs, f"{Services.CLIMATISATION}.climatisationSettings.value.zoneFrontLeftEnabled")
 
     @property
     def zone_front_left_last_updated(self) -> datetime:
         """Return state of zone front left last updated."""
-        return find_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationSettings.value.carCapturedTimestamp",
-        )
+        return find_path(self.attrs, f"{Services.CLIMATISATION}.climatisationSettings.value.carCapturedTimestamp")
 
     @property
     def is_zone_front_left_supported(self) -> bool:
         """Return true if zone front left is supported."""
-        return is_valid_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationSettings.value.zoneFrontLeftEnabled",
-        )
+        return is_valid_path(self.attrs, f"{Services.CLIMATISATION}.climatisationSettings.value.zoneFrontLeftEnabled")
 
     @property
     def zone_front_right(self):
         """Return state of zone front left."""
-        return find_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationSettings.value.zoneFrontRightEnabled",
-        )
+        return find_path(self.attrs, f"{Services.CLIMATISATION}.climatisationSettings.value.zoneFrontRightEnabled")
 
     @property
     def zone_front_right_last_updated(self) -> datetime:
         """Return state of zone front left last updated."""
-        return find_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationSettings.value.carCapturedTimestamp",
-        )
+        return find_path(self.attrs, f"{Services.CLIMATISATION}.climatisationSettings.value.carCapturedTimestamp")
 
     @property
     def is_zone_front_right_supported(self) -> bool:
         """Return true if zone front left is supported."""
-        return is_valid_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationSettings.value.zoneFrontRightEnabled",
-        )
+        return is_valid_path(self.attrs, f"{Services.CLIMATISATION}.climatisationSettings.value.zoneFrontRightEnabled")
 
     # Climatisation, electric
     @property
     def electric_climatisation(self) -> bool:
         """Return status of climatisation."""
-        status = find_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationStatus.value.climatisationState",
-        )
+        status = find_path(self.attrs, f"{Services.CLIMATISATION}.climatisationStatus.value.climatisationState")
         return status in ["ventilation", "heating", "cooling", "on"]
 
     @property
     def electric_climatisation_last_updated(self) -> datetime:
         """Return status of climatisation last updated."""
-        return find_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationStatus.value.carCapturedTimestamp",
-        )
+        return find_path(self.attrs, f"{Services.CLIMATISATION}.climatisationStatus.value.carCapturedTimestamp")
 
     @property
     def is_electric_climatisation_supported(self) -> bool:
@@ -2242,45 +1623,32 @@ class Vehicle:
     def electric_remaining_climatisation_time(self) -> int:
         """Return remaining climatisation time for electric climatisation."""
         return find_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationStatus.value.remainingClimatisationTime_min",
+            self.attrs, f"{Services.CLIMATISATION}.climatisationStatus.value.remainingClimatisationTime_min"
         )
 
     @property
     def electric_remaining_climatisation_time_last_updated(self) -> bool:
         """Return status of electric climatisation remaining climatisation time last updated."""
-        return find_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationStatus.value.carCapturedTimestamp",
-        )
+        return find_path(self.attrs, f"{Services.CLIMATISATION}.climatisationStatus.value.carCapturedTimestamp")
 
     @property
     def is_electric_remaining_climatisation_time_supported(self) -> bool:
         """Return true if electric climatisation remaining climatisation time is supported."""
         return is_valid_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationStatus.value.remainingClimatisationTime_min",
+            self.attrs, f"{Services.CLIMATISATION}.climatisationStatus.value.remainingClimatisationTime_min"
         )
 
     @property
     def auxiliary_climatisation(self) -> bool:
         """Return status of auxiliary climatisation."""
         climatisation_state = None
-        if is_valid_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.auxiliaryHeatingStatus.value.climatisationState",
-        ):
+        if is_valid_path(self.attrs, f"{Services.CLIMATISATION}.auxiliaryHeatingStatus.value.climatisationState"):
             climatisation_state = find_path(
-                self.attrs,
-                f"{Services.CLIMATISATION}.auxiliaryHeatingStatus.value.climatisationState",
+                self.attrs, f"{Services.CLIMATISATION}.auxiliaryHeatingStatus.value.climatisationState"
             )
-        if is_valid_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationStatus.value.climatisationState",
-        ):
+        if is_valid_path(self.attrs, f"{Services.CLIMATISATION}.climatisationStatus.value.climatisationState"):
             climatisation_state = find_path(
-                self.attrs,
-                f"{Services.CLIMATISATION}.climatisationStatus.value.climatisationState",
+                self.attrs, f"{Services.CLIMATISATION}.climatisationStatus.value.climatisationState"
             )
         if climatisation_state in ["heating", "heatingAuxiliary", "on"]:
             return True
@@ -2289,115 +1657,80 @@ class Vehicle:
     @property
     def auxiliary_climatisation_last_updated(self) -> datetime:
         """Return status of auxiliary climatisation last updated."""
-        if is_valid_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.auxiliaryHeatingStatus.value.carCapturedTimestamp",
-        ):
-            return find_path(
-                self.attrs,
-                f"{Services.CLIMATISATION}.auxiliaryHeatingStatus.value.carCapturedTimestamp",
-            )
-        if is_valid_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationStatus.value.carCapturedTimestamp",
-        ):
-            return find_path(
-                self.attrs,
-                f"{Services.CLIMATISATION}.climatisationStatus.value.carCapturedTimestamp",
-            )
+        if is_valid_path(self.attrs, f"{Services.CLIMATISATION}.auxiliaryHeatingStatus.value.carCapturedTimestamp"):
+            return find_path(self.attrs, f"{Services.CLIMATISATION}.auxiliaryHeatingStatus.value.carCapturedTimestamp")
+        if is_valid_path(self.attrs, f"{Services.CLIMATISATION}.climatisationStatus.value.carCapturedTimestamp"):
+            return find_path(self.attrs, f"{Services.CLIMATISATION}.climatisationStatus.value.carCapturedTimestamp")
         return None
 
     @property
     def is_auxiliary_climatisation_supported(self) -> bool:
         """Return true if vehicle has auxiliary climatisation."""
-        if is_valid_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.auxiliaryHeatingStatus.value.climatisationState",
-        ):
+        if is_valid_path(self.attrs, f"{Services.CLIMATISATION}.auxiliaryHeatingStatus.value.climatisationState"):
             return True
-        if is_valid_path(
-            self.attrs, f"{Services.USER_CAPABILITIES}.capabilitiesStatus.value"
-        ):
-            capabilities = find_path(
-                self.attrs, f"{Services.USER_CAPABILITIES}.capabilitiesStatus.value"
-            )
+        if is_valid_path(self.attrs, f"{Services.USER_CAPABILITIES}.capabilitiesStatus.value"):
+            capabilities = find_path(self.attrs, f"{Services.USER_CAPABILITIES}.capabilitiesStatus.value")
             for capability in capabilities:
                 if capability.get("id", None) == "hybridCarAuxiliaryHeating":
                     if 1007 in capability.get("status", []):
                         return False
-                    return True
+                    else:
+                        return True
         return False
 
     @property
     def auxiliary_duration(self) -> int:
         """Return heating duration for auxiliary heater."""
         return find_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationSettings.value.auxiliaryHeatingSettings.duration_min",
+            self.attrs, f"{Services.CLIMATISATION}.climatisationSettings.value.auxiliaryHeatingSettings.duration_min"
         )
 
     @property
     def auxiliary_duration_last_updated(self) -> bool:
         """Return status of auxiliary heater last updated."""
-        return find_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationSettings.value.carCapturedTimestamp",
-        )
+        return find_path(self.attrs, f"{Services.CLIMATISATION}.climatisationSettings.value.carCapturedTimestamp")
 
     @property
     def is_auxiliary_duration_supported(self) -> bool:
         """Return true if auxiliary heater is supported."""
         return is_valid_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationSettings.value.auxiliaryHeatingSettings.duration_min",
+            self.attrs, f"{Services.CLIMATISATION}.climatisationSettings.value.auxiliaryHeatingSettings.duration_min"
         )
 
     @property
     def auxiliary_remaining_climatisation_time(self) -> int:
         """Return remaining climatisation time for auxiliary heater."""
         return find_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.auxiliaryHeatingStatus.value.remainingClimatisationTime_min",
+            self.attrs, f"{Services.CLIMATISATION}.auxiliaryHeatingStatus.value.remainingClimatisationTime_min"
         )
 
     @property
     def auxiliary_remaining_climatisation_time_last_updated(self) -> bool:
         """Return status of auxiliary heater remaining climatisation time last updated."""
-        return find_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.auxiliaryHeatingStatus.value.carCapturedTimestamp",
-        )
+        return find_path(self.attrs, f"{Services.CLIMATISATION}.auxiliaryHeatingStatus.value.carCapturedTimestamp")
 
     @property
     def is_auxiliary_remaining_climatisation_time_supported(self) -> bool:
         """Return true if auxiliary heater remaining climatisation time is supported."""
         return is_valid_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.auxiliaryHeatingStatus.value.remainingClimatisationTime_min",
+            self.attrs, f"{Services.CLIMATISATION}.auxiliaryHeatingStatus.value.remainingClimatisationTime_min"
         )
 
     @property
     def is_climatisation_supported(self) -> bool:
         """Return true if climatisation has State."""
-        return is_valid_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationStatus.value.climatisationState",
-        )
+        return is_valid_path(self.attrs, f"{Services.CLIMATISATION}.climatisationStatus.value.climatisationState")
 
     @property
     def is_climatisation_supported_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return find_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.climatisationStatus.value.carCapturedTimestamp",
-        )
+        return find_path(self.attrs, f"{Services.CLIMATISATION}.climatisationStatus.value.carCapturedTimestamp")
 
     @property
     def window_heater_front(self) -> bool:
         """Return status of front window heater."""
         window_heating_status = find_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.windowHeatingStatus.value.windowHeatingStatus",
+            self.attrs, f"{Services.CLIMATISATION}.windowHeatingStatus.value.windowHeatingStatus"
         )
         for window_heating_state in window_heating_status:
             if window_heating_state["windowLocation"] == "front":
@@ -2408,25 +1741,18 @@ class Vehicle:
     @property
     def window_heater_front_last_updated(self) -> datetime:
         """Return front window heater last updated."""
-        return find_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.windowHeatingStatus.value.carCapturedTimestamp",
-        )
+        return find_path(self.attrs, f"{Services.CLIMATISATION}.windowHeatingStatus.value.carCapturedTimestamp")
 
     @property
     def is_window_heater_front_supported(self) -> bool:
         """Return true if vehicle has heater."""
-        return is_valid_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.windowHeatingStatus.value.windowHeatingStatus",
-        )
+        return is_valid_path(self.attrs, f"{Services.CLIMATISATION}.windowHeatingStatus.value.windowHeatingStatus")
 
     @property
     def window_heater_back(self) -> bool:
         """Return status of rear window heater."""
         window_heating_status = find_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.windowHeatingStatus.value.windowHeatingStatus",
+            self.attrs, f"{Services.CLIMATISATION}.windowHeatingStatus.value.windowHeatingStatus"
         )
         for window_heating_state in window_heating_status:
             if window_heating_state["windowLocation"] == "rear":
@@ -2437,18 +1763,12 @@ class Vehicle:
     @property
     def window_heater_back_last_updated(self) -> datetime:
         """Return front window heater last updated."""
-        return find_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.windowHeatingStatus.value.carCapturedTimestamp",
-        )
+        return find_path(self.attrs, f"{Services.CLIMATISATION}.windowHeatingStatus.value.carCapturedTimestamp")
 
     @property
     def is_window_heater_back_supported(self) -> bool:
         """Return true if vehicle has heater."""
-        return is_valid_path(
-            self.attrs,
-            f"{Services.CLIMATISATION}.windowHeatingStatus.value.windowHeatingStatus",
-        )
+        return is_valid_path(self.attrs, f"{Services.CLIMATISATION}.windowHeatingStatus.value.windowHeatingStatus")
 
     @property
     def window_heater(self) -> bool:
@@ -2464,50 +1784,29 @@ class Vehicle:
     def is_window_heater_supported(self) -> bool:
         """Return true if vehicle has heater."""
         # ID models detection
-        if (
-            self._services.get(Services.PARAMETERS, {}).get(
-                "supportsStartWindowHeating", "false"
-            )
-            == "true"
-        ):
+        if self._services.get(Services.PARAMETERS, {}).get("supportsStartWindowHeating", "false") == "true":
             return True
         # "Legacy" models detection
-        parameters = self._services.get(Services.CLIMATISATION, {}).get(
-            "parameters", None
-        )
+        parameters = self._services.get(Services.CLIMATISATION, {}).get("parameters", None)
         if parameters:
             for parameter in parameters:
-                if (
-                    parameter["key"] == "supportsStartWindowHeating"
-                    and parameter["value"] == "true"
-                ):
+                if parameter["key"] == "supportsStartWindowHeating" and parameter["value"] == "true":
                     return True
         return False
 
     # Windows
     @property
     def windows_closed(self) -> bool:
-        """Return true if all supported windows are closed.
+        """
+        Return true if all supported windows are closed.
 
         :return:
         """
         return (
-            (
-                not self.is_window_closed_left_front_supported
-                or self.window_closed_left_front
-            )
-            and (
-                not self.is_window_closed_left_back_supported
-                or self.window_closed_left_back
-            )
-            and (
-                not self.is_window_closed_right_front_supported
-                or self.window_closed_right_front
-            )
-            and (
-                not self.is_window_closed_right_back_supported
-                or self.window_closed_right_back
-            )
+            (not self.is_window_closed_left_front_supported or self.window_closed_left_front)
+            and (not self.is_window_closed_left_back_supported or self.window_closed_left_back)
+            and (not self.is_window_closed_right_front_supported or self.window_closed_right_front)
+            and (not self.is_window_closed_right_back_supported or self.window_closed_right_back)
         )
 
     @property
@@ -2527,17 +1826,15 @@ class Vehicle:
 
     @property
     def window_closed_left_front(self) -> bool:
-        """Return left front window closed state.
+        """
+        Return left front window closed state.
 
         :return:
         """
         windows = find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.windows")
         for window in windows:
             if window["name"] == "frontLeft":
-                if not any(
-                    valid_status in window["status"]
-                    for valid_status in P.VALID_WINDOW_STATUS
-                ):
+                if not any(valid_status in window["status"] for valid_status in P.VALID_WINDOW_STATUS):
                     return None
                 return "closed" in window["status"]
         return False
@@ -2545,38 +1842,29 @@ class Vehicle:
     @property
     def window_closed_left_front_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return find_path(
-            self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp"
-        )
+        return find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp")
 
     @property
     def is_window_closed_left_front_supported(self) -> bool:
         """Return true if supported."""
         if is_valid_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.windows"):
-            windows = find_path(
-                self.attrs, f"{Services.ACCESS}.accessStatus.value.windows"
-            )
+            windows = find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.windows")
             for window in windows:
-                if (
-                    window["name"] == "frontLeft"
-                    and "unsupported" not in window["status"]
-                ):
+                if window["name"] == "frontLeft" and "unsupported" not in window["status"]:
                     return True
         return False
 
     @property
     def window_closed_right_front(self) -> bool:
-        """Return right front window closed state.
+        """
+        Return right front window closed state.
 
         :return:
         """
         windows = find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.windows")
         for window in windows:
             if window["name"] == "frontRight":
-                if not any(
-                    valid_status in window["status"]
-                    for valid_status in P.VALID_WINDOW_STATUS
-                ):
+                if not any(valid_status in window["status"] for valid_status in P.VALID_WINDOW_STATUS):
                     return None
                 return "closed" in window["status"]
         return False
@@ -2584,38 +1872,29 @@ class Vehicle:
     @property
     def window_closed_right_front_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return find_path(
-            self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp"
-        )
+        return find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp")
 
     @property
     def is_window_closed_right_front_supported(self) -> bool:
         """Return true if supported."""
         if is_valid_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.windows"):
-            windows = find_path(
-                self.attrs, f"{Services.ACCESS}.accessStatus.value.windows"
-            )
+            windows = find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.windows")
             for window in windows:
-                if (
-                    window["name"] == "frontRight"
-                    and "unsupported" not in window["status"]
-                ):
+                if window["name"] == "frontRight" and "unsupported" not in window["status"]:
                     return True
         return False
 
     @property
     def window_closed_left_back(self) -> bool:
-        """Return left back window closed state.
+        """
+        Return left back window closed state.
 
         :return:
         """
         windows = find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.windows")
         for window in windows:
             if window["name"] == "rearLeft":
-                if not any(
-                    valid_status in window["status"]
-                    for valid_status in P.VALID_WINDOW_STATUS
-                ):
+                if not any(valid_status in window["status"] for valid_status in P.VALID_WINDOW_STATUS):
                     return None
                 return "closed" in window["status"]
         return False
@@ -2623,38 +1902,29 @@ class Vehicle:
     @property
     def window_closed_left_back_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return find_path(
-            self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp"
-        )
+        return find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp")
 
     @property
     def is_window_closed_left_back_supported(self) -> bool:
         """Return true if supported."""
         if is_valid_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.windows"):
-            windows = find_path(
-                self.attrs, f"{Services.ACCESS}.accessStatus.value.windows"
-            )
+            windows = find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.windows")
             for window in windows:
-                if (
-                    window["name"] == "rearLeft"
-                    and "unsupported" not in window["status"]
-                ):
+                if window["name"] == "rearLeft" and "unsupported" not in window["status"]:
                     return True
         return False
 
     @property
     def window_closed_right_back(self) -> bool:
-        """Return right back window closed state.
+        """
+        Return right back window closed state.
 
         :return:
         """
         windows = find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.windows")
         for window in windows:
             if window["name"] == "rearRight":
-                if not any(
-                    valid_status in window["status"]
-                    for valid_status in P.VALID_WINDOW_STATUS
-                ):
+                if not any(valid_status in window["status"] for valid_status in P.VALID_WINDOW_STATUS):
                     return None
                 return "closed" in window["status"]
         return False
@@ -2662,38 +1932,29 @@ class Vehicle:
     @property
     def window_closed_right_back_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return find_path(
-            self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp"
-        )
+        return find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp")
 
     @property
     def is_window_closed_right_back_supported(self) -> bool:
         """Return true if supported."""
         if is_valid_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.windows"):
-            windows = find_path(
-                self.attrs, f"{Services.ACCESS}.accessStatus.value.windows"
-            )
+            windows = find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.windows")
             for window in windows:
-                if (
-                    window["name"] == "rearRight"
-                    and "unsupported" not in window["status"]
-                ):
+                if window["name"] == "rearRight" and "unsupported" not in window["status"]:
                     return True
         return False
 
     @property
     def sunroof_closed(self) -> bool:
-        """Return sunroof closed state.
+        """
+        Return sunroof closed state.
 
         :return:
         """
         windows = find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.windows")
         for window in windows:
             if window["name"] == "sunRoof":
-                if not any(
-                    valid_status in window["status"]
-                    for valid_status in P.VALID_WINDOW_STATUS
-                ):
+                if not any(valid_status in window["status"] for valid_status in P.VALID_WINDOW_STATUS):
                     return None
                 return "closed" in window["status"]
         return False
@@ -2701,38 +1962,29 @@ class Vehicle:
     @property
     def sunroof_closed_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return find_path(
-            self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp"
-        )
+        return find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp")
 
     @property
     def is_sunroof_closed_supported(self) -> bool:
         """Return true if supported."""
         if is_valid_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.windows"):
-            windows = find_path(
-                self.attrs, f"{Services.ACCESS}.accessStatus.value.windows"
-            )
+            windows = find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.windows")
             for window in windows:
-                if (
-                    window["name"] == "sunRoof"
-                    and "unsupported" not in window["status"]
-                ):
+                if window["name"] == "sunRoof" and "unsupported" not in window["status"]:
                     return True
         return False
 
     @property
     def sunroof_rear_closed(self) -> bool:
-        """Return sunroof rear closed state.
+        """
+        Return sunroof rear closed state.
 
         :return:
         """
         windows = find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.windows")
         for window in windows:
             if window["name"] == "sunRoofRear":
-                if not any(
-                    valid_status in window["status"]
-                    for valid_status in P.VALID_WINDOW_STATUS
-                ):
+                if not any(valid_status in window["status"] for valid_status in P.VALID_WINDOW_STATUS):
                     return None
                 return "closed" in window["status"]
         return False
@@ -2740,38 +1992,29 @@ class Vehicle:
     @property
     def sunroof_rear_closed_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return find_path(
-            self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp"
-        )
+        return find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp")
 
     @property
     def is_sunroof_rear_closed_supported(self) -> bool:
         """Return true if supported."""
         if is_valid_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.windows"):
-            windows = find_path(
-                self.attrs, f"{Services.ACCESS}.accessStatus.value.windows"
-            )
+            windows = find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.windows")
             for window in windows:
-                if (
-                    window["name"] == "sunRoofRear"
-                    and "unsupported" not in window["status"]
-                ):
+                if window["name"] == "sunRoofRear" and "unsupported" not in window["status"]:
                     return True
         return False
 
     @property
     def roof_cover_closed(self) -> bool:
-        """Return roof cover closed state.
+        """
+        Return roof cover closed state.
 
         :return:
         """
         windows = find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.windows")
         for window in windows:
             if window["name"] == "roofCover":
-                if not any(
-                    valid_status in window["status"]
-                    for valid_status in P.VALID_WINDOW_STATUS
-                ):
+                if not any(valid_status in window["status"] for valid_status in P.VALID_WINDOW_STATUS):
                     return None
                 return "closed" in window["status"]
         return False
@@ -2779,22 +2022,15 @@ class Vehicle:
     @property
     def roof_cover_closed_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return find_path(
-            self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp"
-        )
+        return find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp")
 
     @property
     def is_roof_cover_closed_supported(self) -> bool:
         """Return true if supported."""
         if is_valid_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.doors"):
-            windows = find_path(
-                self.attrs, f"{Services.ACCESS}.accessStatus.value.windows"
-            )
+            windows = find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.windows")
             for window in windows:
-                if (
-                    window["name"] == "roofCover"
-                    and "unsupported" not in window["status"]
-                ):
+                if window["name"] == "roofCover" and "unsupported" not in window["status"]:
                     return True
         return False
 
@@ -2806,60 +2042,51 @@ class Vehicle:
 
     @property
     def door_locked(self) -> bool:
-        """Return true if all doors are locked.
+        """
+        Return true if all doors are locked.
 
         :return:
         """
-        return (
-            find_path(
-                self.attrs, f"{Services.ACCESS}.accessStatus.value.doorLockStatus"
-            )
-            == "locked"
-        )
+        return find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.doorLockStatus") == "locked"
 
     @property
     def door_locked_last_updated(self) -> datetime:
         """Return door lock last updated."""
-        return find_path(
-            self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp"
-        )
+        return find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp")
 
     @property
     def door_locked_sensor_last_updated(self) -> datetime:
         """Return door lock last updated."""
-        return find_path(
-            self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp"
-        )
+        return find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp")
 
     @property
     def is_door_locked_supported(self) -> bool:
-        """Return true if supported.
+        """
+        Return true if supported.
 
         :return:
         """
         # First check that the service is actually enabled
         if not self._services.get(Services.ACCESS, {}).get("active", False):
             return False
-        return is_valid_path(
-            self.attrs, f"{Services.ACCESS}.accessStatus.value.doorLockStatus"
-        )
+        return is_valid_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.doorLockStatus")
 
     @property
     def is_door_locked_sensor_supported(self) -> bool:
-        """Return true if supported.
+        """
+        Return true if supported.
 
         :return:
         """
         # Use real lock if the service is actually enabled
         if self._services.get(Services.ACCESS, {}).get("active", False):
             return False
-        return is_valid_path(
-            self.attrs, f"{Services.ACCESS}.accessStatus.value.doorLockStatus"
-        )
+        return is_valid_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.doorLockStatus")
 
     @property
     def trunk_locked(self) -> bool:
-        """Return trunk locked state.
+        """
+        Return trunk locked state.
 
         :return:
         """
@@ -2872,13 +2099,12 @@ class Vehicle:
     @property
     def trunk_locked_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return find_path(
-            self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp"
-        )
+        return find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp")
 
     @property
     def is_trunk_locked_supported(self) -> bool:
-        """Return true if supported.
+        """
+        Return true if supported.
 
         :return:
         """
@@ -2893,7 +2119,8 @@ class Vehicle:
 
     @property
     def trunk_locked_sensor(self) -> bool:
-        """Return trunk locked state.
+        """
+        Return trunk locked state.
 
         :return:
         """
@@ -2906,13 +2133,12 @@ class Vehicle:
     @property
     def trunk_locked_sensor_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return find_path(
-            self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp"
-        )
+        return find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp")
 
     @property
     def is_trunk_locked_sensor_supported(self) -> bool:
-        """Return true if supported.
+        """
+        Return true if supported.
 
         :return:
         """
@@ -2928,17 +2154,15 @@ class Vehicle:
     # Doors, hood and trunk
     @property
     def hood_closed(self) -> bool:
-        """Return hood closed state.
+        """
+        Return hood closed state.
 
         :return:
         """
         doors = find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.doors")
         for door in doors:
             if door["name"] == "bonnet":
-                if not any(
-                    valid_status in door["status"]
-                    for valid_status in P.VALID_DOOR_STATUS
-                ):
+                if not any(valid_status in door["status"] for valid_status in P.VALID_DOOR_STATUS):
                     return None
                 return "closed" in door["status"]
         return False
@@ -2946,9 +2170,7 @@ class Vehicle:
     @property
     def hood_closed_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return find_path(
-            self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp"
-        )
+        return find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp")
 
     @property
     def is_hood_closed_supported(self) -> bool:
@@ -2962,17 +2184,15 @@ class Vehicle:
 
     @property
     def door_closed_left_front(self) -> bool:
-        """Return left front door closed state.
+        """
+        Return left front door closed state.
 
         :return:
         """
         doors = find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.doors")
         for door in doors:
             if door["name"] == "frontLeft":
-                if not any(
-                    valid_status in door["status"]
-                    for valid_status in P.VALID_DOOR_STATUS
-                ):
+                if not any(valid_status in door["status"] for valid_status in P.VALID_DOOR_STATUS):
                     return None
                 return "closed" in door["status"]
         return False
@@ -2980,9 +2200,7 @@ class Vehicle:
     @property
     def door_closed_left_front_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return find_path(
-            self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp"
-        )
+        return find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp")
 
     @property
     def is_door_closed_left_front_supported(self) -> bool:
@@ -2996,17 +2214,15 @@ class Vehicle:
 
     @property
     def door_closed_right_front(self) -> bool:
-        """Return right front door closed state.
+        """
+        Return right front door closed state.
 
         :return:
         """
         doors = find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.doors")
         for door in doors:
             if door["name"] == "frontRight":
-                if not any(
-                    valid_status in door["status"]
-                    for valid_status in P.VALID_DOOR_STATUS
-                ):
+                if not any(valid_status in door["status"] for valid_status in P.VALID_DOOR_STATUS):
                     return None
                 return "closed" in door["status"]
         return False
@@ -3014,9 +2230,7 @@ class Vehicle:
     @property
     def door_closed_right_front_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return find_path(
-            self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp"
-        )
+        return find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp")
 
     @property
     def is_door_closed_right_front_supported(self) -> bool:
@@ -3030,17 +2244,15 @@ class Vehicle:
 
     @property
     def door_closed_left_back(self) -> bool:
-        """Return left back door closed state.
+        """
+        Return left back door closed state.
 
         :return:
         """
         doors = find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.doors")
         for door in doors:
             if door["name"] == "rearLeft":
-                if not any(
-                    valid_status in door["status"]
-                    for valid_status in P.VALID_DOOR_STATUS
-                ):
+                if not any(valid_status in door["status"] for valid_status in P.VALID_DOOR_STATUS):
                     return None
                 return "closed" in door["status"]
         return False
@@ -3048,9 +2260,7 @@ class Vehicle:
     @property
     def door_closed_left_back_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return find_path(
-            self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp"
-        )
+        return find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp")
 
     @property
     def is_door_closed_left_back_supported(self) -> bool:
@@ -3064,17 +2274,15 @@ class Vehicle:
 
     @property
     def door_closed_right_back(self) -> bool:
-        """Return right back door closed state.
+        """
+        Return right back door closed state.
 
         :return:
         """
         doors = find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.doors")
         for door in doors:
             if door["name"] == "rearRight":
-                if not any(
-                    valid_status in door["status"]
-                    for valid_status in P.VALID_DOOR_STATUS
-                ):
+                if not any(valid_status in door["status"] for valid_status in P.VALID_DOOR_STATUS):
                     return None
                 return "closed" in door["status"]
         return False
@@ -3082,9 +2290,7 @@ class Vehicle:
     @property
     def door_closed_right_back_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return find_path(
-            self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp"
-        )
+        return find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp")
 
     @property
     def is_door_closed_right_back_supported(self) -> bool:
@@ -3098,7 +2304,8 @@ class Vehicle:
 
     @property
     def trunk_closed(self) -> bool:
-        """Return trunk closed state.
+        """
+        Return trunk closed state.
 
         :return:
         """
@@ -3111,9 +2318,7 @@ class Vehicle:
     @property
     def trunk_closed_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return find_path(
-            self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp"
-        )
+        return find_path(self.attrs, f"{Services.ACCESS}.accessStatus.value.carCapturedTimestamp")
 
     @property
     def is_trunk_closed_supported(self) -> bool:
@@ -3145,28 +2350,20 @@ class Vehicle:
     def departure_timer1_last_updated(self) -> datetime:
         """Return last updated timestamp."""
         if is_valid_path(
-            self.attrs,
-            f"{Services.DEPARTURE_PROFILES}.departureProfilesStatus.value.carCapturedTimestamp",
+            self.attrs, f"{Services.DEPARTURE_PROFILES}.departureProfilesStatus.value.carCapturedTimestamp"
         ):
             return find_path(
-                self.attrs,
-                f"{Services.DEPARTURE_PROFILES}.departureProfilesStatus.value.carCapturedTimestamp",
+                self.attrs, f"{Services.DEPARTURE_PROFILES}.departureProfilesStatus.value.carCapturedTimestamp"
             )
         if is_valid_path(
-            self.attrs,
-            f"{Services.CLIMATISATION_TIMERS}.auxiliaryHeatingTimersStatus.value.carCapturedTimestamp",
+            self.attrs, f"{Services.CLIMATISATION_TIMERS}.auxiliaryHeatingTimersStatus.value.carCapturedTimestamp"
         ):
             return find_path(
-                self.attrs,
-                f"{Services.CLIMATISATION_TIMERS}.auxiliaryHeatingTimersStatus.value.carCapturedTimestamp",
+                self.attrs, f"{Services.CLIMATISATION_TIMERS}.auxiliaryHeatingTimersStatus.value.carCapturedTimestamp"
             )
-        if is_valid_path(
-            self.attrs,
-            f"{Services.DEPARTURE_TIMERS}.departureTimersStatus.value.carCapturedTimestamp",
-        ):
+        if is_valid_path(self.attrs, f"{Services.DEPARTURE_TIMERS}.departureTimersStatus.value.carCapturedTimestamp"):
             return find_path(
-                self.attrs,
-                f"{Services.DEPARTURE_TIMERS}.departureTimersStatus.value.carCapturedTimestamp",
+                self.attrs, f"{Services.DEPARTURE_TIMERS}.departureTimersStatus.value.carCapturedTimestamp"
             )
         return None
 
@@ -3213,61 +2410,40 @@ class Vehicle:
         if timer.get("singleTimer", None):
             timer_type = "single"
             if timer.get("singleTimer", None).get("startDateTime", None):
-                start_date_time = timer.get("singleTimer", None).get(
-                    "startDateTime", None
-                )
+                start_date_time = timer.get("singleTimer", None).get("startDateTime", None)
                 start_time = (
-                    start_date_time.replace(tzinfo=UTC)
-                    .astimezone(tz=None)
-                    .strftime("%Y-%m-%dT%H:%M:%S")
+                    start_date_time.replace(tzinfo=timezone.utc).astimezone(tz=None).strftime("%Y-%m-%dT%H:%M:%S")
                 )
             if timer.get("singleTimer", None).get("startDateTimeLocal", None):
-                start_date_time = timer.get("singleTimer", None).get(
-                    "startDateTimeLocal", None
-                )
-                if isinstance(start_date_time, str):
-                    start_date_time = datetime.strptime(
-                        start_date_time, "%Y-%m-%dT%H:%M:%S"
-                    )
+                start_date_time = timer.get("singleTimer", None).get("startDateTimeLocal", None)
+                if type(start_date_time) is str:
+                    start_date_time = datetime.strptime(start_date_time, "%Y-%m-%dT%H:%M:%S")
                 start_time = start_date_time
             if timer.get("singleTimer", None).get("departureDateTimeLocal", None):
-                start_date_time = timer.get("singleTimer", None).get(
-                    "departureDateTimeLocal", None
-                )
-                if isinstance(start_date_time, str):
-                    start_date_time = datetime.strptime(
-                        start_date_time, "%Y-%m-%dT%H:%M:%S"
-                    )
+                start_date_time = timer.get("singleTimer", None).get("departureDateTimeLocal", None)
+                if type(start_date_time) is str:
+                    start_date_time = datetime.strptime(start_date_time, "%Y-%m-%dT%H:%M:%S")
                 start_time = start_date_time
         elif timer.get("recurringTimer", None):
             timer_type = "recurring"
             if timer.get("recurringTimer", None).get("startTime", None):
-                start_date_time = timer.get("recurringTimer", None).get(
-                    "startTime", None
-                )
+                start_date_time = timer.get("recurringTimer", None).get("startTime", None)
                 start_time = (
                     datetime.strptime(start_date_time, "%H:%M")
-                    .replace(tzinfo=UTC)
+                    .replace(tzinfo=timezone.utc)
                     .astimezone(tz=None)
                     .strftime("%H:%M")
                 )
             if timer.get("recurringTimer", None).get("startTimeLocal", None):
-                start_date_time = timer.get("recurringTimer", None).get(
-                    "startTimeLocal", None
-                )
-                start_time = datetime.strptime(start_date_time, "%H:%M").strftime(
-                    "%H:%M"
-                )
+                start_date_time = timer.get("recurringTimer", None).get("startTimeLocal", None)
+                start_time = datetime.strptime(start_date_time, "%H:%M").strftime("%H:%M")
             if timer.get("recurringTimer", None).get("departureTimeLocal", None):
-                start_date_time = timer.get("recurringTimer", None).get(
-                    "departureTimeLocal", None
-                )
-                start_time = datetime.strptime(start_date_time, "%H:%M").strftime(
-                    "%H:%M"
-                )
+                start_date_time = timer.get("recurringTimer", None).get("departureTimeLocal", None)
+                start_time = datetime.strptime(start_date_time, "%H:%M").strftime("%H:%M")
             recurring_days = timer.get("recurringTimer", None).get("recurringOn", None)
-            recurring_days = timer.get("recurringTimer", {}).get("recurringOn", {})
-            recurring_on = [day for day in recurring_days if recurring_days.get(day)]
+            for day in recurring_days:
+                if recurring_days.get(day) is True:
+                    recurring_on.append(day)
         data = {
             "timer_id": timer.get("id", None),
             "timer_type": timer_type,
@@ -3287,46 +2463,24 @@ class Vehicle:
             data["climatisation_enabled"] = timer.get("climatisation", False)
         if timer.get("preferredChargingTimes", None):
             preferred_charging_times = timer.get("preferredChargingTimes", None)[0]
-            data["preferred_charging_start_time"] = preferred_charging_times.get(
-                "startTimeLocal", None
-            )
-            data["preferred_charging_end_time"] = preferred_charging_times.get(
-                "endTimeLocal", None
-            )
+            data["preferred_charging_start_time"] = preferred_charging_times.get("startTimeLocal", None)
+            data["preferred_charging_end_time"] = preferred_charging_times.get("endTimeLocal", None)
         return data
 
     def departure_timer(self, timer_id: str | int):
         """Return departure timer."""
-        if is_valid_path(
-            self.attrs,
-            f"{Services.DEPARTURE_PROFILES}.departureProfilesStatus.value.timers",
-        ):
-            timers = find_path(
-                self.attrs,
-                f"{Services.DEPARTURE_PROFILES}.departureProfilesStatus.value.timers",
-            )
+        if is_valid_path(self.attrs, f"{Services.DEPARTURE_PROFILES}.departureProfilesStatus.value.timers"):
+            timers = find_path(self.attrs, f"{Services.DEPARTURE_PROFILES}.departureProfilesStatus.value.timers")
             for timer in timers:
                 if timer.get("id", 0) == timer_id:
                     return timer
-        if is_valid_path(
-            self.attrs,
-            f"{Services.CLIMATISATION_TIMERS}.auxiliaryHeatingTimersStatus.value.timers",
-        ):
-            timers = find_path(
-                self.attrs,
-                f"{Services.CLIMATISATION_TIMERS}.auxiliaryHeatingTimersStatus.value.timers",
-            )
+        if is_valid_path(self.attrs, f"{Services.CLIMATISATION_TIMERS}.auxiliaryHeatingTimersStatus.value.timers"):
+            timers = find_path(self.attrs, f"{Services.CLIMATISATION_TIMERS}.auxiliaryHeatingTimersStatus.value.timers")
             for timer in timers:
                 if timer.get("id", 0) == timer_id:
                     return timer
-        if is_valid_path(
-            self.attrs,
-            f"{Services.DEPARTURE_TIMERS}.departureTimersStatus.value.timers",
-        ):
-            timers = find_path(
-                self.attrs,
-                f"{Services.DEPARTURE_TIMERS}.departureTimersStatus.value.timers",
-            )
+        if is_valid_path(self.attrs, f"{Services.DEPARTURE_TIMERS}.departureTimersStatus.value.timers"):
+            timers = find_path(self.attrs, f"{Services.DEPARTURE_TIMERS}.departureTimersStatus.value.timers")
             for timer in timers:
                 if timer.get("id", 0) == timer_id:
                     return timer
@@ -3334,14 +2488,8 @@ class Vehicle:
 
     def departure_profile(self, profile_id: str | int):
         """Return departure profile."""
-        if is_valid_path(
-            self.attrs,
-            f"{Services.DEPARTURE_PROFILES}.departureProfilesStatus.value.profiles",
-        ):
-            profiles = find_path(
-                self.attrs,
-                f"{Services.DEPARTURE_PROFILES}.departureProfilesStatus.value.profiles",
-            )
+        if is_valid_path(self.attrs, f"{Services.DEPARTURE_PROFILES}.departureProfilesStatus.value.profiles"):
+            profiles = find_path(self.attrs, f"{Services.DEPARTURE_PROFILES}.departureProfilesStatus.value.profiles")
             for profile in profiles:
                 if profile.get("id", 0) == profile_id:
                     return profile
@@ -3362,8 +2510,7 @@ class Vehicle:
     def ac_departure_timer1_last_updated(self) -> datetime:
         """Return last updated timestamp."""
         return find_path(
-            self.attrs,
-            f"{Services.CLIMATISATION_TIMERS}.climatisationTimersStatus.value.carCapturedTimestamp",
+            self.attrs, f"{Services.CLIMATISATION_TIMERS}.climatisationTimersStatus.value.carCapturedTimestamp"
         )
 
     @property
@@ -3391,14 +2538,8 @@ class Vehicle:
 
     def ac_departure_timer(self, timer_id: str | int):
         """Return ac departure timer."""
-        if is_valid_path(
-            self.attrs,
-            f"{Services.CLIMATISATION_TIMERS}.climatisationTimersStatus.value.timers",
-        ):
-            timers = find_path(
-                self.attrs,
-                f"{Services.CLIMATISATION_TIMERS}.climatisationTimersStatus.value.timers",
-            )
+        if is_valid_path(self.attrs, f"{Services.CLIMATISATION_TIMERS}.climatisationTimersStatus.value.timers"):
+            timers = find_path(self.attrs, f"{Services.CLIMATISATION_TIMERS}.climatisationTimersStatus.value.timers")
             for timer in timers:
                 if timer.get("id", 0) == timer_id:
                     return timer
@@ -3413,33 +2554,33 @@ class Vehicle:
         if timer.get("singleTimer", None):
             timer_type = "single"
             start_date_time = timer.get("singleTimer", None).get("startDateTime", None)
-            start_time = (
-                start_date_time.replace(tzinfo=UTC)
-                .astimezone(tz=None)
-                .strftime("%Y-%m-%dT%H:%M:%S")
-            )
+            start_time = start_date_time.replace(tzinfo=timezone.utc).astimezone(tz=None).strftime("%Y-%m-%dT%H:%M:%S")
         elif timer.get("recurringTimer", None):
             timer_type = "recurring"
             start_date_time = timer.get("recurringTimer", None).get("startTime", None)
             start_time = (
                 datetime.strptime(start_date_time, "%H:%M")
-                .replace(tzinfo=UTC)
+                .replace(tzinfo=timezone.utc)
                 .astimezone(tz=None)
                 .strftime("%H:%M")
             )
             recurring_days = timer.get("recurringTimer", None).get("recurringOn", None)
-            recurring_on = [day for day in recurring_days if recurring_days.get(day)]
-        return {
+            for day in recurring_days:
+                if recurring_days.get(day) is True:
+                    recurring_on.append(day)
+        data = {
             "timer_id": timer.get("id", None),
             "timer_type": timer_type,
             "start_time": start_time,
             "recurring_on": recurring_on,
         }
+        return data
 
     # Trip data
     @property
     def trip_last_entry(self):
-        """Return last trip data entry.
+        """
+        Return last trip data entry.
 
         :return:
         """
@@ -3447,7 +2588,8 @@ class Vehicle:
 
     @property
     def trip_last_average_speed(self):
-        """Return last trip average speed.
+        """
+        Return last trip average speed.
 
         :return:
         """
@@ -3460,25 +2602,23 @@ class Vehicle:
 
     @property
     def is_trip_last_average_speed_supported(self) -> bool:
-        """Return true if supported.
+        """
+        Return true if supported.
 
         :return:
         """
-        return is_valid_path(
-            self.attrs, f"{Services.TRIP_LAST}.averageSpeed_kmph"
-        ) and type(
+        return is_valid_path(self.attrs, f"{Services.TRIP_LAST}.averageSpeed_kmph") and type(
             find_path(self.attrs, f"{Services.TRIP_LAST}.averageSpeed_kmph")
         ) in (float, int)
 
     @property
     def trip_last_average_electric_engine_consumption(self):
-        """Return last trip average electric consumption.
+        """
+        Return last trip average electric consumption.
 
         :return:
         """
-        return float(
-            find_path(self.attrs, f"{Services.TRIP_LAST}.averageElectricConsumption")
-        )
+        return float(find_path(self.attrs, f"{Services.TRIP_LAST}.averageElectricConsumption"))
 
     @property
     def trip_last_average_electric_engine_consumption_last_updated(self) -> datetime:
@@ -3487,25 +2627,23 @@ class Vehicle:
 
     @property
     def is_trip_last_average_electric_engine_consumption_supported(self) -> bool:
-        """Return true if supported.
+        """
+        Return true if supported.
 
         :return:
         """
-        return is_valid_path(
-            self.attrs, f"{Services.TRIP_LAST}.averageElectricConsumption"
-        ) and type(
+        return is_valid_path(self.attrs, f"{Services.TRIP_LAST}.averageElectricConsumption") and type(
             find_path(self.attrs, f"{Services.TRIP_LAST}.averageElectricConsumption")
         ) in (float, int)
 
     @property
     def trip_last_average_fuel_consumption(self):
-        """Return last trip average fuel consumption.
+        """
+        Return last trip average fuel consumption.
 
         :return:
         """
-        return float(
-            find_path(self.attrs, f"{Services.TRIP_LAST}.averageFuelConsumption")
-        )
+        return float(find_path(self.attrs, f"{Services.TRIP_LAST}.averageFuelConsumption"))
 
     @property
     def trip_last_average_fuel_consumption_last_updated(self) -> datetime:
@@ -3514,46 +2652,19 @@ class Vehicle:
 
     @property
     def is_trip_last_average_fuel_consumption_supported(self) -> bool:
-        """Return true if supported.
-
-        :return:
-        """
-        return is_valid_path(
-            self.attrs, f"{Services.TRIP_LAST}.averageFuelConsumption"
-        ) and type(
-            find_path(self.attrs, f"{Services.TRIP_LAST}.averageFuelConsumption")
-        ) in (float, int)
-
-    @property
-    def trip_last_average_gas_consumption(self):
-        """Return last trip average gas consumption.
-
-        :return:
         """
-        return float(
-            find_path(self.attrs, f"{Services.TRIP_LAST}.averageGasConsumption")
-        )
-
-    @property
-    def trip_last_average_gas_consumption_last_updated(self) -> datetime:
-        """Return last updated timestamp."""
-        return find_path(self.attrs, f"{Services.TRIP_LAST}.tripEndTimestamp")
-
-    @property
-    def is_trip_last_average_gas_consumption_supported(self) -> bool:
-        """Return true if supported.
+        Return true if supported.
 
         :return:
         """
-        return is_valid_path(
-            self.attrs, f"{Services.TRIP_LAST}.averageGasConsumption"
-        ) and type(
-            find_path(self.attrs, f"{Services.TRIP_LAST}.averageGasConsumption")
+        return is_valid_path(self.attrs, f"{Services.TRIP_LAST}.averageFuelConsumption") and type(
+            find_path(self.attrs, f"{Services.TRIP_LAST}.averageFuelConsumption")
         ) in (float, int)
 
     @property
     def trip_last_average_auxillary_consumption(self):
-        """Return last trip average auxiliary consumption.
+        """
+        Return last trip average auxiliary consumption.
 
         :return:
         """
@@ -3567,19 +2678,19 @@ class Vehicle:
 
     @property
     def is_trip_last_average_auxillary_consumption_supported(self) -> bool:
-        """Return true if supported.
+        """
+        Return true if supported.
 
         :return:
         """
-        return is_valid_path(
-            self.attrs, f"{Services.TRIP_LAST}.averageAuxiliaryConsumption"
-        ) and type(
+        return is_valid_path(self.attrs, f"{Services.TRIP_LAST}.averageAuxiliaryConsumption") and type(
             find_path(self.attrs, f"{Services.TRIP_LAST}.averageAuxiliaryConsumption")
         ) in (float, int)
 
     @property
     def trip_last_average_aux_consumer_consumption(self):
-        """Return last trip average auxiliary consumer consumption.
+        """
+        Return last trip average auxiliary consumer consumption.
 
         :return:
         """
@@ -3593,19 +2704,19 @@ class Vehicle:
 
     @property
     def is_trip_last_average_aux_consumer_consumption_supported(self) -> bool:
-        """Return true if supported.
+        """
+        Return true if supported.
 
         :return:
         """
-        return is_valid_path(
-            self.attrs, f"{Services.TRIP_LAST}.averageAuxConsumerConsumption"
-        ) and type(
+        return is_valid_path(self.attrs, f"{Services.TRIP_LAST}.averageAuxConsumerConsumption") and type(
             find_path(self.attrs, f"{Services.TRIP_LAST}.averageAuxConsumerConsumption")
         ) in (float, int)
 
     @property
     def trip_last_duration(self):
-        """Return last trip duration in minutes(?).
+        """
+        Return last trip duration in minutes(?).
 
         :return:
         """
@@ -3618,7 +2729,8 @@ class Vehicle:
 
     @property
     def is_trip_last_duration_supported(self) -> bool:
-        """Return true if supported.
+        """
+        Return true if supported.
 
         :return:
         """
@@ -3628,7 +2740,8 @@ class Vehicle:
 
     @property
     def trip_last_length(self):
-        """Return last trip length.
+        """
+        Return last trip length.
 
         :return:
         """
@@ -3641,7 +2754,8 @@ class Vehicle:
 
     @property
     def is_trip_last_length_supported(self) -> bool:
-        """Return true if supported.
+        """
+        Return true if supported.
 
         :return:
         """
@@ -3651,7 +2765,8 @@ class Vehicle:
 
     @property
     def trip_last_recuperation(self):
-        """Return last trip recuperation.
+        """
+        Return last trip recuperation.
 
         :return:
         """
@@ -3665,7 +2780,8 @@ class Vehicle:
 
     @property
     def is_trip_last_recuperation_supported(self) -> bool:
-        """Return true if supported.
+        """
+        Return true if supported.
 
         :return:
         """
@@ -3675,7 +2791,8 @@ class Vehicle:
 
     @property
     def trip_last_average_recuperation(self):
-        """Return last trip total recuperation.
+        """
+        Return last trip total recuperation.
 
         :return:
         """
@@ -3688,19 +2805,18 @@ class Vehicle:
 
     @property
     def is_trip_last_average_recuperation_supported(self) -> bool:
-        """Return true if supported.
+        """
+        Return true if supported.
 
         :return:
         """
         response = self.trip_last_entry
-        return response and type(response.get("averageRecuperation", None)) in (
-            float,
-            int,
-        )
+        return response and type(response.get("averageRecuperation", None)) in (float, int)
 
     @property
     def trip_last_total_electric_consumption(self):
-        """Return last trip total electric consumption.
+        """
+        Return last trip total electric consumption.
 
         :return:
         """
@@ -3714,16 +2830,14 @@ class Vehicle:
 
     @property
     def is_trip_last_total_electric_consumption_supported(self) -> bool:
-        """Return true if supported.
+        """
+        Return true if supported.
 
         :return:
         """
         # Not implemented
         response = self.trip_last_entry
-        return response and type(response.get("totalElectricConsumption", None)) in (
-            float,
-            int,
-        )
+        return response and type(response.get("totalElectricConsumption", None)) in (float, int)
 
     # Status of set data requests
     @property
@@ -3766,11 +2880,9 @@ class Vehicle:
     def request_in_progress(self) -> bool:
         """Check of any requests are currently in progress."""
         try:
-            return any(
-                isinstance(value, dict) and "id" in value and bool(value["id"])
-                for value in self._requests.values()
-            )
-        except Exception as e:  # pylint: disable=broad-exception-caught
+            for section in self._requests:
+                return self._requests[section].get("id", False)
+        except Exception as e:
             _LOGGER.warning(e)
         return False
 
@@ -3778,18 +2890,11 @@ class Vehicle:
     def request_in_progress_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
         try:
-            # Get all timestamps in the dictionary
-            timestamps = [
-                item["timestamp"]
-                for item in self._requests.values()
-                if isinstance(item, dict) and "timestamp" in item
-            ]
-
-            # Return the most recent timestamp
-            return max(timestamps) if timestamps else datetime.now(UTC)
-        except Exception as e:  # pylint: disable=broad-exception-caught
+            for section in self._requests:
+                return self._requests[section].get("timestamp")
+        except Exception as e:
             _LOGGER.warning(e)
-        return datetime.now(UTC)
+        return datetime.now(timezone.utc)
 
     @property
     def is_request_in_progress_supported(self):
@@ -3799,18 +2904,9 @@ class Vehicle:
     @property
     def request_results(self) -> dict:
         """Get last request result."""
-        data = {
-            "latest": self._requests.get("latest", None),
-            "state": self._requests.get("state", None),
-        }
+        data = {"latest": self._requests.get("latest", None), "state": self._requests.get("state", None)}
         for section in self._requests:
-            if section in [
-                "departuretimer",
-                "batterycharge",
-                "climatisation",
-                "refresh",
-                "lock",
-            ]:
+            if section in ["departuretimer", "batterycharge", "climatisation", "refresh", "lock"]:
                 data[section] = self._requests[section].get("status", "Unknown")
         return data
 
@@ -3818,18 +2914,10 @@ class Vehicle:
     def request_results_last_updated(self) -> datetime | None:
         """Get last updated time."""
         if self._requests.get("latest", "") != "":
-            return self._requests.get(str(self._requests.get("latest")), {}).get(
-                "timestamp"
-            )
+            return self._requests.get(str(self._requests.get("latest")), {}).get("timestamp")
         # all requests should have more or less the same timestamp anyway, so
         # just return the first one
-        for section in [
-            "departuretimer",
-            "batterycharge",
-            "climatisation",
-            "refresh",
-            "lock",
-        ]:
+        for section in ["departuretimer", "batterycharge", "climatisation", "refresh", "lock"]:
             if section in self._requests:
                 return self._requests[section].get("timestamp")
         return None
@@ -3851,211 +2939,104 @@ class Vehicle:
 
     @property
     def json(self):
-        """Return vehicle data in JSON format.
+        """
+        Return vehicle data in JSON format.
 
         :return:
         """
 
         def serialize(obj):
-            """Convert datetime instances back to JSON compatible format.
+            """
+            Convert datetime instances back to JSON compatible format.
 
             :param obj:
             :return:
             """
             return obj.isoformat() if isinstance(obj, datetime) else obj
 
-        return to_json(
-            OrderedDict(sorted(self.attrs.items())), indent=4, default=serialize
-        )
+        return to_json(OrderedDict(sorted(self.attrs.items())), indent=4, default=serialize)
 
     def is_primary_drive_electric(self):
         """Check if primary engine is electric."""
         return (
-            find_path(
-                self.attrs,
-                f"{Services.MEASUREMENTS}.fuelLevelStatus.value.primaryEngineType",
-            )
+            find_path(self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.primaryEngineType")
             == ENGINE_TYPE_ELECTRIC
         )
 
     def is_secondary_drive_electric(self):
         """Check if secondary engine is electric."""
         return (
-            is_valid_path(
-                self.attrs,
-                f"{Services.MEASUREMENTS}.fuelLevelStatus.value.secondaryEngineType",
-            )
-            and find_path(
-                self.attrs,
-                f"{Services.MEASUREMENTS}.fuelLevelStatus.value.secondaryEngineType",
-            )
+            is_valid_path(self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.primaryEngineType")
+            and find_path(self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.primaryEngineType")
             == ENGINE_TYPE_ELECTRIC
         )
 
     def is_primary_drive_combustion(self):
         """Check if primary engine is combustion."""
         engine_type = ""
-        if is_valid_path(
-            self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.primaryEngine.type"
-        ):
-            engine_type = find_path(
-                self.attrs,
-                f"{Services.FUEL_STATUS}.rangeStatus.value.primaryEngine.type",
-            )
+        if is_valid_path(self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.primaryEngine.type"):
+            engine_type = find_path(self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.primaryEngine.type")
 
-        if is_valid_path(
-            self.attrs,
-            f"{Services.MEASUREMENTS}.fuelLevelStatus.value.primaryEngineType",
-        ):
-            engine_type = find_path(
-                self.attrs,
-                f"{Services.MEASUREMENTS}.fuelLevelStatus.value.primaryEngineType",
-            )
+        if is_valid_path(self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.primaryEngineType"):
+            engine_type = find_path(self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.primaryEngineType")
 
         return engine_type in ENGINE_TYPE_COMBUSTION
 
     def is_secondary_drive_combustion(self):
         """Check if secondary engine is combustion."""
         engine_type = ""
-        if is_valid_path(
-            self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.secondaryEngine.type"
-        ):
-            engine_type = find_path(
-                self.attrs,
-                f"{Services.FUEL_STATUS}.rangeStatus.value.secondaryEngine.type",
-            )
+        if is_valid_path(self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.secondaryEngine.type"):
+            engine_type = find_path(self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.secondaryEngine.type")
 
-        if is_valid_path(
-            self.attrs,
-            f"{Services.MEASUREMENTS}.fuelLevelStatus.value.secondaryEngineType",
-        ):
-            engine_type = find_path(
-                self.attrs,
-                f"{Services.MEASUREMENTS}.fuelLevelStatus.value.secondaryEngineType",
-            )
+        if is_valid_path(self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.secondaryEngineType"):
+            engine_type = find_path(self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.secondaryEngineType")
 
         return engine_type in ENGINE_TYPE_COMBUSTION
 
-    def is_primary_drive_gas(self):
-        """Check if primary engine is gas."""
-        if is_valid_path(
-            self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carType"
-        ):
-            return (
-                find_path(
-                    self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carType"
-                )
-                == ENGINE_TYPE_GAS
-            )
-        if is_valid_path(
-            self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carType"
-        ):
-            return (
-                find_path(
-                    self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carType"
-                )
-                == ENGINE_TYPE_GAS
-            )
-        return False
-
     @property
     def is_car_type_electric(self):
         """Check if car type is electric."""
-        if is_valid_path(
-            self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carType"
-        ):
-            return (
-                find_path(
-                    self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carType"
-                )
-                == ENGINE_TYPE_ELECTRIC
-            )
-        if is_valid_path(
-            self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carType"
-        ):
+        if is_valid_path(self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carType"):
+            return find_path(self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carType") == ENGINE_TYPE_ELECTRIC
+        if is_valid_path(self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carType"):
             return (
-                find_path(
-                    self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carType"
-                )
-                == ENGINE_TYPE_ELECTRIC
+                find_path(self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carType") == ENGINE_TYPE_ELECTRIC
             )
         return False
 
     @property
     def is_car_type_diesel(self):
         """Check if car type is diesel."""
-        if is_valid_path(
-            self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carType"
-        ):
-            return (
-                find_path(
-                    self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carType"
-                )
-                == ENGINE_TYPE_DIESEL
-            )
-        if is_valid_path(
-            self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carType"
-        ):
-            return (
-                find_path(
-                    self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carType"
-                )
-                == ENGINE_TYPE_DIESEL
-            )
+        if is_valid_path(self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carType"):
+            return find_path(self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carType") == ENGINE_TYPE_DIESEL
+        if is_valid_path(self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carType"):
+            return find_path(self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carType") == ENGINE_TYPE_DIESEL
         return False
 
     @property
     def is_car_type_gasoline(self):
         """Check if car type is gasoline."""
-        if is_valid_path(
-            self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carType"
-        ):
-            return (
-                find_path(
-                    self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carType"
-                )
-                == ENGINE_TYPE_GASOLINE
-            )
-        if is_valid_path(
-            self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carType"
-        ):
+        if is_valid_path(self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carType"):
+            return find_path(self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carType") == ENGINE_TYPE_GASOLINE
+        if is_valid_path(self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carType"):
             return (
-                find_path(
-                    self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carType"
-                )
-                == ENGINE_TYPE_GASOLINE
+                find_path(self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carType") == ENGINE_TYPE_GASOLINE
             )
         return False
 
     @property
     def is_car_type_hybrid(self):
         """Check if car type is hybrid."""
-        if is_valid_path(
-            self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carType"
-        ):
-            return (
-                find_path(
-                    self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carType"
-                )
-                == ENGINE_TYPE_HYBRID
-            )
-        if is_valid_path(
-            self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carType"
-        ):
-            return (
-                find_path(
-                    self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carType"
-                )
-                == ENGINE_TYPE_HYBRID
-            )
+        if is_valid_path(self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carType"):
+            return find_path(self.attrs, f"{Services.FUEL_STATUS}.rangeStatus.value.carType") == ENGINE_TYPE_HYBRID
+        if is_valid_path(self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carType"):
+            return find_path(self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.carType") == ENGINE_TYPE_HYBRID
         return False
 
     @property
     def has_combustion_engine(self):
         """Return true if car has a combustion engine."""
-        return (
-            self.is_primary_drive_combustion() or self.is_secondary_drive_combustion()
-        )
+        return self.is_primary_drive_combustion() or self.is_secondary_drive_combustion()
 
     @property
     def api_vehicles_status(self) -> bool:
@@ -4065,7 +3046,7 @@ class Vehicle:
     @property
     def api_vehicles_status_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return datetime.now(UTC)
+        return datetime.now(timezone.utc)
 
     @property
     def is_api_vehicles_status_supported(self):
@@ -4075,14 +3056,12 @@ class Vehicle:
     @property
     def api_capabilities_status(self) -> bool:
         """Check capabilities API status."""
-        return self.attrs.get(Services.SERVICE_STATUS, {}).get(
-            "capabilities", "Unknown"
-        )
+        return self.attrs.get(Services.SERVICE_STATUS, {}).get("capabilities", "Unknown")
 
     @property
     def api_capabilities_status_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return datetime.now(UTC)
+        return datetime.now(timezone.utc)
 
     @property
     def is_api_capabilities_status_supported(self):
@@ -4097,7 +3076,7 @@ class Vehicle:
     @property
     def api_trips_status_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return datetime.now(UTC)
+        return datetime.now(timezone.utc)
 
     @property
     def is_api_trips_status_supported(self):
@@ -4109,14 +3088,12 @@ class Vehicle:
     @property
     def api_selectivestatus_status(self) -> bool:
         """Check selectivestatus API status."""
-        return self.attrs.get(Services.SERVICE_STATUS, {}).get(
-            "selectivestatus", "Unknown"
-        )
+        return self.attrs.get(Services.SERVICE_STATUS, {}).get("selectivestatus", "Unknown")
 
     @property
     def api_selectivestatus_status_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return datetime.now(UTC)
+        return datetime.now(timezone.utc)
 
     @property
     def is_api_selectivestatus_status_supported(self):
@@ -4126,14 +3103,12 @@ class Vehicle:
     @property
     def api_parkingposition_status(self) -> bool:
         """Check parkingposition API status."""
-        return self.attrs.get(Services.SERVICE_STATUS, {}).get(
-            "parkingposition", "Unknown"
-        )
+        return self.attrs.get(Services.SERVICE_STATUS, {}).get("parkingposition", "Unknown")
 
     @property
     def api_parkingposition_status_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return datetime.now(UTC)
+        return datetime.now(timezone.utc)
 
     @property
     def is_api_parkingposition_status_supported(self):
@@ -4150,7 +3125,7 @@ class Vehicle:
     @property
     def api_token_status_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return datetime.now(UTC)
+        return datetime.now(timezone.utc)
 
     @property
     def is_api_token_status_supported(self):
@@ -4168,7 +3143,7 @@ class Vehicle:
     @property
     def last_data_refresh_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return datetime.now(UTC)
+        return datetime.now(timezone.utc)
 
     @property
     def is_last_data_refresh_supported(self):