volkswagencarnet 5.0.0b4__py3-none-any.whl → 5.0.1__py3-none-any.whl

volkswagencarnet/vw_dashboard.py

@@ -2,14 +2,13 @@
 
 # Thanks to molobrakos
 
-import logging
 from datetime import datetime
+import logging
 
 from .vw_const import TEMP_CELSIUS, VWDeviceClass, VWStateClass
 from .vw_utilities import camel2slug
 from .vw_vehicle import Vehicle
 
-
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -27,7 +26,7 @@ class Instrument:
         entity_type: str | None = None,
         device_class: str | None = None,
         state_class: str | None = None,
-    ):
+    ) -> None:
         """Init."""
         self.attr = attr
         self.component = component
@@ -44,7 +43,6 @@ class Instrument:
 
     def configurate(self, **args):
         """Override in subclasses."""
-        pass
 
     @property
     def slug_attr(self) -> str:
@@ -55,7 +53,9 @@ class Instrument:
         """Set up entity if supported."""
         self.vehicle = vehicle
         if not self.is_supported:
-            _LOGGER.debug("%s (%s:%s) is not supported", self, type(self).__name__, self.attr)
+            _LOGGER.debug(
+                "%s (%s:%s) is not supported", self, type(self).__name__, self.attr
+            )
             return False
 
         _LOGGER.debug("%s is supported", self)
@@ -87,8 +87,7 @@ class Instrument:
         """Return current state."""
         if hasattr(self.vehicle, self.attr):
             return getattr(self.vehicle, self.attr)
-        else:
-            _LOGGER.debug(f'Could not find attribute "{self.attr}"')
+        _LOGGER.debug('Could not find attribute "%s"', self.attr)
         return self.vehicle.get_attr(self.attr)
 
     @property
@@ -102,16 +101,20 @@ class Instrument:
         supported = "is_" + self.attr + "_supported"
         if hasattr(self.vehicle, supported):
             return getattr(self.vehicle, supported)
-        else:
-            return False
+        return False
 
     @property
     def last_refresh(self) -> datetime | None:
+        """Return last_updated attribute."""
         if hasattr(self.vehicle, self.attr + "_last_updated"):
             return getattr(self.vehicle, self.attr + "_last_updated")
-        _LOGGER.warning(f"Implement in subclasses. {self.__class__}:{self.attr}_last_updated")
+        _LOGGER.warning(
+            "Implement in subclasses. %s:%s_last_updated", self.__class__, self.attr
+        )
         if self.state_class is not None:
-            raise NotImplementedError(f"Implement in subclasses. {self.__class__}:{self.attr}_last_updated")
+            raise NotImplementedError(
+                f"Implement in subclasses. {self.__class__}:{self.attr}_last_updated"
+            )
         return None
 
 
@@ -127,7 +130,7 @@ class Sensor(Instrument):
         entity_type: str | None = None,
         device_class: str | None = None,
         state_class: str | None = None,
-    ):
+    ) -> None:
         """Init."""
         super().__init__(
             component="sensor",
@@ -142,72 +145,90 @@ class Sensor(Instrument):
         self.convert = False
 
     def configurate(self, miles=False, scandinavian_miles=False, **config):
+        """Configure unit conversion."""
         if self.unit and miles:
-            if "km" == self.unit:
+            if self.unit == "km":
                 self.unit = "mi"
                 self.convert = True
-            elif "km/h" == self.unit:
+            elif self.unit == "km/h":
                 self.unit = "mi/h"
                 self.convert = True
-            elif "l/100 km" == self.unit:
+            elif self.unit == "l/100 km":
                 self.unit = "l/100 mi"
                 self.convert = True
-            elif "kWh/100 km" == self.unit:
+            elif self.unit == "kWh/100 km":
                 self.unit = "kWh/100 mi"
                 self.convert = True
         elif self.unit and scandinavian_miles:
-            if "km" == self.unit:
+            if self.unit == "km":
                 self.unit = "mil"
-            elif "km/h" == self.unit:
+            elif self.unit == "km/h":
                 self.unit = "mil/h"
-            elif "l/100 km" == self.unit:
+            elif self.unit == "l/100 km":
                 self.unit = "l/100 mil"
-            elif "kWh/100 km" == self.unit:
+            elif self.unit == "kWh/100 km":
                 self.unit = "kWh/100 mil"
 
     @property
     def is_mutable(self):
+        """Return boolean is_mutable."""
         return False
 
     @property
     def str_state(self):
+        """Return current state as string."""
         if self.unit:
             return f"{self.state} {self.unit}"
-        else:
-            return f"{self.state}"
+        return f"{self.state}"
 
     @property
     def state(self):
+        """Return current state."""
+        # Base value
         val = super().state
-        if val and self.unit and "mi" in self.unit and self.convert is True:
-            return round(int(val) * 0.6213712)
-        elif val and self.unit and "mi/h" in self.unit and self.convert is True:
-            return round(int(val) * 0.6213712)
-        elif val and self.unit and "gal/100 mi" in self.unit and self.convert is True:
-            return round(val * 0.4251438, 1)
-        elif val and self.unit and "kWh/100 mi" in self.unit and self.convert is True:
-            return round(val * 0.4251438, 1)
-        elif val and self.unit and "°F" in self.unit and self.convert is True:
-            temp = round((val * 9 / 5) + 32, 1)
-            return temp
-        elif val and self.unit in ["mil", "mil/h"]:
-            return val / 10
-        else:
+        # If the base value is not valid or convert is not true, return the original value
+        if not val or not self.convert:
             return val
+        # Simplified condition checking
+        if self.unit:
+            if "mi" in self.unit:
+                if self.unit in ["mi", "mi/h"]:
+                    return round(int(val) * 0.6213712)
+            if "gal/100 mi" in self.unit or "kWh/100 mi" in self.unit:
+                return round(val * 0.4251438, 1)
+            if "°F" in self.unit:
+                return round((val * 9 / 5) + 32, 1)
+            if self.unit in ["mil", "mil/h"]:
+                return val / 10
+        # Default case, return the unmodified value
+        return val
 
 
 class BinarySensor(Instrument):
-    def __init__(self, attr, name, device_class, icon="", entity_type=None, reverse_state=False):
-        super().__init__(component="binary_sensor", attr=attr, name=name, icon=icon, entity_type=entity_type)
+    """BinarySensor instrument."""
+
+    def __init__(
+        self, attr, name, device_class, icon="", entity_type=None, reverse_state=False
+    ) -> None:
+        """Init."""
+        super().__init__(
+            component="binary_sensor",
+            attr=attr,
+            name=name,
+            icon=icon,
+            entity_type=entity_type,
+        )
         self.device_class = device_class
         self.reverse_state = reverse_state
 
     @property
     def is_mutable(self):
+        """Return boolean is_mutable."""
         return False
 
     @property
     def str_state(self):
+        """Return current state as string."""
         if self.device_class in [VWDeviceClass.DOOR, VWDeviceClass.WINDOW]:
             return "Open" if self.state else "Closed"
         if self.device_class == VWDeviceClass.LOCK:
@@ -223,47 +244,53 @@ class BinarySensor(Instrument):
 
     @property
     def state(self):
+        """Return current state."""
         val = super().state
 
         if isinstance(val, (bool, list)):
             if self.reverse_state:
                 if bool(val):
                     return False
-                else:
-                    return True
-            else:
-                return bool(val)
-        elif isinstance(val, str):
+                return True
+            return bool(val)
+        if isinstance(val, str):
             return val != "Normal"
         return val
 
     @property
     def is_on(self):
+        """Return state."""
         return self.state
 
 
 class Switch(Instrument):
     """Switch instrument."""
 
-    def __init__(self, attr, name, icon, entity_type=None):
-        super().__init__(component="switch", attr=attr, name=name, icon=icon, entity_type=entity_type)
+    def __init__(self, attr, name, icon, entity_type=None) -> None:
+        """Init."""
+        super().__init__(
+            component="switch", attr=attr, name=name, icon=icon, entity_type=entity_type
+        )
 
     @property
     def is_mutable(self):
+        """Return boolean is_mutable."""
         return True
 
     @property
     def str_state(self):
+        """Return current state as string."""
         return "On" if self.state else "Off"
 
     def is_on(self):
+        """Return state."""
         return self.state
 
     def turn_on(self):
-        pass
+        """Turn on."""
 
     def turn_off(self):
-        pass
+        """Turn off."""
 
     @property
     def assumed_state(self) -> bool:
@@ -272,6 +299,8 @@ class Switch(Instrument):
 
 
 class Number(Instrument):
+    """Number instrument."""
+
     def __init__(
         self,
         attr: str,
@@ -281,7 +310,7 @@ class Number(Instrument):
         entity_type: str | None = None,
         device_class: str | None = None,
         state_class: str | None = None,
-    ):
+    ) -> None:
         """Init."""
         super().__init__(
             component="number",
@@ -296,35 +325,91 @@ class Number(Instrument):
 
     @property
     def is_mutable(self):
+        """Return boolean is_mutable."""
         return False
 
     @property
     def state(self):
+        """Return current state."""
         raise NotImplementedError
 
     @property
     def min_value(self):
+        """Return min value."""
         raise NotImplementedError
 
     @property
     def max_value(self):
+        """Return max value."""
         raise NotImplementedError
 
     @property
     def native_step(self):
+        """Return native step."""
+        raise NotImplementedError
+
+
+class Select(Instrument):
+    """Select instrument."""
+
+    def __init__(
+        self,
+        attr: str,
+        name: str,
+        icon: str | None,
+        unit: str | None,
+        entity_type: str | None = None,
+        device_class: str | None = None,
+        state_class: str | None = None,
+    ) -> None:
+        """Init."""
+        super().__init__(
+            component="select",
+            attr=attr,
+            name=name,
+            icon=icon,
+            entity_type=entity_type,
+            device_class=device_class,
+            state_class=state_class,
+        )
+        self.unit = unit
+
+    @property
+    def is_mutable(self):
+        """Return boolean is_mutable."""
+        return False
+
+    @property
+    def state(self):
+        """Return current state."""
+        raise NotImplementedError
+
+    @property
+    def current_option(self):
+        """Return current option."""
+        raise NotImplementedError
+
+    @property
+    def options(self):
+        """Return options."""
         raise NotImplementedError
 
 
 class Position(Instrument):
-    def __init__(self):
+    """Position instrument."""
+
+    def __init__(self) -> None:
+        """Init."""
         super().__init__(component="device_tracker", attr="position", name="Position")
 
     @property
     def is_mutable(self):
+        """Return boolean is_mutable."""
         return False
 
     @property
     def state(self):
+        """Return current state."""
         state = super().state  # or {}
         return (
             state.get("lat", "?"),
@@ -334,6 +419,7 @@ class Position(Instrument):
 
     @property
     def str_state(self):
+        """Return current state as string."""
         state = super().state  # or {}
         ts = state.get("timestamp", None)
         return (
@@ -344,81 +430,106 @@ class Position(Instrument):
 
 
 class DoorLock(Instrument):
-    def __init__(self):
-        super().__init__(component=VWDeviceClass.LOCK, attr="door_locked", name="Door locked")
+    """DoorLock instrument."""
+
+    def __init__(self) -> None:
+        """Init."""
+        super().__init__(
+            component=VWDeviceClass.LOCK, attr="door_locked", name="Door locked"
+        )
         self.spin = ""
 
     def configurate(self, **config):
+        """Configure spin."""
         self.spin = config.get("spin", "")
 
     @property
     def is_mutable(self):
+        """Return boolean is_mutable."""
         return True
 
     @property
     def str_state(self):
+        """Return current state as string."""
         return "Locked" if self.state else "Unlocked"
 
     @property
     def state(self):
+        """Return current state."""
         return self.vehicle.door_locked
 
     @property
     def is_locked(self):
+        """Return current state."""
         return self.state
 
     async def lock(self):
+        """Trigger Lock."""
         try:
             response = await self.vehicle.set_lock(VWDeviceClass.LOCK, self.spin)
             await self.vehicle.update()
             if self.callback is not None:
                 self.callback()
-            return response
-        except Exception as e:
-            _LOGGER.error("Lock failed: %", e.args[0])
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            _LOGGER.error("Lock failed: %s", e.args[0])
             return False
+        else:
+            return response
 
     async def unlock(self):
+        """Trigger Unlock."""
         try:
             response = await self.vehicle.set_lock("unlock", self.spin)
             await self.vehicle.update()
             if self.callback is not None:
                 self.callback()
-            return response
-        except Exception as e:
-            _LOGGER.error("Unlock failed: %", e.args[0])
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            _LOGGER.error("Unlock failed: %s", e.args[0])
             return False
+        else:
+            return response
 
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return dict(last_result=self.vehicle.lock_action_status)
+        return {"last_result": self.vehicle.lock_action_status}
 
 
 class TrunkLock(Instrument):
-    def __init__(self):
-        super().__init__(component=VWDeviceClass.LOCK, attr="trunk_locked", name="Trunk locked")
+    """TrunkLock instrument."""
+
+    def __init__(self) -> None:
+        """Init."""
+        super().__init__(
+            component=VWDeviceClass.LOCK, attr="trunk_locked", name="Trunk locked"
+        )
 
     @property
     def is_mutable(self):
+        """Return boolean is_mutable."""
         return True
 
     @property
     def str_state(self):
+        """Return current state as string."""
         return "Locked" if self.state else "Unlocked"
 
     @property
     def state(self):
+        """Return current state."""
         return self.vehicle.trunk_locked
 
     @property
     def is_locked(self):
+        """Return current state."""
         return self.state
 
     async def lock(self):
+        """Trigger lock."""
         return None
 
     async def unlock(self):
+        """Trigger unlock."""
         return None
 
 
@@ -428,7 +539,8 @@ class TrunkLock(Instrument):
 class AuxiliaryDuration(Number):
     """Currently disabled due to the lack of auxiliary settings API."""
 
-    def __init__(self):
+    def __init__(self) -> None:
+        """Init."""
         super().__init__(
             attr="auxiliary_duration",
             name="Auxiliary duration",
@@ -439,37 +551,45 @@ class AuxiliaryDuration(Number):
         self.spin = ""
 
     def configurate(self, **config):
+        """Configure spin."""
         self.spin = config.get("spin", "")
 
     @property
     def state(self):
+        """Return current state."""
         return self.vehicle.auxiliary_duration
 
     async def set_value(self, minutes: int):
+        """Set value."""
         await self.vehicle.set_auxiliary_duration(minutes, self.spin)
         await self.vehicle.update()
 
     @property
     def min_value(self):
+        """Return min value."""
         return 5
 
     @property
     def max_value(self):
+        """Return max value."""
         return 30
 
     @property
     def native_step(self):
+        """Return native step."""
         return 5
 
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return dict(last_result=self.vehicle.climater_action_status)
+        return {"last_result": self.vehicle.climater_action_status}
 
 
 class BatteryTargetSOC(Number):
+    """Battery target charge level."""
 
-    def __init__(self):
+    def __init__(self) -> None:
+        """Init."""
         super().__init__(
             attr="battery_target_charge_level",
             name="Battery target charge level",
@@ -480,33 +600,42 @@ class BatteryTargetSOC(Number):
 
     @property
     def state(self):
+        """Return current state."""
         return self.vehicle.battery_target_charge_level
 
     async def set_value(self, value: int):
-        await self.vehicle.set_charging_settings(setting="battery_target_charge_level", value=value)
+        """Set value."""
+        await self.vehicle.set_charging_settings(
+            setting="battery_target_charge_level", value=value
+        )
         await self.vehicle.update()
 
     @property
     def min_value(self):
+        """Return min value."""
         return 50
 
     @property
     def max_value(self):
+        """Return max value."""
         return 100
 
     @property
     def native_step(self):
+        """Return native step."""
         return 10
 
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return dict(last_result=self.vehicle.charger_action_status)
+        return {"last_result": self.vehicle.charger_action_status}
 
 
 class ClimatisationTargetTemperature(Number):
+    """Climatisation target temperature."""
 
-    def __init__(self):
+    def __init__(self) -> None:
+        """Init."""
         super().__init__(
             attr="climatisation_target_temperature",
             name="Climatisation target temperature",
@@ -517,49 +646,102 @@ class ClimatisationTargetTemperature(Number):
 
     @property
     def state(self):
+        """Return current state."""
         return self.vehicle.climatisation_target_temperature
 
     async def set_value(self, value: float):
-        await self.vehicle.set_climatisation_settings(setting="climatisation_target_temperature", value=value)
+        """Set value."""
+        await self.vehicle.set_climatisation_settings(
+            setting="climatisation_target_temperature", value=value
+        )
         await self.vehicle.update()
 
     @property
     def min_value(self):
+        """Return min value."""
         return 15.5
 
     @property
     def max_value(self):
+        """Return max value."""
         return 30
 
     @property
     def native_step(self):
+        """Return native step."""
         return 0.5
 
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return dict(last_result=self.vehicle.climater_action_status)
+        return {"last_result": self.vehicle.climater_action_status}
+
+
+# Select
+
+
+class ChargeMaxACAmpere(Select):
+    """Maximum charge ampere."""
+
+    def __init__(self) -> None:
+        """Init."""
+        super().__init__(
+            attr="charge_max_ac_ampere",
+            name="Charger max AC ampere",
+            icon="mdi:flash-auto",
+            unit="A",
+            entity_type="config",
+        )
+
+    @property
+    def state(self):
+        """Return current state."""
+        return self.vehicle.charge_max_ac_ampere
+
+    @property
+    def current_option(self):
+        """Return current option."""
+        return str(self.vehicle.charge_max_ac_ampere)
+
+    @property
+    def options(self) -> dict:
+        """Return options."""
+        return ["5", "10", "13", "32"]
+
+    async def set_value(self, ampere: str):
+        """Set value."""
+        await self.vehicle.set_charging_settings(
+            setting="max_charge_amperage", value=ampere
+        )
+        await self.vehicle.update()
 
 
 # Switches
 
 
 class RequestUpdate(Switch):
-    def __init__(self):
-        super().__init__(attr="refresh_data", name="Force data refresh", icon="mdi:car-connected")
+    """Force data refresh."""
+
+    def __init__(self) -> None:
+        """Init."""
+        super().__init__(
+            attr="refresh_data", name="Force data refresh", icon="mdi:car-connected"
+        )
 
     @property
     def state(self):
+        """Return current state."""
         return self.vehicle.refresh_data
 
     async def turn_on(self):
+        """Turn on."""
         await self.vehicle.set_refresh()
         await self.vehicle.update()
         if self.callback is not None:
             self.callback()
 
     async def turn_off(self):
-        pass
+        """Turn off."""
 
     @property
     def assumed_state(self) -> bool:
@@ -569,22 +751,32 @@ class RequestUpdate(Switch):
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return dict(last_result=self.vehicle.refresh_action_status)
+        return {"last_result": self.vehicle.refresh_action_status}
 
 
 class ElectricClimatisation(Switch):
-    def __init__(self):
-        super().__init__(attr="electric_climatisation", name="Electric Climatisation", icon="mdi:air-conditioner")
+    """Electric Climatisation."""
+
+    def __init__(self) -> None:
+        """Init."""
+        super().__init__(
+            attr="electric_climatisation",
+            name="Electric Climatisation",
+            icon="mdi:air-conditioner",
+        )
 
     @property
     def state(self):
+        """Return current state."""
         return self.vehicle.electric_climatisation
 
     async def turn_on(self):
+        """Turn on."""
         await self.vehicle.set_climatisation("start")
         await self.vehicle.update()
 
     async def turn_off(self):
+        """Turn off."""
         await self.vehicle.set_climatisation("stop")
         await self.vehicle.update()
 
@@ -596,26 +788,37 @@ class ElectricClimatisation(Switch):
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return dict(last_result=self.vehicle.climater_action_status)
+        return {"last_result": self.vehicle.climater_action_status}
 
 
 class AuxiliaryClimatisation(Switch):
-    def __init__(self):
-        super().__init__(attr="auxiliary_climatisation", name="Auxiliary Climatisation", icon="mdi:radiator")
+    """Auxiliary Climatisation."""
+
+    def __init__(self) -> None:
+        """Init."""
+        super().__init__(
+            attr="auxiliary_climatisation",
+            name="Auxiliary Climatisation",
+            icon="mdi:radiator",
+        )
         self.spin = ""
 
     def configurate(self, **config):
+        """Configure spin."""
         self.spin = config.get("spin", "")
 
     @property
     def state(self):
+        """Return current state."""
         return self.vehicle.auxiliary_climatisation
 
     async def turn_on(self):
+        """Turn on."""
         await self.vehicle.set_auxiliary_climatisation("start", self.spin)
         await self.vehicle.update()
 
     async def turn_off(self):
+        """Turn off."""
         await self.vehicle.set_auxiliary_climatisation("stop", self.spin)
         await self.vehicle.update()
 
@@ -627,22 +830,28 @@ class AuxiliaryClimatisation(Switch):
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return dict(last_result=self.vehicle.climater_action_status)
+        return {"last_result": self.vehicle.climater_action_status}
 
 
 class Charging(Switch):
-    def __init__(self):
+    """Charging."""
+
+    def __init__(self) -> None:
+        """Init."""
         super().__init__(attr="charging", name="Charging", icon="mdi:battery")
 
     @property
     def state(self):
+        """Return current state."""
         return self.vehicle.charging
 
     async def turn_on(self):
+        """Turn on."""
         await self.vehicle.set_charger("start")
         await self.vehicle.update()
 
     async def turn_off(self):
+        """Turn off."""
         await self.vehicle.set_charger("stop")
         await self.vehicle.update()
 
@@ -654,25 +863,38 @@ class Charging(Switch):
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return dict(last_result=self.vehicle.charger_action_status)
+        return {"last_result": self.vehicle.charger_action_status}
 
 
 class ReducedACCharging(Switch):
-    def __init__(self):
+    """Reduced AC Charging."""
+
+    def __init__(self) -> None:
+        """Init."""
         super().__init__(
-            attr="reduced_ac_charging", name="Reduced AC Charging", icon="mdi:ev-station", entity_type="config"
+            attr="reduced_ac_charging",
+            name="Reduced AC Charging",
+            icon="mdi:ev-station",
+            entity_type="config",
         )
 
     @property
     def state(self):
+        """Return current state."""
         return self.vehicle.reduced_ac_charging
 
     async def turn_on(self):
-        await self.vehicle.set_charging_settings(setting="reduced_ac_charging", value="reduced")
+        """Turn on."""
+        await self.vehicle.set_charging_settings(
+            setting="reduced_ac_charging", value="reduced"
+        )
         await self.vehicle.update()
 
     async def turn_off(self):
-        await self.vehicle.set_charging_settings(setting="reduced_ac_charging", value="maximum")
+        """Turn off."""
+        await self.vehicle.set_charging_settings(
+            setting="reduced_ac_charging", value="maximum"
+        )
         await self.vehicle.update()
 
     @property
@@ -683,11 +905,14 @@ class ReducedACCharging(Switch):
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return dict(last_result=self.vehicle.charger_action_status)
+        return {"last_result": self.vehicle.charger_action_status}
 
 
 class AutoReleaseACConnector(Switch):
-    def __init__(self):
+    """Auto-release AC connector."""
+
+    def __init__(self) -> None:
+        """Init."""
         super().__init__(
             attr="auto_release_ac_connector",
             name="Auto-release AC connector",
@@ -697,14 +922,21 @@ class AutoReleaseACConnector(Switch):
 
     @property
     def state(self):
+        """Return current state."""
         return self.vehicle.auto_release_ac_connector
 
     async def turn_on(self):
-        await self.vehicle.set_charging_settings(setting="auto_release_ac_connector", value="permanent")
+        """Turn on."""
+        await self.vehicle.set_charging_settings(
+            setting="auto_release_ac_connector", value="permanent"
+        )
         await self.vehicle.update()
 
     async def turn_off(self):
-        await self.vehicle.set_charging_settings(setting="auto_release_ac_connector", value="off")
+        """Turn off."""
+        await self.vehicle.set_charging_settings(
+            setting="auto_release_ac_connector", value="off"
+        )
         await self.vehicle.update()
 
     @property
@@ -714,7 +946,10 @@ class AutoReleaseACConnector(Switch):
 
 
 class BatteryCareMode(Switch):
-    def __init__(self):
+    """Battery care mode."""
+
+    def __init__(self) -> None:
+        """Init."""
         super().__init__(
             attr="battery_care_mode",
             name="Battery care mode",
@@ -724,13 +959,16 @@ class BatteryCareMode(Switch):
 
     @property
     def state(self):
+        """Return current state."""
         return self.vehicle.battery_care_mode
 
     async def turn_on(self):
+        """Turn on."""
         await self.vehicle.set_charging_care_settings(value="activated")
         await self.vehicle.update()
 
     async def turn_off(self):
+        """Turn off."""
         await self.vehicle.set_charging_care_settings(value="deactivated")
         await self.vehicle.update()
 
@@ -742,11 +980,14 @@ class BatteryCareMode(Switch):
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return dict(last_result=self.vehicle.charger_action_status)
+        return {"last_result": self.vehicle.charger_action_status}
 
 
 class OptimisedBatteryUse(Switch):
-    def __init__(self):
+    """Optimised battery use."""
+
+    def __init__(self) -> None:
+        """Init."""
         super().__init__(
             attr="optimised_battery_use",
             name="Optimised battery use",
@@ -756,13 +997,16 @@ class OptimisedBatteryUse(Switch):
 
     @property
     def state(self):
+        """Return current state."""
         return self.vehicle.optimised_battery_use
 
     async def turn_on(self):
+        """Turn on."""
         await self.vehicle.set_readiness_battery_support(value=True)
         await self.vehicle.update()
 
     async def turn_off(self):
+        """Turn off."""
         await self.vehicle.set_readiness_battery_support(value=False)
         await self.vehicle.update()
 
@@ -774,20 +1018,25 @@ class OptimisedBatteryUse(Switch):
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return dict(last_result=self.vehicle.charger_action_status)
+        return {"last_result": self.vehicle.charger_action_status}
 
 
 class DepartureTimer(Switch):
     """Departure timers."""
 
-    def __init__(self, id: str | int):
+    def __init__(self, id: str | int) -> None:
+        """Init."""
         self._id = id
         super().__init__(
-            attr=f"departure_timer{id}", name=f"Departure Timer {id}", icon="mdi:car-clock", entity_type="config"
+            attr=f"departure_timer{id}",
+            name=f"Departure Timer {id}",
+            icon="mdi:car-clock",
+            entity_type="config",
         )
         self.spin = ""
 
     def configurate(self, **config):
+        """Configure spin."""
         self.spin = config.get("spin", "")
 
     @property
@@ -797,12 +1046,16 @@ class DepartureTimer(Switch):
 
     async def turn_on(self):
         """Enable timer."""
-        await self.vehicle.set_departure_timer(timer_id=self._id, spin=self.spin, enable=True)
+        await self.vehicle.set_departure_timer(
+            timer_id=self._id, spin=self.spin, enable=True
+        )
         await self.vehicle.update()
 
     async def turn_off(self):
         """Disable timer."""
-        await self.vehicle.set_departure_timer(timer_id=self._id, spin=self.spin, enable=False)
+        await self.vehicle.set_departure_timer(
+            timer_id=self._id, spin=self.spin, enable=False
+        )
         await self.vehicle.update()
 
     @property
@@ -820,15 +1073,19 @@ class DepartureTimer(Switch):
 class ACDepartureTimer(Switch):
     """Air conditioning departure timers."""
 
-    def __init__(self, id: str | int):
+    def __init__(self, id: str | int) -> None:
+        """Init."""
         self._id = id
         super().__init__(
-            attr=f"ac_departure_timer{id}", name=f"AC Departure Timer {id}", icon="mdi:fan-clock", entity_type="config"
+            attr=f"ac_departure_timer{id}",
+            name=f"AC Departure Timer {id}",
+            icon="mdi:fan-clock",
+            entity_type="config",
         )
 
     @property
     def state(self):
-        """Return switch state."""
+        """Return current state."""
         return self.vehicle.ac_departure_timer_enabled(self._id)
 
     async def turn_on(self):
@@ -854,18 +1111,26 @@ class ACDepartureTimer(Switch):
 
 
 class WindowHeater(Switch):
-    def __init__(self):
-        super().__init__(attr="window_heater", name="Window Heater", icon="mdi:car-defrost-rear")
+    """Window Heater."""
+
+    def __init__(self) -> None:
+        """Init."""
+        super().__init__(
+            attr="window_heater", name="Window Heater", icon="mdi:car-defrost-rear"
+        )
 
     @property
     def state(self):
+        """Return current state."""
         return self.vehicle.window_heater
 
     async def turn_on(self):
+        """Turn on."""
         await self.vehicle.set_window_heating("start")
         await self.vehicle.update()
 
     async def turn_off(self):
+        """Turn off."""
         await self.vehicle.set_window_heating("stop")
         await self.vehicle.update()
 
@@ -877,11 +1142,14 @@ class WindowHeater(Switch):
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return dict(last_result=self.vehicle.climater_action_status)
+        return {"last_result": self.vehicle.climater_action_status}
 
 
 class BatteryClimatisation(Switch):
-    def __init__(self):
+    """Climatisation from battery."""
+
+    def __init__(self) -> None:
+        """Init."""
         super().__init__(
             attr="climatisation_without_external_power",
             name="Climatisation from battery",
@@ -891,14 +1159,21 @@ class BatteryClimatisation(Switch):
 
     @property
     def state(self):
+        """Return current state."""
         return self.vehicle.climatisation_without_external_power
 
     async def turn_on(self):
-        await self.vehicle.set_climatisation_settings(setting="climatisation_without_external_power", value=True)
+        """Turn on."""
+        await self.vehicle.set_climatisation_settings(
+            setting="climatisation_without_external_power", value=True
+        )
         await self.vehicle.update()
 
     async def turn_off(self):
-        await self.vehicle.set_climatisation_settings(setting="climatisation_without_external_power", value=False)
+        """Turn off."""
+        await self.vehicle.set_climatisation_settings(
+            setting="climatisation_without_external_power", value=False
+        )
         await self.vehicle.update()
 
     @property
@@ -909,11 +1184,14 @@ class BatteryClimatisation(Switch):
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return dict(last_result=self.vehicle.climater_action_status)
+        return {"last_result": self.vehicle.climater_action_status}
 
 
 class AuxiliaryAC(Switch):
-    def __init__(self):
+    """Auxiliary air conditioning."""
+
+    def __init__(self) -> None:
+        """Init."""
         super().__init__(
             attr="auxiliary_air_conditioning",
             name="Auxiliary air conditioning",
@@ -923,14 +1201,21 @@ class AuxiliaryAC(Switch):
 
     @property
     def state(self):
+        """Return current state."""
         return self.vehicle.auxiliary_air_conditioning
 
     async def turn_on(self):
-        await self.vehicle.set_climatisation_settings(setting="auxiliary_air_conditioning", value=True)
+        """Turn on."""
+        await self.vehicle.set_climatisation_settings(
+            setting="auxiliary_air_conditioning", value=True
+        )
         await self.vehicle.update()
 
     async def turn_off(self):
-        await self.vehicle.set_climatisation_settings(setting="auxiliary_air_conditioning", value=False)
+        """Turn off."""
+        await self.vehicle.set_climatisation_settings(
+            setting="auxiliary_air_conditioning", value=False
+        )
         await self.vehicle.update()
 
     @property
@@ -941,11 +1226,14 @@ class AuxiliaryAC(Switch):
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return dict(last_result=self.vehicle.climater_action_status)
+        return {"last_result": self.vehicle.climater_action_status}
 
 
 class AutomaticWindowHeating(Switch):
-    def __init__(self):
+    """Automatic window heating."""
+
+    def __init__(self) -> None:
+        """Init."""
         super().__init__(
             attr="automatic_window_heating",
             name="Automatic window heating",
@@ -955,14 +1243,21 @@ class AutomaticWindowHeating(Switch):
 
     @property
     def state(self):
+        """Return current state."""
         return self.vehicle.automatic_window_heating
 
     async def turn_on(self):
-        await self.vehicle.set_climatisation_settings(setting="automatic_window_heating", value=True)
+        """Turn on."""
+        await self.vehicle.set_climatisation_settings(
+            setting="automatic_window_heating", value=True
+        )
         await self.vehicle.update()
 
     async def turn_off(self):
-        await self.vehicle.set_climatisation_settings(setting="automatic_window_heating", value=False)
+        """Turn off."""
+        await self.vehicle.set_climatisation_settings(
+            setting="automatic_window_heating", value=False
+        )
         await self.vehicle.update()
 
     @property
@@ -973,11 +1268,14 @@ class AutomaticWindowHeating(Switch):
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return dict(last_result=self.vehicle.climater_action_status)
+        return {"last_result": self.vehicle.climater_action_status}
 
 
 class ZoneFrontLeft(Switch):
-    def __init__(self):
+    """Zone Front Left."""
+
+    def __init__(self) -> None:
+        """Init."""
         super().__init__(
             attr="zone_front_left",
             name="Zone Front Left",
@@ -987,14 +1285,21 @@ class ZoneFrontLeft(Switch):
 
     @property
     def state(self):
+        """Return current state."""
         return self.vehicle.zone_front_left
 
     async def turn_on(self):
-        await self.vehicle.set_climatisation_settings(setting="zone_front_left", value=True)
+        """Turn on."""
+        await self.vehicle.set_climatisation_settings(
+            setting="zone_front_left", value=True
+        )
         await self.vehicle.update()
 
     async def turn_off(self):
-        await self.vehicle.set_climatisation_settings(setting="zone_front_left", value=False)
+        """Turn off."""
+        await self.vehicle.set_climatisation_settings(
+            setting="zone_front_left", value=False
+        )
         await self.vehicle.update()
 
     @property
@@ -1005,11 +1310,14 @@ class ZoneFrontLeft(Switch):
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return dict(last_result=self.vehicle.climater_action_status)
+        return {"last_result": self.vehicle.climater_action_status}
 
 
 class ZoneFrontRight(Switch):
-    def __init__(self):
+    """Zone Front Right."""
+
+    def __init__(self) -> None:
+        """Init."""
         super().__init__(
             attr="zone_front_right",
             name="Zone Front Right",
@@ -1019,14 +1327,21 @@ class ZoneFrontRight(Switch):
 
     @property
     def state(self):
+        """Return current state."""
         return self.vehicle.zone_front_right
 
     async def turn_on(self):
-        await self.vehicle.set_climatisation_settings(setting="zone_front_right", value=True)
+        """Turn on."""
+        await self.vehicle.set_climatisation_settings(
+            setting="zone_front_right", value=True
+        )
         await self.vehicle.update()
 
     async def turn_off(self):
-        await self.vehicle.set_climatisation_settings(setting="zone_front_right", value=False)
+        """Turn off."""
+        await self.vehicle.set_climatisation_settings(
+            setting="zone_front_right", value=False
+        )
         await self.vehicle.update()
 
     @property
@@ -1037,16 +1352,20 @@ class ZoneFrontRight(Switch):
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return dict(last_result=self.vehicle.climater_action_status)
+        return {"last_result": self.vehicle.climater_action_status}
 
 
 class RequestResults(Sensor):
     """Request results sensor class."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Init."""
         super().__init__(
-            attr="request_results", name="Request results", icon="mdi:chat-alert", unit="", entity_type="diag"
+            attr="request_results",
+            name="Request results",
+            icon="mdi:chat-alert",
+            unit="",
+            entity_type="diag",
         )
 
     @property
@@ -1076,6 +1395,7 @@ def create_instruments():
         ClimatisationTargetTemperature(),
         DoorLock(),
         TrunkLock(),
+        ChargeMaxACAmpere(),
         RequestUpdate(),
         WindowHeater(),
         BatteryClimatisation(),
@@ -1117,6 +1437,18 @@ def create_instruments():
             icon="mdi:battery-arrow-up",
             unit="%",
         ),
+        Sensor(
+            attr="hv_battery_min_temperature",
+            name="HV battery min temperature",
+            icon="mdi:thermometer-chevron-down",
+            unit=TEMP_CELSIUS,
+        ),
+        Sensor(
+            attr="hv_battery_max_temperature",
+            name="HV battery max temperature",
+            icon="mdi:thermometer-chevron-up",
+            unit=TEMP_CELSIUS,
+        ),
         Sensor(
             attr="adblue_level",
             name="Adblue level",
@@ -1129,6 +1461,12 @@ def create_instruments():
             icon="mdi:fuel",
             unit="%",
         ),
+        Sensor(
+            attr="gas_level",
+            name="Gas level",
+            icon="mdi:gas-cylinder",
+            unit="%",
+        ),
         Sensor(
             attr="service_inspection",
             name="Service inspection days",
@@ -1187,6 +1525,18 @@ def create_instruments():
             icon="mdi:car",
             unit="km",
         ),
+        Sensor(
+            attr="fuel_range",
+            name="Fuel range",
+            icon="mdi:car",
+            unit="km",
+        ),
+        Sensor(
+            attr="gas_range",
+            name="Gas range",
+            icon="mdi:car",
+            unit="km",
+        ),
         Sensor(
             attr="combined_range",
             name="Combined range",
@@ -1258,6 +1608,13 @@ def create_instruments():
             unit="l/100 km",
             state_class=VWStateClass.MEASUREMENT,
         ),
+        Sensor(
+            attr="trip_last_average_gas_consumption",
+            name="Last trip average gas consumption",
+            icon="mdi:gas-cylinder",
+            unit="m3/100km",
+            state_class=VWStateClass.MEASUREMENT,
+        ),
         Sensor(
             attr="trip_last_duration",
             name="Last trip duration",
@@ -1381,14 +1738,31 @@ def create_instruments():
             device_class=VWDeviceClass.TIMESTAMP,
             entity_type="diag",
         ),
-        BinarySensor(attr="external_power", name="External power", device_class=VWDeviceClass.POWER),
-        BinarySensor(attr="energy_flow", name="Energy flow", device_class=VWDeviceClass.POWER),
         BinarySensor(
-            attr="parking_light", name="Parking light", device_class=VWDeviceClass.LIGHT, icon="mdi:car-parking-lights"
+            attr="external_power",
+            name="External power",
+            device_class=VWDeviceClass.POWER,
         ),
-        BinarySensor(attr="door_locked", name="Doors locked", device_class=VWDeviceClass.LOCK, reverse_state=True),
         BinarySensor(
-            attr="door_locked_sensor", name="Doors locked", device_class=VWDeviceClass.LOCK, reverse_state=True
+            attr="energy_flow", name="Energy flow", device_class=VWDeviceClass.POWER
+        ),
+        BinarySensor(
+            attr="parking_light",
+            name="Parking light",
+            device_class=VWDeviceClass.LIGHT,
+            icon="mdi:car-parking-lights",
+        ),
+        BinarySensor(
+            attr="door_locked",
+            name="Doors locked",
+            device_class=VWDeviceClass.LOCK,
+            reverse_state=True,
+        ),
+        BinarySensor(
+            attr="door_locked_sensor",
+            name="Doors locked",
+            device_class=VWDeviceClass.LOCK,
+            reverse_state=True,
         ),
         BinarySensor(
             attr="door_closed_left_front",
@@ -1418,12 +1792,30 @@ def create_instruments():
             reverse_state=True,
             icon="mdi:car-door",
         ),
-        BinarySensor(attr="trunk_locked", name="Trunk locked", device_class=VWDeviceClass.LOCK, reverse_state=True),
         BinarySensor(
-            attr="trunk_locked_sensor", name="Trunk locked", device_class=VWDeviceClass.LOCK, reverse_state=True
+            attr="trunk_locked",
+            name="Trunk locked",
+            device_class=VWDeviceClass.LOCK,
+            reverse_state=True,
+        ),
+        BinarySensor(
+            attr="trunk_locked_sensor",
+            name="Trunk locked",
+            device_class=VWDeviceClass.LOCK,
+            reverse_state=True,
+        ),
+        BinarySensor(
+            attr="trunk_closed",
+            name="Trunk closed",
+            device_class=VWDeviceClass.DOOR,
+            reverse_state=True,
+        ),
+        BinarySensor(
+            attr="hood_closed",
+            name="Hood closed",
+            device_class=VWDeviceClass.DOOR,
+            reverse_state=True,
         ),
-        BinarySensor(attr="trunk_closed", name="Trunk closed", device_class=VWDeviceClass.DOOR, reverse_state=True),
-        BinarySensor(attr="hood_closed", name="Hood closed", device_class=VWDeviceClass.DOOR, reverse_state=True),
         BinarySensor(
             attr="charging_cable_connected",
             name="Charging cable connected",
@@ -1437,7 +1829,10 @@ def create_instruments():
             reverse_state=True,
         ),
         BinarySensor(
-            attr="sunroof_closed", name="Sunroof closed", device_class=VWDeviceClass.WINDOW, reverse_state=True
+            attr="sunroof_closed",
+            name="Sunroof closed",
+            device_class=VWDeviceClass.WINDOW,
+            reverse_state=True,
         ),
         BinarySensor(
             attr="sunroof_rear_closed",
@@ -1446,10 +1841,16 @@ def create_instruments():
             reverse_state=True,
         ),
         BinarySensor(
-            attr="roof_cover_closed", name="Roof cover closed", device_class=VWDeviceClass.WINDOW, reverse_state=True
+            attr="roof_cover_closed",
+            name="Roof cover closed",
+            device_class=VWDeviceClass.WINDOW,
+            reverse_state=True,
         ),
         BinarySensor(
-            attr="windows_closed", name="Windows closed", device_class=VWDeviceClass.WINDOW, reverse_state=True
+            attr="windows_closed",
+            name="Windows closed",
+            device_class=VWDeviceClass.WINDOW,
+            reverse_state=True,
         ),
         BinarySensor(
             attr="window_closed_left_front",
@@ -1475,7 +1876,11 @@ def create_instruments():
             device_class=VWDeviceClass.WINDOW,
             reverse_state=True,
         ),
-        BinarySensor(attr="vehicle_moving", name="Vehicle Moving", device_class=VWDeviceClass.MOVING),
+        BinarySensor(
+            attr="vehicle_moving",
+            name="Vehicle Moving",
+            device_class=VWDeviceClass.MOVING,
+        ),
         BinarySensor(
             attr="request_in_progress",
             name="Request in progress",
@@ -1488,7 +1893,11 @@ def create_instruments():
 class Dashboard:
     """Helper for accessing the instruments."""
 
-    def __init__(self, vehicle, **config):
+    def __init__(self, vehicle, **config) -> None:
         """Initialize instruments."""
         _LOGGER.debug("Setting up dashboard with config :%s", config)
-        self.instruments = [instrument for instrument in create_instruments() if instrument.setup(vehicle, **config)]
+        self.instruments = [
+            instrument
+            for instrument in create_instruments()
+            if instrument.setup(vehicle, **config)
+        ]