select.py

Go to the documentation of this file.

"""Select platform for Tessie integration."""
 
from __future__ import annotations
 
from itertools import chain
 
from tesla_fleet_api.const import EnergyExportMode, EnergyOperationMode
from tessie_api import set_seat_cool, set_seat_heat
 
from homeassistant.components.select import SelectEntity
from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
from . import TessieConfigEntry
from .const import TessieSeatCoolerOptions, TessieSeatHeaterOptions
from .entity import TessieEnergyEntity, TessieEntity
from .helpers import handle_command
from .models import TessieEnergyData
 
SEAT_HEATERS = {
    "climate_state_seat_heater_left": "front_left",
    "climate_state_seat_heater_right": "front_right",
    "climate_state_seat_heater_rear_left": "rear_left",
    "climate_state_seat_heater_rear_center": "rear_center",
    "climate_state_seat_heater_rear_right": "rear_right",
    "climate_state_seat_heater_third_row_left": "third_row_left",
    "climate_state_seat_heater_third_row_right": "third_row_right",
}
 
SEAT_COOLERS = {
    "climate_state_seat_fan_front_left": "front_left",
    "climate_state_seat_fan_front_right": "front_right",
}
 
PARALLEL_UPDATES = 0
 
 
async def async_setup_entry(
    hass: HomeAssistant,
    entry: TessieConfigEntry,
    async_add_entities: AddEntitiesCallback,
) -> None:
    """Set up the Tessie select platform from a config entry."""
 
    async_add_entities(
        chain(
            (
                TessieSeatHeaterSelectEntity(vehicle, key)
                for vehicle in entry.runtime_data.vehicles
                for key in SEAT_HEATERS
                if key
                in vehicle.data_coordinator.data  # not all vehicles have rear center or third row
            ),
            (
                TessieSeatCoolerSelectEntity(vehicle, key)
                for vehicle in entry.runtime_data.vehicles
                for key in SEAT_COOLERS
                if key
                in vehicle.data_coordinator.data  # not all vehicles have ventilated seats
            ),
            (
                TessieOperationSelectEntity(energysite)
                for energysite in entry.runtime_data.energysites
                if energysite.info_coordinator.data.get("components_battery")
            ),
            (
                TessieExportRuleSelectEntity(energysite)
                for energysite in entry.runtime_data.energysites
                if energysite.info_coordinator.data.get("components_battery")
                and energysite.info_coordinator.data.get("components_solar")
            ),
        )
    )
 
 
class TessieSeatHeaterSelectEntity(TessieEntity, SelectEntity):
    """Select entity for current charge."""
 
    _attr_options = [
        TessieSeatHeaterOptions.OFF,
        TessieSeatHeaterOptions.LOW,
        TessieSeatHeaterOptions.MEDIUM,
        TessieSeatHeaterOptions.HIGH,
    ]
 
    @property
    def current_option(self) -> str | None:
        """Return the current selected option."""
        return self._attr_options_attr_options[self._value_value_value]
 
    async def async_select_option(self, option: str) -> None:
        """Change the selected option."""
        level = self._attr_options_attr_options.index(option)
        await self.runrun(set_seat_heat, seat=SEAT_HEATERS[self.keykey], level=level)
        self.setset((self.keykey, level))
 
 
class TessieSeatCoolerSelectEntity(TessieEntity, SelectEntity):
    """Select entity for cooled seat."""
 
    _attr_options = [
        TessieSeatCoolerOptions.OFF,
        TessieSeatCoolerOptions.LOW,
        TessieSeatCoolerOptions.MEDIUM,
        TessieSeatCoolerOptions.HIGH,
    ]
 
    @property
    def current_option(self) -> str | None:
        """Return the current selected option."""
        return self._attr_options_attr_options[self._value_value_value]
 
    async def async_select_option(self, option: str) -> None:
        """Change the selected option."""
        level = self._attr_options_attr_options.index(option)
        await self.runrun(set_seat_cool, seat=SEAT_COOLERS[self.keykey], level=level)
        self.setset((self.keykey, level))
 
 
class TessieOperationSelectEntity(TessieEnergyEntity, SelectEntity):
    """Select entity for operation mode select entities."""
 
    _attr_options: list[str] = [
        EnergyOperationMode.AUTONOMOUS,
        EnergyOperationMode.BACKUP,
        EnergyOperationMode.SELF_CONSUMPTION,
    ]
 
    def __init__(
        self,
        data: TessieEnergyData,
    ) -> None:
        """Initialize the operation mode select entity."""
        super().__init__(data, data.info_coordinator, "default_real_mode")
 
    def _async_update_attrs(self) -> None:
        """Update the attributes of the entity."""
        self._attr_current_option_attr_current_option = self._value_value
 
    async def async_select_option(self, option: str) -> None:
        """Change the selected option."""
        await handle_command(self.apiapiapiapi.operation(option))
        self._attr_current_option_attr_current_option = option
        self.async_write_ha_stateasync_write_ha_state()
 
 
class TessieExportRuleSelectEntity(TessieEnergyEntity, SelectEntity):
    """Select entity for export rules select entities."""
 
    _attr_options: list[str] = [
        EnergyExportMode.NEVER,
        EnergyExportMode.BATTERY_OK,
        EnergyExportMode.PV_ONLY,
    ]
 
    def __init__(
        self,
        data: TessieEnergyData,
    ) -> None:
        """Initialize the export rules select entity."""
        super().__init__(
            data, data.info_coordinator, "components_customer_preferred_export_rule"
        )
 
    def _async_update_attrs(self) -> None:
        """Update the attributes of the entity."""
        self._attr_current_option_attr_current_option = self.getget(self.keykey, EnergyExportMode.NEVER.value)
 
    async def async_select_option(self, option: str) -> None:
        """Change the selected option."""
        await handle_command(self.apiapiapiapi.grid_import_export(option))
        self._attr_current_option_attr_current_option = option
        self.async_write_ha_stateasync_write_ha_state()