diff --git a/homeassistant/components/mazda/sensor.py b/homeassistant/components/mazda/sensor.py index ee42b989c49..adcb7499aab 100644 --- a/homeassistant/components/mazda/sensor.py +++ b/homeassistant/components/mazda/sensor.py @@ -1,9 +1,13 @@ """Platform for Mazda sensor integration.""" from __future__ import annotations -from homeassistant.components.sensor import SensorEntity +from collections.abc import Callable +from dataclasses import dataclass + +from homeassistant.components.sensor import SensorEntity, SensorEntityDescription from homeassistant.config_entries import ConfigEntry from homeassistant.const import ( + CONF_UNIT_SYSTEM_IMPERIAL, LENGTH_KILOMETERS, LENGTH_MILES, PERCENTAGE, @@ -11,11 +15,157 @@ from homeassistant.const import ( ) from homeassistant.core import HomeAssistant from homeassistant.helpers.entity_platform import AddEntitiesCallback +from homeassistant.helpers.typing import StateType +from homeassistant.util.unit_system import UnitSystem from . import MazdaEntity from .const import DATA_CLIENT, DATA_COORDINATOR, DOMAIN +@dataclass +class MazdaSensorRequiredKeysMixin: + """Mixin for required keys.""" + + # Suffix to be appended to the vehicle name to obtain the sensor name + name_suffix: str + + # Function to determine the value for this sensor, given the coordinator data and the configured unit system + value: Callable[[dict, UnitSystem], StateType] + + +@dataclass +class MazdaSensorEntityDescription( + SensorEntityDescription, MazdaSensorRequiredKeysMixin +): + """Describes a Mazda sensor entity.""" + + # Function to determine whether the vehicle supports this sensor, given the coordinator data + is_supported: Callable[[dict], bool] = lambda data: True + + # Function to determine the unit of measurement for this sensor, given the configured unit system + # Falls back to description.native_unit_of_measurement if it is not provided + unit: Callable[[UnitSystem], str | None] | None = None + + +def _get_distance_unit(unit_system): + """Return the distance unit for the given unit system.""" + if unit_system.name == CONF_UNIT_SYSTEM_IMPERIAL: + return LENGTH_MILES + return LENGTH_KILOMETERS + + +def _front_left_tire_pressure_supported(data): + """Determine if front left tire pressure is supported.""" + return data["status"]["tirePressure"]["frontLeftTirePressurePsi"] is not None + + +def _front_right_tire_pressure_supported(data): + """Determine if front right tire pressure is supported.""" + return data["status"]["tirePressure"]["frontRightTirePressurePsi"] is not None + + +def _rear_left_tire_pressure_supported(data): + """Determine if rear left tire pressure is supported.""" + return data["status"]["tirePressure"]["rearLeftTirePressurePsi"] is not None + + +def _rear_right_tire_pressure_supported(data): + """Determine if rear right tire pressure is supported.""" + return data["status"]["tirePressure"]["rearRightTirePressurePsi"] is not None + + +def _fuel_distance_remaining_value(data, unit_system): + """Get the fuel distance remaining value.""" + return round( + unit_system.length(data["status"]["fuelDistanceRemainingKm"], LENGTH_KILOMETERS) + ) + + +def _odometer_value(data, unit_system): + """Get the odometer value.""" + return round(unit_system.length(data["status"]["odometerKm"], LENGTH_KILOMETERS)) + + +def _front_left_tire_pressure_value(data, unit_system): + """Get the front left tire pressure value.""" + return round(data["status"]["tirePressure"]["frontLeftTirePressurePsi"]) + + +def _front_right_tire_pressure_value(data, unit_system): + """Get the front right tire pressure value.""" + return round(data["status"]["tirePressure"]["frontRightTirePressurePsi"]) + + +def _rear_left_tire_pressure_value(data, unit_system): + """Get the rear left tire pressure value.""" + return round(data["status"]["tirePressure"]["rearLeftTirePressurePsi"]) + + +def _rear_right_tire_pressure_value(data, unit_system): + """Get the rear right tire pressure value.""" + return round(data["status"]["tirePressure"]["rearRightTirePressurePsi"]) + + +SENSOR_ENTITIES = [ + MazdaSensorEntityDescription( + key="fuel_remaining_percentage", + name_suffix="Fuel Remaining Percentage", + icon="mdi:gas-station", + native_unit_of_measurement=PERCENTAGE, + is_supported=lambda data: data["status"]["fuelRemainingPercent"] is not None, + value=lambda data, unit_system: data["status"]["fuelRemainingPercent"], + ), + MazdaSensorEntityDescription( + key="fuel_distance_remaining", + name_suffix="Fuel Distance Remaining", + icon="mdi:gas-station", + unit=_get_distance_unit, + is_supported=lambda data: data["status"]["fuelDistanceRemainingKm"] is not None, + value=_fuel_distance_remaining_value, + ), + MazdaSensorEntityDescription( + key="odometer", + name_suffix="Odometer", + icon="mdi:speedometer", + unit=_get_distance_unit, + is_supported=lambda data: data["status"]["odometerKm"] is not None, + value=_odometer_value, + ), + MazdaSensorEntityDescription( + key="front_left_tire_pressure", + name_suffix="Front Left Tire Pressure", + icon="mdi:car-tire-alert", + native_unit_of_measurement=PRESSURE_PSI, + is_supported=_front_left_tire_pressure_supported, + value=_front_left_tire_pressure_value, + ), + MazdaSensorEntityDescription( + key="front_right_tire_pressure", + name_suffix="Front Right Tire Pressure", + icon="mdi:car-tire-alert", + native_unit_of_measurement=PRESSURE_PSI, + is_supported=_front_right_tire_pressure_supported, + value=_front_right_tire_pressure_value, + ), + MazdaSensorEntityDescription( + key="rear_left_tire_pressure", + name_suffix="Rear Left Tire Pressure", + icon="mdi:car-tire-alert", + native_unit_of_measurement=PRESSURE_PSI, + is_supported=_rear_left_tire_pressure_supported, + value=_rear_left_tire_pressure_value, + ), + MazdaSensorEntityDescription( + key="rear_right_tire_pressure", + name_suffix="Rear Right Tire Pressure", + icon="mdi:car-tire-alert", + native_unit_of_measurement=PRESSURE_PSI, + is_supported=_rear_right_tire_pressure_supported, + value=_rear_right_tire_pressure_value, + ), +] + + async def async_setup_entry( hass: HomeAssistant, config_entry: ConfigEntry, @@ -27,170 +177,37 @@ async def async_setup_entry( entities: list[SensorEntity] = [] - for index, _ in enumerate(coordinator.data): - entities.append(MazdaFuelRemainingSensor(client, coordinator, index)) - entities.append(MazdaFuelDistanceSensor(client, coordinator, index)) - entities.append(MazdaOdometerSensor(client, coordinator, index)) - entities.append(MazdaFrontLeftTirePressureSensor(client, coordinator, index)) - entities.append(MazdaFrontRightTirePressureSensor(client, coordinator, index)) - entities.append(MazdaRearLeftTirePressureSensor(client, coordinator, index)) - entities.append(MazdaRearRightTirePressureSensor(client, coordinator, index)) + for index, data in enumerate(coordinator.data): + for description in SENSOR_ENTITIES: + if description.is_supported(data): + entities.append( + MazdaSensorEntity(client, coordinator, index, description) + ) async_add_entities(entities) -class MazdaFuelRemainingSensor(MazdaEntity, SensorEntity): - """Class for the fuel remaining sensor.""" +class MazdaSensorEntity(MazdaEntity, SensorEntity): + """Representation of a Mazda vehicle sensor.""" - _attr_native_unit_of_measurement = PERCENTAGE - _attr_icon = "mdi:gas-station" + entity_description: MazdaSensorEntityDescription - def __init__(self, client, coordinator, index) -> None: - """Initialize Mazda fuel remaining sensor.""" + def __init__(self, client, coordinator, index, description): + """Initialize Mazda sensor.""" super().__init__(client, coordinator, index) + self.entity_description = description - self._attr_name = f"{self.vehicle_name} Fuel Remaining Percentage" - self._attr_unique_id = f"{self.vin}_fuel_remaining_percentage" + self._attr_name = f"{self.vehicle_name} {description.name_suffix}" + self._attr_unique_id = f"{self.vin}_{description.key}" + + @property + def native_unit_of_measurement(self): + """Return the unit of measurement for the sensor, according to the configured unit system.""" + if unit_fn := self.entity_description.unit: + return unit_fn(self.hass.config.units) + return self.entity_description.native_unit_of_measurement @property def native_value(self): """Return the state of the sensor.""" - return self.data["status"]["fuelRemainingPercent"] - - -class MazdaFuelDistanceSensor(MazdaEntity, SensorEntity): - """Class for the fuel distance sensor.""" - - _attr_icon = "mdi:gas-station" - - def __init__(self, client, coordinator, index) -> None: - """Initialize Mazda fuel distance sensor.""" - super().__init__(client, coordinator, index) - - self._attr_name = f"{self.vehicle_name} Fuel Distance Remaining" - self._attr_unique_id = f"{self.vin}_fuel_distance_remaining" - self._attr_native_unit_of_measurement = ( - LENGTH_KILOMETERS - if coordinator.hass.config.units.is_metric - else LENGTH_MILES - ) - - @property - def native_value(self): - """Return the state of the sensor.""" - fuel_distance_km = self.data["status"]["fuelDistanceRemainingKm"] - return ( - None - if fuel_distance_km is None - else round( - self.hass.config.units.length(fuel_distance_km, LENGTH_KILOMETERS) - ) - ) - - -class MazdaOdometerSensor(MazdaEntity, SensorEntity): - """Class for the odometer sensor.""" - - _attr_icon = "mdi:speedometer" - - def __init__(self, client, coordinator, index) -> None: - """Initialize Mazda odometer sensor.""" - super().__init__(client, coordinator, index) - - self._attr_name = f"{self.vehicle_name} Odometer" - self._attr_unique_id = f"{self.vin}_odometer" - self._attr_native_unit_of_measurement = ( - LENGTH_KILOMETERS - if coordinator.hass.config.units.is_metric - else LENGTH_MILES - ) - - @property - def native_value(self): - """Return the state of the sensor.""" - odometer_km = self.data["status"]["odometerKm"] - return ( - None - if odometer_km is None - else round(self.hass.config.units.length(odometer_km, LENGTH_KILOMETERS)) - ) - - -class MazdaFrontLeftTirePressureSensor(MazdaEntity, SensorEntity): - """Class for the front left tire pressure sensor.""" - - _attr_native_unit_of_measurement = PRESSURE_PSI - _attr_icon = "mdi:car-tire-alert" - - def __init__(self, client, coordinator, index) -> None: - """Initialize Mazda front left tire pressure sensor.""" - super().__init__(client, coordinator, index) - - self._attr_name = f"{self.vehicle_name} Front Left Tire Pressure" - self._attr_unique_id = f"{self.vin}_front_left_tire_pressure" - - @property - def native_value(self): - """Return the state of the sensor.""" - tire_pressure = self.data["status"]["tirePressure"]["frontLeftTirePressurePsi"] - return None if tire_pressure is None else round(tire_pressure) - - -class MazdaFrontRightTirePressureSensor(MazdaEntity, SensorEntity): - """Class for the front right tire pressure sensor.""" - - _attr_native_unit_of_measurement = PRESSURE_PSI - _attr_icon = "mdi:car-tire-alert" - - def __init__(self, client, coordinator, index) -> None: - """Initialize Mazda front right tire pressure sensor.""" - super().__init__(client, coordinator, index) - - self._attr_name = f"{self.vehicle_name} Front Right Tire Pressure" - self._attr_unique_id = f"{self.vin}_front_right_tire_pressure" - - @property - def native_value(self): - """Return the state of the sensor.""" - tire_pressure = self.data["status"]["tirePressure"]["frontRightTirePressurePsi"] - return None if tire_pressure is None else round(tire_pressure) - - -class MazdaRearLeftTirePressureSensor(MazdaEntity, SensorEntity): - """Class for the rear left tire pressure sensor.""" - - _attr_native_unit_of_measurement = PRESSURE_PSI - _attr_icon = "mdi:car-tire-alert" - - def __init__(self, client, coordinator, index) -> None: - """Initialize Mazda rear left tire pressure sensor.""" - super().__init__(client, coordinator, index) - - self._attr_name = f"{self.vehicle_name} Rear Left Tire Pressure" - self._attr_unique_id = f"{self.vin}_rear_left_tire_pressure" - - @property - def native_value(self): - """Return the state of the sensor.""" - tire_pressure = self.data["status"]["tirePressure"]["rearLeftTirePressurePsi"] - return None if tire_pressure is None else round(tire_pressure) - - -class MazdaRearRightTirePressureSensor(MazdaEntity, SensorEntity): - """Class for the rear right tire pressure sensor.""" - - _attr_native_unit_of_measurement = PRESSURE_PSI - _attr_icon = "mdi:car-tire-alert" - - def __init__(self, client, coordinator, index) -> None: - """Initialize Mazda rear right tire pressure sensor.""" - super().__init__(client, coordinator, index) - - self._attr_name = f"{self.vehicle_name} Rear Right Tire Pressure" - self._attr_unique_id = f"{self.vin}_rear_right_tire_pressure" - - @property - def native_value(self): - """Return the state of the sensor.""" - tire_pressure = self.data["status"]["tirePressure"]["rearRightTirePressurePsi"] - return None if tire_pressure is None else round(tire_pressure) + return self.entity_description.value(self.data, self.hass.config.units)