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

volkswagencarnet/vw_dashboard.py

@@ -2,13 +2,14 @@
 
 # Thanks to molobrakos
 
-from datetime import datetime
 import logging
+from datetime import datetime
 
 from .vw_const import TEMP_CELSIUS, VWDeviceClass, VWStateClass
 from .vw_utilities import camel2slug
 from .vw_vehicle import Vehicle
 
+
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -26,7 +27,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
@@ -43,6 +44,7 @@ class Instrument:
 
     def configurate(self, **args):
         """Override in subclasses."""
+        pass
 
     @property
     def slug_attr(self) -> str:
@@ -53,9 +55,7 @@ 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,7 +87,8 @@ class Instrument:
         """Return current state."""
         if hasattr(self.vehicle, self.attr):
             return getattr(self.vehicle, self.attr)
-        _LOGGER.debug('Could not find attribute "%s"', self.attr)
+        else:
+            _LOGGER.debug(f'Could not find attribute "{self.attr}"')
         return self.vehicle.get_attr(self.attr)
 
     @property
@@ -101,20 +102,16 @@ class Instrument:
         supported = "is_" + self.attr + "_supported"
         if hasattr(self.vehicle, supported):
             return getattr(self.vehicle, supported)
-        return False
+        else:
+            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(
-            "Implement in subclasses. %s:%s_last_updated", self.__class__, self.attr
-        )
+        _LOGGER.warning(f"Implement in subclasses. {self.__class__}:{self.attr}_last_updated")
         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
 
 
@@ -130,7 +127,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",
@@ -145,90 +142,72 @@ class Sensor(Instrument):
         self.convert = False
 
     def configurate(self, miles=False, scandinavian_miles=False, **config):
-        """Configure unit conversion."""
         if self.unit and miles:
-            if self.unit == "km":
+            if "km" == self.unit:
                 self.unit = "mi"
                 self.convert = True
-            elif self.unit == "km/h":
+            elif "km/h" == self.unit:
                 self.unit = "mi/h"
                 self.convert = True
-            elif self.unit == "l/100 km":
+            elif "l/100 km" == self.unit:
                 self.unit = "l/100 mi"
                 self.convert = True
-            elif self.unit == "kWh/100 km":
+            elif "kWh/100 km" == self.unit:
                 self.unit = "kWh/100 mi"
                 self.convert = True
         elif self.unit and scandinavian_miles:
-            if self.unit == "km":
+            if "km" == self.unit:
                 self.unit = "mil"
-            elif self.unit == "km/h":
+            elif "km/h" == self.unit:
                 self.unit = "mil/h"
-            elif self.unit == "l/100 km":
+            elif "l/100 km" == self.unit:
                 self.unit = "l/100 mil"
-            elif self.unit == "kWh/100 km":
+            elif "kWh/100 km" == self.unit:
                 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}"
-        return f"{self.state}"
+        else:
+            return f"{self.state}"
 
     @property
     def state(self):
-        """Return current state."""
-        # Base value
         val = super().state
-        # If the base value is not valid or convert is not true, return the original value
-        if not val or not self.convert:
+        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:
             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):
-    """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,
-        )
+    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)
         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:
@@ -244,53 +223,47 @@ 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
-                return True
-            return bool(val)
-        if isinstance(val, str):
+                else:
+                    return True
+            else:
+                return bool(val)
+        elif 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) -> None:
-        """Init."""
-        super().__init__(
-            component="switch", attr=attr, name=name, icon=icon, entity_type=entity_type
-        )
+    def __init__(self, attr, name, icon, entity_type=None):
+        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):
-        """Turn on."""
+        pass
 
     def turn_off(self):
-        """Turn off."""
+        pass
 
     @property
     def assumed_state(self) -> bool:
@@ -299,8 +272,6 @@ class Switch(Instrument):
 
 
 class Number(Instrument):
-    """Number instrument."""
-
     def __init__(
         self,
         attr: str,
@@ -310,7 +281,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",
@@ -325,45 +296,35 @@ 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 Position(Instrument):
-    """Position instrument."""
-
-    def __init__(self) -> None:
-        """Init."""
+    def __init__(self):
         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", "?"),
@@ -373,7 +334,6 @@ class Position(Instrument):
 
     @property
     def str_state(self):
-        """Return current state as string."""
         state = super().state  # or {}
         ts = state.get("timestamp", None)
         return (
@@ -384,106 +344,81 @@ class Position(Instrument):
 
 
 class DoorLock(Instrument):
-    """DoorLock instrument."""
-
-    def __init__(self) -> None:
-        """Init."""
-        super().__init__(
-            component=VWDeviceClass.LOCK, attr="door_locked", name="Door locked"
-        )
+    def __init__(self):
+        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()
-        except Exception as e:  # pylint: disable=broad-exception-caught
-            _LOGGER.error("Lock failed: %s", e.args[0])
-            return False
-        else:
             return response
+        except Exception as e:
+            _LOGGER.error("Lock failed: %", e.args[0])
+            return False
 
     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()
-        except Exception as e:  # pylint: disable=broad-exception-caught
-            _LOGGER.error("Unlock failed: %s", e.args[0])
-            return False
-        else:
             return response
+        except Exception as e:
+            _LOGGER.error("Unlock failed: %", e.args[0])
+            return False
 
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return {"last_result": self.vehicle.lock_action_status}
+        return dict(last_result=self.vehicle.lock_action_status)
 
 
 class TrunkLock(Instrument):
-    """TrunkLock instrument."""
-
-    def __init__(self) -> None:
-        """Init."""
-        super().__init__(
-            component=VWDeviceClass.LOCK, attr="trunk_locked", name="Trunk locked"
-        )
+    def __init__(self):
+        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
 
 
@@ -493,8 +428,7 @@ class TrunkLock(Instrument):
 class AuxiliaryDuration(Number):
     """Currently disabled due to the lack of auxiliary settings API."""
 
-    def __init__(self) -> None:
-        """Init."""
+    def __init__(self):
         super().__init__(
             attr="auxiliary_duration",
             name="Auxiliary duration",
@@ -505,45 +439,37 @@ 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 {"last_result": self.vehicle.climater_action_status}
+        return dict(last_result=self.vehicle.climater_action_status)
 
 
 class BatteryTargetSOC(Number):
-    """Battery target charge level."""
 
-    def __init__(self) -> None:
-        """Init."""
+    def __init__(self):
         super().__init__(
             attr="battery_target_charge_level",
             name="Battery target charge level",
@@ -554,42 +480,33 @@ class BatteryTargetSOC(Number):
 
     @property
     def state(self):
-        """Return current state."""
         return self.vehicle.battery_target_charge_level
 
     async def set_value(self, value: int):
-        """Set value."""
-        await self.vehicle.set_charging_settings(
-            setting="battery_target_charge_level", value=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 {"last_result": self.vehicle.charger_action_status}
+        return dict(last_result=self.vehicle.charger_action_status)
 
 
 class ClimatisationTargetTemperature(Number):
-    """Climatisation target temperature."""
 
-    def __init__(self) -> None:
-        """Init."""
+    def __init__(self):
         super().__init__(
             attr="climatisation_target_temperature",
             name="Climatisation target temperature",
@@ -600,63 +517,49 @@ class ClimatisationTargetTemperature(Number):
 
     @property
     def state(self):
-        """Return current state."""
         return self.vehicle.climatisation_target_temperature
 
     async def set_value(self, value: float):
-        """Set value."""
-        await self.vehicle.set_climatisation_settings(
-            setting="climatisation_target_temperature", value=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 {"last_result": self.vehicle.climater_action_status}
+        return dict(last_result=self.vehicle.climater_action_status)
 
 
 # Switches
 
 
 class RequestUpdate(Switch):
-    """Force data refresh."""
-
-    def __init__(self) -> None:
-        """Init."""
-        super().__init__(
-            attr="refresh_data", name="Force data refresh", icon="mdi:car-connected"
-        )
+    def __init__(self):
+        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):
-        """Turn off."""
+        pass
 
     @property
     def assumed_state(self) -> bool:
@@ -666,32 +569,22 @@ class RequestUpdate(Switch):
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return {"last_result": self.vehicle.refresh_action_status}
+        return dict(last_result=self.vehicle.refresh_action_status)
 
 
 class ElectricClimatisation(Switch):
-    """Electric Climatisation."""
-
-    def __init__(self) -> None:
-        """Init."""
-        super().__init__(
-            attr="electric_climatisation",
-            name="Electric Climatisation",
-            icon="mdi:air-conditioner",
-        )
+    def __init__(self):
+        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()
 
@@ -703,37 +596,26 @@ class ElectricClimatisation(Switch):
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return {"last_result": self.vehicle.climater_action_status}
+        return dict(last_result=self.vehicle.climater_action_status)
 
 
 class AuxiliaryClimatisation(Switch):
-    """Auxiliary Climatisation."""
-
-    def __init__(self) -> None:
-        """Init."""
-        super().__init__(
-            attr="auxiliary_climatisation",
-            name="Auxiliary Climatisation",
-            icon="mdi:radiator",
-        )
+    def __init__(self):
+        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()
 
@@ -745,28 +627,22 @@ class AuxiliaryClimatisation(Switch):
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return {"last_result": self.vehicle.climater_action_status}
+        return dict(last_result=self.vehicle.climater_action_status)
 
 
 class Charging(Switch):
-    """Charging."""
-
-    def __init__(self) -> None:
-        """Init."""
+    def __init__(self):
         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()
 
@@ -778,38 +654,25 @@ class Charging(Switch):
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return {"last_result": self.vehicle.charger_action_status}
+        return dict(last_result=self.vehicle.charger_action_status)
 
 
 class ReducedACCharging(Switch):
-    """Reduced AC Charging."""
-
-    def __init__(self) -> None:
-        """Init."""
+    def __init__(self):
         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):
-        """Turn on."""
-        await self.vehicle.set_charging_settings(
-            setting="reduced_ac_charging", value="reduced"
-        )
+        await self.vehicle.set_charging_settings(setting="reduced_ac_charging", value="reduced")
         await self.vehicle.update()
 
     async def turn_off(self):
-        """Turn off."""
-        await self.vehicle.set_charging_settings(
-            setting="reduced_ac_charging", value="maximum"
-        )
+        await self.vehicle.set_charging_settings(setting="reduced_ac_charging", value="maximum")
         await self.vehicle.update()
 
     @property
@@ -820,14 +683,11 @@ class ReducedACCharging(Switch):
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return {"last_result": self.vehicle.charger_action_status}
+        return dict(last_result=self.vehicle.charger_action_status)
 
 
 class AutoReleaseACConnector(Switch):
-    """Auto-release AC connector."""
-
-    def __init__(self) -> None:
-        """Init."""
+    def __init__(self):
         super().__init__(
             attr="auto_release_ac_connector",
             name="Auto-release AC connector",
@@ -837,21 +697,14 @@ class AutoReleaseACConnector(Switch):
 
     @property
     def state(self):
-        """Return current state."""
         return self.vehicle.auto_release_ac_connector
 
     async def turn_on(self):
-        """Turn on."""
-        await self.vehicle.set_charging_settings(
-            setting="auto_release_ac_connector", value="permanent"
-        )
+        await self.vehicle.set_charging_settings(setting="auto_release_ac_connector", value="permanent")
         await self.vehicle.update()
 
     async def turn_off(self):
-        """Turn off."""
-        await self.vehicle.set_charging_settings(
-            setting="auto_release_ac_connector", value="off"
-        )
+        await self.vehicle.set_charging_settings(setting="auto_release_ac_connector", value="off")
         await self.vehicle.update()
 
     @property
@@ -861,10 +714,7 @@ class AutoReleaseACConnector(Switch):
 
 
 class BatteryCareMode(Switch):
-    """Battery care mode."""
-
-    def __init__(self) -> None:
-        """Init."""
+    def __init__(self):
         super().__init__(
             attr="battery_care_mode",
             name="Battery care mode",
@@ -874,16 +724,13 @@ 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()
 
@@ -895,14 +742,11 @@ class BatteryCareMode(Switch):
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return {"last_result": self.vehicle.charger_action_status}
+        return dict(last_result=self.vehicle.charger_action_status)
 
 
 class OptimisedBatteryUse(Switch):
-    """Optimised battery use."""
-
-    def __init__(self) -> None:
-        """Init."""
+    def __init__(self):
         super().__init__(
             attr="optimised_battery_use",
             name="Optimised battery use",
@@ -912,16 +756,13 @@ 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()
 
@@ -933,25 +774,20 @@ class OptimisedBatteryUse(Switch):
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return {"last_result": self.vehicle.charger_action_status}
+        return dict(last_result=self.vehicle.charger_action_status)
 
 
 class DepartureTimer(Switch):
     """Departure timers."""
 
-    def __init__(self, id: str | int) -> None:
-        """Init."""
+    def __init__(self, id: str | int):
         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
@@ -961,16 +797,12 @@ 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
@@ -988,19 +820,15 @@ class DepartureTimer(Switch):
 class ACDepartureTimer(Switch):
     """Air conditioning departure timers."""
 
-    def __init__(self, id: str | int) -> None:
-        """Init."""
+    def __init__(self, id: str | int):
         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 current state."""
+        """Return switch state."""
         return self.vehicle.ac_departure_timer_enabled(self._id)
 
     async def turn_on(self):
@@ -1026,26 +854,18 @@ class ACDepartureTimer(Switch):
 
 
 class WindowHeater(Switch):
-    """Window Heater."""
-
-    def __init__(self) -> None:
-        """Init."""
-        super().__init__(
-            attr="window_heater", name="Window Heater", icon="mdi:car-defrost-rear"
-        )
+    def __init__(self):
+        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()
 
@@ -1057,14 +877,11 @@ class WindowHeater(Switch):
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return {"last_result": self.vehicle.climater_action_status}
+        return dict(last_result=self.vehicle.climater_action_status)
 
 
 class BatteryClimatisation(Switch):
-    """Climatisation from battery."""
-
-    def __init__(self) -> None:
-        """Init."""
+    def __init__(self):
         super().__init__(
             attr="climatisation_without_external_power",
             name="Climatisation from battery",
@@ -1074,21 +891,14 @@ class BatteryClimatisation(Switch):
 
     @property
     def state(self):
-        """Return current state."""
         return self.vehicle.climatisation_without_external_power
 
     async def turn_on(self):
-        """Turn on."""
-        await self.vehicle.set_climatisation_settings(
-            setting="climatisation_without_external_power", value=True
-        )
+        await self.vehicle.set_climatisation_settings(setting="climatisation_without_external_power", value=True)
         await self.vehicle.update()
 
     async def turn_off(self):
-        """Turn off."""
-        await self.vehicle.set_climatisation_settings(
-            setting="climatisation_without_external_power", value=False
-        )
+        await self.vehicle.set_climatisation_settings(setting="climatisation_without_external_power", value=False)
         await self.vehicle.update()
 
     @property
@@ -1099,14 +909,11 @@ class BatteryClimatisation(Switch):
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return {"last_result": self.vehicle.climater_action_status}
+        return dict(last_result=self.vehicle.climater_action_status)
 
 
 class AuxiliaryAC(Switch):
-    """Auxiliary air conditioning."""
-
-    def __init__(self) -> None:
-        """Init."""
+    def __init__(self):
         super().__init__(
             attr="auxiliary_air_conditioning",
             name="Auxiliary air conditioning",
@@ -1116,21 +923,14 @@ class AuxiliaryAC(Switch):
 
     @property
     def state(self):
-        """Return current state."""
         return self.vehicle.auxiliary_air_conditioning
 
     async def turn_on(self):
-        """Turn on."""
-        await self.vehicle.set_climatisation_settings(
-            setting="auxiliary_air_conditioning", value=True
-        )
+        await self.vehicle.set_climatisation_settings(setting="auxiliary_air_conditioning", value=True)
         await self.vehicle.update()
 
     async def turn_off(self):
-        """Turn off."""
-        await self.vehicle.set_climatisation_settings(
-            setting="auxiliary_air_conditioning", value=False
-        )
+        await self.vehicle.set_climatisation_settings(setting="auxiliary_air_conditioning", value=False)
         await self.vehicle.update()
 
     @property
@@ -1141,14 +941,11 @@ class AuxiliaryAC(Switch):
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return {"last_result": self.vehicle.climater_action_status}
+        return dict(last_result=self.vehicle.climater_action_status)
 
 
 class AutomaticWindowHeating(Switch):
-    """Automatic window heating."""
-
-    def __init__(self) -> None:
-        """Init."""
+    def __init__(self):
         super().__init__(
             attr="automatic_window_heating",
             name="Automatic window heating",
@@ -1158,21 +955,14 @@ class AutomaticWindowHeating(Switch):
 
     @property
     def state(self):
-        """Return current state."""
         return self.vehicle.automatic_window_heating
 
     async def turn_on(self):
-        """Turn on."""
-        await self.vehicle.set_climatisation_settings(
-            setting="automatic_window_heating", value=True
-        )
+        await self.vehicle.set_climatisation_settings(setting="automatic_window_heating", value=True)
         await self.vehicle.update()
 
     async def turn_off(self):
-        """Turn off."""
-        await self.vehicle.set_climatisation_settings(
-            setting="automatic_window_heating", value=False
-        )
+        await self.vehicle.set_climatisation_settings(setting="automatic_window_heating", value=False)
         await self.vehicle.update()
 
     @property
@@ -1183,14 +973,11 @@ class AutomaticWindowHeating(Switch):
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return {"last_result": self.vehicle.climater_action_status}
+        return dict(last_result=self.vehicle.climater_action_status)
 
 
 class ZoneFrontLeft(Switch):
-    """Zone Front Left."""
-
-    def __init__(self) -> None:
-        """Init."""
+    def __init__(self):
         super().__init__(
             attr="zone_front_left",
             name="Zone Front Left",
@@ -1200,21 +987,14 @@ class ZoneFrontLeft(Switch):
 
     @property
     def state(self):
-        """Return current state."""
         return self.vehicle.zone_front_left
 
     async def turn_on(self):
-        """Turn on."""
-        await self.vehicle.set_climatisation_settings(
-            setting="zone_front_left", value=True
-        )
+        await self.vehicle.set_climatisation_settings(setting="zone_front_left", value=True)
         await self.vehicle.update()
 
     async def turn_off(self):
-        """Turn off."""
-        await self.vehicle.set_climatisation_settings(
-            setting="zone_front_left", value=False
-        )
+        await self.vehicle.set_climatisation_settings(setting="zone_front_left", value=False)
         await self.vehicle.update()
 
     @property
@@ -1225,14 +1005,11 @@ class ZoneFrontLeft(Switch):
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return {"last_result": self.vehicle.climater_action_status}
+        return dict(last_result=self.vehicle.climater_action_status)
 
 
 class ZoneFrontRight(Switch):
-    """Zone Front Right."""
-
-    def __init__(self) -> None:
-        """Init."""
+    def __init__(self):
         super().__init__(
             attr="zone_front_right",
             name="Zone Front Right",
@@ -1242,21 +1019,14 @@ class ZoneFrontRight(Switch):
 
     @property
     def state(self):
-        """Return current state."""
         return self.vehicle.zone_front_right
 
     async def turn_on(self):
-        """Turn on."""
-        await self.vehicle.set_climatisation_settings(
-            setting="zone_front_right", value=True
-        )
+        await self.vehicle.set_climatisation_settings(setting="zone_front_right", value=True)
         await self.vehicle.update()
 
     async def turn_off(self):
-        """Turn off."""
-        await self.vehicle.set_climatisation_settings(
-            setting="zone_front_right", value=False
-        )
+        await self.vehicle.set_climatisation_settings(setting="zone_front_right", value=False)
         await self.vehicle.update()
 
     @property
@@ -1267,20 +1037,16 @@ class ZoneFrontRight(Switch):
     @property
     def attributes(self) -> dict:
         """Return attributes."""
-        return {"last_result": self.vehicle.climater_action_status}
+        return dict(last_result=self.vehicle.climater_action_status)
 
 
 class RequestResults(Sensor):
     """Request results sensor class."""
 
-    def __init__(self) -> None:
+    def __init__(self):
         """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
@@ -1351,18 +1117,6 @@ 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",
@@ -1375,12 +1129,6 @@ 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",
@@ -1439,18 +1187,6 @@ 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",
@@ -1522,13 +1258,6 @@ 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",
@@ -1652,31 +1381,14 @@ 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="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",
-        ),
-        BinarySensor(
-            attr="door_locked",
-            name="Doors locked",
-            device_class=VWDeviceClass.LOCK,
-            reverse_state=True,
+            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,
+            attr="door_locked_sensor", name="Doors locked", device_class=VWDeviceClass.LOCK, reverse_state=True
         ),
         BinarySensor(
             attr="door_closed_left_front",
@@ -1706,30 +1418,12 @@ 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",
-            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,
+            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="charging_cable_connected",
             name="Charging cable connected",
@@ -1743,10 +1437,7 @@ 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",
@@ -1755,16 +1446,10 @@ 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",
@@ -1790,11 +1475,7 @@ 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",
@@ -1807,11 +1488,7 @@ def create_instruments():
 class Dashboard:
     """Helper for accessing the instruments."""
 
-    def __init__(self, vehicle, **config) -> None:
+    def __init__(self, vehicle, **config):
         """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)]