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

volkswagencarnet/vw_vehicle.py

@@ -1,14 +1,15 @@
 #!/usr/bin/env python3
-"""Vehicle class for We Connect."""
+"""Vehicle class for Volkswagen Connect."""
+
 from __future__ import annotations
 
 import asyncio
-import logging
 from collections import OrderedDict
-from datetime import datetime, timedelta, timezone
+from datetime import UTC, datetime, timedelta
 from json import dumps as to_json
+import logging
 
-from .vw_const import VehicleStatusParameter as P, Services
+from .vw_const import Services, VehicleStatusParameter as P
 from .vw_utilities import find_path, is_valid_path
 
 # TODO
@@ -24,15 +25,21 @@ _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_COMBUSTION = [
+    ENGINE_TYPE_DIESEL,
+    ENGINE_TYPE_GASOLINE,
+    ENGINE_TYPE_CNG,
+]
+ENGINE_TYPE_GAS = [ENGINE_TYPE_CNG]
 DEFAULT_TARGET_TEMP = 24
 
 
 class Vehicle:
     """Vehicle contains the state of sensors and methods for interacting with the car."""
 
-    def __init__(self, conn, url):
+    def __init__(self, conn, url) -> None:
         """Initialize the Vehicle with default values."""
         self._connection = conn
         self._url = url
@@ -40,18 +47,17 @@ class Vehicle:
         self._discovered = False
         self._states = {}
         self._requests: dict[str, object] = {
-            "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)},
+            "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)},
             "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},
@@ -73,33 +79,50 @@ 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(timezone.utc) - timedelta(minutes=unknown_offset)
+                "timestamp",
+                datetime.now(UTC) - timedelta(minutes=unknown_offset),
             )
-            if timestamp + timedelta(minutes=3) < datetime.now(timezone.utc):
+            if timestamp + timedelta(minutes=3) < datetime.now(UTC):
                 self._requests.get(topic, {}).pop("id")
             else:
-                _LOGGER.info(f"Action ({topic}) already in progress")
+                _LOGGER.info("Action (%s) already in progress", topic)
                 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] = {
-                "timestamp": datetime.now(timezone.utc),
-                "status": response.get("state", "Unknown"),
-                "id": response.get("id", 0),
+                "status": "Failed",
+                "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)}
+            _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),
+        }
         return True
 
     # API get and set functions #
@@ -107,43 +130,64 @@ 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 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}")
+
+        # 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)
         self._discovered = True
 
     async def update(self):
@@ -175,7 +219,7 @@ class Vehicle:
             )
             await asyncio.gather(self.get_service_status())
         else:
-            _LOGGER.info(f"Vehicle with VIN {self.vin} is deactivated.")
+            _LOGGER.info("Vehicle with VIN %s is deactivated", self.vin)
 
     # Data collection functions
     async def get_selectivestatus(self, services):
@@ -214,26 +258,28 @@ class Vehicle:
         """Update status of outstanding requests."""
         retry_count -= 1
         if retry_count == 0:
-            _LOGGER.info(f"Timeout while waiting for result of {request.requestId}.")
+            _LOGGER.info("Timeout while waiting for result of %s", request.requestId)
             return "Timeout"
         try:
             status = await self._connection.get_request_status(self.vin, request)
-            _LOGGER.debug(f"Request ID {request}: {status}")
+            _LOGGER.debug("Request ID %s: %s", request, status)
             self._requests["state"] = status
             if status == "In Progress":
                 await asyncio.sleep(10)
                 return await self.wait_for_request(request, retry_count)
-            else:
-                return status
-        except Exception as error:
-            _LOGGER.warning(f"Exception encountered while waiting for request status: {error}")
+        except Exception as error:  # pylint: disable=broad-exception-caught
+            _LOGGER.warning(
+                "Exception encountered while waiting for request status: %s", 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])
@@ -241,41 +287,32 @@ class Vehicle:
             if self.last_connected < refresh_trigger_time:
                 await asyncio.sleep(10)
                 return await self.wait_for_data_refresh(retry_count)
-            else:
-                return "successful"
-        except Exception as error:
-            _LOGGER.warning(f"Exception encountered while waiting for data refresh: {error}")
+
+        except Exception as error:  # pylint: disable=broad-exception-caught
+            _LOGGER.warning(
+                "Exception encountered while waiting for data refresh: %s", 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(f'Charging action "{action}" is not supported.')
-                raise Exception(f'Charging action "{action}" is not supported.')
+                _LOGGER.error('Charging action "%s" is not supported', action)
+                raise Exception(f'Charging action "{action}" is not supported.')  # pylint: disable=broad-exception-raised
             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",
             )
-        else:
-            _LOGGER.error("No charging support.")
-            raise Exception("No charging support.")
+        _LOGGER.error("No charging support")
+        raise Exception("No charging support.")  # pylint: disable=broad-exception-raised
 
     async def set_charging_settings(self, setting, value):
         """Set charging settings."""
@@ -283,62 +320,96 @@ 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(f'Charging setting "{value}" is not supported.')
-                raise Exception(f'Charging setting "{value}" is not supported.')
+                _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."
+                )
             data = {}
-            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_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_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
+                    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
                 )
             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",
             )
-        else:
-            _LOGGER.error("Charging settings are not supported.")
-            raise Exception("Charging settings are not supported.")
+        _LOGGER.error("Charging settings are not supported")
+        raise Exception("Charging settings are not supported.")  # pylint: disable=broad-exception-raised
 
     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(f'Charging care mode "{value}" is not supported.')
-                raise Exception(f'Charging care mode "{value}" is not supported.')
+                _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
             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",
             )
-        else:
-            _LOGGER.error("Charging care settings are not supported.")
-            raise Exception("Charging care settings are not supported.")
+        _LOGGER.error("Charging care settings are not supported")
+        raise Exception("Charging care settings are not supported.")  # pylint: disable=broad-exception-raised
 
     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(f'Battery support mode "{value}" is not supported.')
-                raise Exception(f'Battery support mode "{value}" is not supported.')
+                _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
             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",
             )
-        else:
-            _LOGGER.error("Battery support settings are not supported.")
-            raise Exception("Battery support settings are not supported.")
+        _LOGGER.error("Battery support settings are not supported")
+        raise Exception("Battery support settings are not supported.")  # pylint: disable=broad-exception-raised
 
     # Climatisation electric/auxiliary/windows (CLIMATISATION)
     async def set_climatisation_settings(self, setting, value):
@@ -385,16 +456,26 @@ 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(
@@ -402,27 +483,28 @@ class Vehicle:
                     topic="climatisation",
                     error_msg="Failed to set climatisation settings",
                 )
-            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.")
+            _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
 
     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(f'Window heater action "{action}" is not supported.')
-                raise Exception(f'Window heater action "{action}" is not supported.')
+                _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
             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",
             )
-        else:
-            _LOGGER.error("No climatisation support.")
-            raise Exception("No climatisation support.")
+        _LOGGER.error("No climatisation support")
+        raise Exception("No climatisation support.")  # pylint: disable=broad-exception-raised
 
     async def set_climatisation(self, action="stop"):
         """Turn on/off climatisation with electric heater."""
@@ -433,7 +515,9 @@ 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:
@@ -445,18 +529,19 @@ class Vehicle:
             elif action == "stop":
                 data = {}
             else:
-                _LOGGER.error(f"Invalid climatisation action: {action}")
-                raise Exception(f"Invalid climatisation action: {action}")
+                _LOGGER.error("Invalid climatisation action: %s", action)
+                raise Exception(f"Invalid climatisation action: {action}")  # pylint: disable=broad-exception-raised
             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.",
             )
-        else:
-            _LOGGER.error("No climatisation support.")
-            raise Exception("No climatisation support.")
+        _LOGGER.error("No climatisation support")
+        raise Exception("No climatisation support.")  # pylint: disable=broad-exception-raised
 
     async def set_auxiliary_climatisation(self, action, spin):
         """Turn on/off climatisation with auxiliary heater."""
@@ -468,72 +553,102 @@ class Vehicle:
             elif action == "stop":
                 data = {}
             else:
-                _LOGGER.error(f"Invalid auxiliary heater action: {action}")
-                raise Exception(f"Invalid auxiliary heater action: {action}")
+                _LOGGER.error("Invalid auxiliary heater action: %s", action)
+                raise Exception(f"Invalid auxiliary heater action: {action}")  # pylint: disable=broad-exception-raised
             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.",
             )
-        else:
-            _LOGGER.error("No climatisation support.")
-            raise Exception("No climatisation support.")
+        _LOGGER.error("No climatisation support")
+        raise Exception("No climatisation support.")  # pylint: disable=broad-exception-raised
 
     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 type(enable) is not bool:
-                _LOGGER.error("Charging departure timers setting is not supported.")
-                raise Exception("Charging departure timers setting is not supported.")
+            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
             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 i in range(len(timers)):
-                    if timers[i].get("id", 0) == timer_id:
-                        timers[i]["enabled"] = enable
+                for index, timer in enumerate(timers):
+                    if timer.get("id", 0) == timer_id:
+                        timers[index]["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 i in range(len(timers)):
-                    if timers[i].get("id", 0) == timer_id:
-                        timers[i]["enabled"] = enable
+                for index, timer in enumerate(timers):
+                    if timer.get("id", 0) == timer_id:
+                        timers[index]["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 i in range(len(timers)):
-                    if timers[i].get("id", 0) == timer_id:
-                        timers[i]["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 index, timer in enumerate(timers):
+                    if timer.get("id", 0) == timer_id:
+                        timers[index]["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.",
             )
-        else:
-            _LOGGER.error("Departure timers are not supported.")
-            raise Exception("Departure timers are not supported.")
+        _LOGGER.error("Departure timers are not supported")
+        raise Exception("Departure timers are not supported.")  # pylint: disable=broad-exception-raised
 
     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 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
+            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
             data = {"timers": timers}
             response = await self._connection.setClimatisationTimers(self.vin, data)
             return await self._handle_response(
@@ -541,32 +656,38 @@ class Vehicle:
                 topic="departuretimer",
                 error_msg="Failed to change climatisation departure timers setting.",
             )
-        else:
-            _LOGGER.error("Climatisation departure timers are not supported.")
-            raise Exception("Climatisation departure timers are not supported.")
+        _LOGGER.error("Climatisation departure timers are not supported")
+        raise Exception("Climatisation departure timers are not supported.")  # pylint: disable=broad-exception-raised
 
     # 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.")
+            _LOGGER.info("Remote lock/unlock is not supported")
+            raise Exception("Remote lock/unlock is not supported.")  # pylint: disable=broad-exception-raised
         if self._in_progress("lock", unknown_offset=-5):
             return False
         if action not in ["lock", "unlock"]:
-            _LOGGER.error(f"Invalid lock action: {action}")
-            raise Exception(f"Invalid lock action: {action}")
+            _LOGGER.error("Invalid lock action: %s", action)
+            raise Exception(f"Invalid lock action: {action}")  # pylint: disable=broad-exception-raised
 
         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:
-            _LOGGER.warning(f"Failed to {action} vehicle - {error}")
-            self._requests["lock"] = {"status": "Exception", "timestamp": datetime.now(timezone.utc)}
-        raise Exception("Lock action failed")
+        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
 
     # Refresh vehicle data (VSR)
     async def set_refresh(self):
@@ -580,40 +701,46 @@ class Vehicle:
                 if response.status == 204:
                     self._requests["state"] = "in_progress"
                     self._requests["refresh"] = {
-                        "timestamp": datetime.now(timezone.utc),
+                        "timestamp": datetime.now(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(f"Unable to refresh the data. Incorrect response code: {response.status}")
+                    _LOGGER.debug(
+                        "Unable to refresh the data. Incorrect response code: %s",
+                        response.status,
+                    )
                 self._requests["state"] = status
-                self._requests["refresh"] = {"status": status, "timestamp": datetime.now(timezone.utc)}
+                self._requests["refresh"] = {
+                    "status": status,
+                    "timestamp": datetime.now(UTC),
+                }
                 return True
-            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")
+            _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
 
     # 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:
@@ -621,8 +748,7 @@ 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:
@@ -632,41 +758,44 @@ class Vehicle:
     async def expired(self, service):
         """Check if access to service has expired."""
         try:
-            now = datetime.utcnow()
+            now = datetime.now(UTC)
             if self._services.get(service, {}).get("expiration", False):
                 expiration = self._services.get(service, {}).get("expiration", False)
                 if not expiration:
-                    expiration = datetime.utcnow() + timedelta(days=1)
+                    expiration = datetime.neow(UTC) + timedelta(days=1)
             else:
-                _LOGGER.debug(f"Could not determine end of access for service {service}, assuming it is valid")
-                expiration = datetime.utcnow() + timedelta(days=1)
+                _LOGGER.debug(
+                    "Could not determine end of access for service %s, assuming it is valid",
+                    service,
+                )
+                expiration = datetime.now(UTC) + timedelta(days=1)
             expiration = expiration.replace(tzinfo=None)
             if now >= expiration:
-                _LOGGER.warning(f"Access to {service} has expired!")
+                _LOGGER.warning("Access to %s has expired!", service)
                 self._discovered = False
                 return True
-            else:
-                return False
-        except Exception:
-            _LOGGER.debug(f"Exception. Could not determine end of access for service {service}, assuming it is valid")
+        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:
             return False
 
     def dashboard(self, **config):
-        """
-        Return dashboard with specified configuration.
+        """Return dashboard with specified configuration.
 
         :param config:
         :return:
         """
-        # Classic python notation
-        from .vw_dashboard import Dashboard
+        from .vw_dashboard import Dashboard  # pylint: disable=import-outside-toplevel
 
         return Dashboard(self, **config)
 
     @property
     def vin(self) -> str:
-        """
-        Vehicle identification number.
+        """Vehicle identification number.
 
         :return:
         """
@@ -674,8 +803,7 @@ class Vehicle:
 
     @property
     def unique_id(self) -> str:
-        """
-        Return unique id for the vehicle (vin).
+        """Return unique id for the vehicle (vin).
 
         :return:
         """
@@ -685,8 +813,7 @@ class Vehicle:
     # Car information
     @property
     def nickname(self) -> str | None:
-        """
-        Return nickname of the vehicle.
+        """Return nickname of the vehicle.
 
         :return:
         """
@@ -694,8 +821,7 @@ 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:
         """
@@ -703,8 +829,7 @@ class Vehicle:
 
     @property
     def deactivated(self) -> bool | None:
-        """
-        Return true if service is deactivated.
+        """Return true if service is deactivated.
 
         :return:
         """
@@ -712,8 +837,7 @@ 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:
         """
@@ -747,8 +871,7 @@ 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:
         """
@@ -759,17 +882,27 @@ 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 == 1
+        return lights_on_count == 2
 
     @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:
@@ -785,33 +918,35 @@ 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
-        elif self.is_distance_supported:
-            if type(self.distance_last_updated) is str:
+        if self.is_distance_supported:
+            if isinstance(self.distance_last_updated, 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=timezone.utc)
+                    .replace(tzinfo=UTC)
                 )
-            else:
-                return self.distance_last_updated
+            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
-        elif self.is_distance_supported:
-            if type(self.distance_last_updated) is str:
+        if self.is_distance_supported:
+            if isinstance(self.distance_last_updated, 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=timezone.utc)
+                    .replace(tzinfo=UTC)
                 )
-            else:
-                return self.distance_last_updated
+            return self.distance_last_updated
 
     @property
     def is_last_connected_supported(self) -> bool:
@@ -822,326 +957,495 @@ 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"
-        elif charger_type == "dc":
+        if 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")
+        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",
+        )
 
     @property
     def charge_max_ac_setting(self) -> str | int:
         """Return charger max ampere setting."""
-        value = find_path(self.attrs, f"{Services.CHARGING}.chargingSettings.value.maxChargeCurrentAC")
-        return value
+        return find_path(
+            self.attrs, f"{Services.CHARGING}.chargingSettings.value.maxChargeCurrentAC"
+        )
 
     @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:
@@ -1161,64 +1465,89 @@ 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(timezone.utc)
+        return datetime.now(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(timezone.utc)
+        return datetime.now(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
+        # TODO untouched # pylint: disable=fixme
         """Return true if energy is flowing through charging port."""
         check = (
             self.attrs.get("charger", {})
@@ -1231,7 +1560,7 @@ class Vehicle:
 
     @property
     def energy_flow_last_updated(self) -> datetime:
-        # TODO untouched
+        # TODO untouched # pylint: disable=fixme
         """Return energy flow last updated."""
         return (
             self.attrs.get("charger", {})
@@ -1243,9 +1572,14 @@ class Vehicle:
 
     @property
     def is_energy_flow_supported(self) -> bool:
-        # TODO untouched
+        # TODO untouched # pylint: disable=fixme
         """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
@@ -1258,9 +1592,11 @@ 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:
+        except Exception:  # pylint: disable=broad-exception-caught
             output = {
                 "lat": "?",
                 "lng": "?",
@@ -1270,12 +1606,16 @@ 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:
@@ -1313,43 +1653,64 @@ 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):
@@ -1359,83 +1720,179 @@ 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 true if combustion range is supported, i.e. false for EVs.
+        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:
         """
-        return is_valid_path(self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.dieselRange") or is_valid_path(
+        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(
             self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.gasolineRange"
         )
 
     @property
-    def combined_range(self) -> int:
+    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 combined range.
+        return is_valid_path(
+            self.attrs, f"{Services.MEASUREMENTS}.rangeStatus.value.cngRange"
+        )
+
+    @property
+    def combined_range(self) -> int:
+        """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"):
+        if (
+            is_valid_path(
+                self.attrs,
+                f"{Services.FUEL_STATUS}.rangeStatus.value.primaryEngine.currentFuelLevel_pct",
+            )
+            and not self.is_primary_drive_gas()
+        ):
             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
 
@@ -1443,58 +1900,162 @@ 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 true if fuel level reporting is supported.
+        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:
         """
-        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")
+        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 car_type(self) -> str:
+    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:
         """
-        Return car type.
+        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",
+        )
+
+    @property
+    def car_type(self) -> str:
+        """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"
         )
 
@@ -1502,109 +2063,167 @@ class Vehicle:
     @property
     def climatisation_target_temperature(self) -> float | None:
         """Return the target temperature from climater."""
-        # TODO should we handle Fahrenheit??
-        return float(find_path(self.attrs, f"{Services.CLIMATISATION}.climatisationSettings.value.targetTemperature_C"))
+        # TODO should we handle Fahrenheit?? # pylint: disable=fixme
+        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:
@@ -1623,32 +2242,45 @@ 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
@@ -1657,80 +2289,115 @@ 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
-                    else:
-                        return True
+                    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":
@@ -1741,18 +2408,25 @@ 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":
@@ -1763,12 +2437,18 @@ 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:
@@ -1784,29 +2464,50 @@ 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
@@ -1826,15 +2527,17 @@ 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
@@ -1842,29 +2545,38 @@ 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
@@ -1872,29 +2584,38 @@ 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
@@ -1902,29 +2623,38 @@ 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
@@ -1932,29 +2662,38 @@ 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
@@ -1962,29 +2701,38 @@ 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
@@ -1992,29 +2740,38 @@ 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
@@ -2022,15 +2779,22 @@ 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
 
@@ -2042,51 +2806,60 @@ 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:
         """
@@ -2099,12 +2872,13 @@ 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:
         """
@@ -2119,8 +2893,7 @@ class Vehicle:
 
     @property
     def trunk_locked_sensor(self) -> bool:
-        """
-        Return trunk locked state.
+        """Return trunk locked state.
 
         :return:
         """
@@ -2133,12 +2906,13 @@ 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:
         """
@@ -2154,15 +2928,17 @@ 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
@@ -2170,7 +2946,9 @@ 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:
@@ -2184,15 +2962,17 @@ 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
@@ -2200,7 +2980,9 @@ 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:
@@ -2214,15 +2996,17 @@ 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
@@ -2230,7 +3014,9 @@ 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:
@@ -2244,15 +3030,17 @@ 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
@@ -2260,7 +3048,9 @@ 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:
@@ -2274,15 +3064,17 @@ 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
@@ -2290,7 +3082,9 @@ 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:
@@ -2304,8 +3098,7 @@ class Vehicle:
 
     @property
     def trunk_closed(self) -> bool:
-        """
-        Return trunk closed state.
+        """Return trunk closed state.
 
         :return:
         """
@@ -2318,7 +3111,9 @@ 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:
@@ -2350,20 +3145,28 @@ 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
 
@@ -2410,40 +3213,61 @@ 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=timezone.utc).astimezone(tz=None).strftime("%Y-%m-%dT%H:%M:%S")
+                    start_date_time.replace(tzinfo=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 type(start_date_time) is 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 isinstance(start_date_time, 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 type(start_date_time) is 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 isinstance(start_date_time, 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=timezone.utc)
+                    .replace(tzinfo=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)
-            for day in recurring_days:
-                if recurring_days.get(day) is True:
-                    recurring_on.append(day)
+            recurring_days = timer.get("recurringTimer", {}).get("recurringOn", {})
+            recurring_on = [day for day in recurring_days if recurring_days.get(day)]
         data = {
             "timer_id": timer.get("id", None),
             "timer_type": timer_type,
@@ -2463,24 +3287,46 @@ 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
@@ -2488,8 +3334,14 @@ 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
@@ -2510,7 +3362,8 @@ 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
@@ -2538,8 +3391,14 @@ 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
@@ -2554,33 +3413,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=timezone.utc).astimezone(tz=None).strftime("%Y-%m-%dT%H:%M:%S")
+            start_time = (
+                start_date_time.replace(tzinfo=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=timezone.utc)
+                .replace(tzinfo=UTC)
                 .astimezone(tz=None)
                 .strftime("%H:%M")
             )
             recurring_days = timer.get("recurringTimer", None).get("recurringOn", None)
-            for day in recurring_days:
-                if recurring_days.get(day) is True:
-                    recurring_on.append(day)
-        data = {
+            recurring_on = [day for day in recurring_days if recurring_days.get(day)]
+        return {
             "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:
         """
@@ -2588,8 +3447,7 @@ class Vehicle:
 
     @property
     def trip_last_average_speed(self):
-        """
-        Return last trip average speed.
+        """Return last trip average speed.
 
         :return:
         """
@@ -2602,23 +3460,25 @@ 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:
@@ -2627,23 +3487,25 @@ 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:
@@ -2652,19 +3514,46 @@ class Vehicle:
 
     @property
     def is_trip_last_average_fuel_consumption_supported(self) -> bool:
-        """
-        Return true if supported.
+        """Return true if supported.
 
         :return:
         """
-        return is_valid_path(self.attrs, f"{Services.TRIP_LAST}.averageFuelConsumption") and type(
+        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):
+    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:
         """
-        Return last trip average auxiliary consumption.
+        return is_valid_path(
+            self.attrs, f"{Services.TRIP_LAST}.averageGasConsumption"
+        ) and type(
+            find_path(self.attrs, f"{Services.TRIP_LAST}.averageGasConsumption")
+        ) in (float, int)
+
+    @property
+    def trip_last_average_auxillary_consumption(self):
+        """Return last trip average auxiliary consumption.
 
         :return:
         """
@@ -2678,19 +3567,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:
         """
@@ -2704,19 +3593,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:
         """
@@ -2729,8 +3618,7 @@ class Vehicle:
 
     @property
     def is_trip_last_duration_supported(self) -> bool:
-        """
-        Return true if supported.
+        """Return true if supported.
 
         :return:
         """
@@ -2740,8 +3628,7 @@ class Vehicle:
 
     @property
     def trip_last_length(self):
-        """
-        Return last trip length.
+        """Return last trip length.
 
         :return:
         """
@@ -2754,8 +3641,7 @@ class Vehicle:
 
     @property
     def is_trip_last_length_supported(self) -> bool:
-        """
-        Return true if supported.
+        """Return true if supported.
 
         :return:
         """
@@ -2765,8 +3651,7 @@ class Vehicle:
 
     @property
     def trip_last_recuperation(self):
-        """
-        Return last trip recuperation.
+        """Return last trip recuperation.
 
         :return:
         """
@@ -2780,8 +3665,7 @@ class Vehicle:
 
     @property
     def is_trip_last_recuperation_supported(self) -> bool:
-        """
-        Return true if supported.
+        """Return true if supported.
 
         :return:
         """
@@ -2791,8 +3675,7 @@ class Vehicle:
 
     @property
     def trip_last_average_recuperation(self):
-        """
-        Return last trip total recuperation.
+        """Return last trip total recuperation.
 
         :return:
         """
@@ -2805,18 +3688,19 @@ 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:
         """
@@ -2830,14 +3714,16 @@ 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
@@ -2880,9 +3766,11 @@ class Vehicle:
     def request_in_progress(self) -> bool:
         """Check of any requests are currently in progress."""
         try:
-            for section in self._requests:
-                return self._requests[section].get("id", False)
-        except Exception as e:
+            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
             _LOGGER.warning(e)
         return False
 
@@ -2890,11 +3778,18 @@ class Vehicle:
     def request_in_progress_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
         try:
-            for section in self._requests:
-                return self._requests[section].get("timestamp")
-        except Exception as e:
+            # 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
             _LOGGER.warning(e)
-        return datetime.now(timezone.utc)
+        return datetime.now(UTC)
 
     @property
     def is_request_in_progress_supported(self):
@@ -2904,9 +3799,18 @@ 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
 
@@ -2914,10 +3818,18 @@ 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
@@ -2939,104 +3851,211 @@ 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.primaryEngineType")
-            and find_path(self.attrs, f"{Services.MEASUREMENTS}.fuelLevelStatus.value.primaryEngineType")
+            is_valid_path(
+                self.attrs,
+                f"{Services.MEASUREMENTS}.fuelLevelStatus.value.secondaryEngineType",
+            )
+            and find_path(
+                self.attrs,
+                f"{Services.MEASUREMENTS}.fuelLevelStatus.value.secondaryEngineType",
+            )
             == 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:
@@ -3046,7 +4065,7 @@ class Vehicle:
     @property
     def api_vehicles_status_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return datetime.now(timezone.utc)
+        return datetime.now(UTC)
 
     @property
     def is_api_vehicles_status_supported(self):
@@ -3056,12 +4075,14 @@ 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(timezone.utc)
+        return datetime.now(UTC)
 
     @property
     def is_api_capabilities_status_supported(self):
@@ -3076,7 +4097,7 @@ class Vehicle:
     @property
     def api_trips_status_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return datetime.now(timezone.utc)
+        return datetime.now(UTC)
 
     @property
     def is_api_trips_status_supported(self):
@@ -3088,12 +4109,14 @@ 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(timezone.utc)
+        return datetime.now(UTC)
 
     @property
     def is_api_selectivestatus_status_supported(self):
@@ -3103,12 +4126,14 @@ 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(timezone.utc)
+        return datetime.now(UTC)
 
     @property
     def is_api_parkingposition_status_supported(self):
@@ -3125,7 +4150,7 @@ class Vehicle:
     @property
     def api_token_status_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return datetime.now(timezone.utc)
+        return datetime.now(UTC)
 
     @property
     def is_api_token_status_supported(self):
@@ -3143,7 +4168,7 @@ class Vehicle:
     @property
     def last_data_refresh_last_updated(self) -> datetime:
         """Return attribute last updated timestamp."""
-        return datetime.now(timezone.utc)
+        return datetime.now(UTC)
 
     @property
     def is_last_data_refresh_supported(self):