cover.py

Go to the documentation of this file.

"""Cover platform for Tessie integration."""
 
from __future__ import annotations
 
from itertools import chain
from typing import Any
 
from tessie_api import (
    close_charge_port,
    close_sunroof,
    close_windows,
    open_close_rear_trunk,
    open_front_trunk,
    open_unlock_charge_port,
    vent_sunroof,
    vent_windows,
)
 
from homeassistant.components.cover import (
    CoverDeviceClass,
    CoverEntity,
    CoverEntityFeature,
)
from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
from . import TessieConfigEntry
from .const import TessieCoverStates
from .entity import TessieEntity
from .models import TessieVehicleData
 
PARALLEL_UPDATES = 0
 
 
async def async_setup_entry(
    hass: HomeAssistant,
    entry: TessieConfigEntry,
    async_add_entities: AddEntitiesCallback,
) -> None:
    """Set up the Tessie sensor platform from a config entry."""
    data = entry.runtime_data
 
    async_add_entities(
        chain(
            (
                klass(vehicle)
                for klass in (
                    TessieWindowEntity,
                    TessieChargePortEntity,
                    TessieFrontTrunkEntity,
                    TessieRearTrunkEntity,
                )
                for vehicle in data.vehicles
            ),
            (
                TessieSunroofEntity(vehicle)
                for vehicle in data.vehicles
                if vehicle.data_coordinator.data.get(
                    "vehicle_config_sun_roof_installed"
                )
            ),
        )
    )
 
 
class TessieWindowEntity(TessieEntity, CoverEntity):
    """Cover entity for current charge."""
 
    _attr_device_class = CoverDeviceClass.WINDOW
    _attr_supported_features = CoverEntityFeature.OPEN | CoverEntityFeature.CLOSE
 
    def __init__(self, vehicle: TessieVehicleData) -> None:
        """Initialize the sensor."""
        super().__init__(vehicle, "windows")
 
    @property
    def is_closed(self) -> bool | None:
        """Return if the cover is closed or not."""
        return (
            self.getget("vehicle_state_fd_window") == TessieCoverStates.CLOSED
            and self.getget("vehicle_state_fp_window") == TessieCoverStates.CLOSED
            and self.getget("vehicle_state_rd_window") == TessieCoverStates.CLOSED
            and self.getget("vehicle_state_rp_window") == TessieCoverStates.CLOSED
        )
 
    async def async_open_cover(self, **kwargs: Any) -> None:
        """Open windows."""
        await self.runrun(vent_windows)
        self.setset(
            ("vehicle_state_fd_window", TessieCoverStates.OPEN),
            ("vehicle_state_fp_window", TessieCoverStates.OPEN),
            ("vehicle_state_rd_window", TessieCoverStates.OPEN),
            ("vehicle_state_rp_window", TessieCoverStates.OPEN),
        )
 
    async def async_close_cover(self, **kwargs: Any) -> None:
        """Close windows."""
        await self.runrun(close_windows)
        self.setset(
            ("vehicle_state_fd_window", TessieCoverStates.CLOSED),
            ("vehicle_state_fp_window", TessieCoverStates.CLOSED),
            ("vehicle_state_rd_window", TessieCoverStates.CLOSED),
            ("vehicle_state_rp_window", TessieCoverStates.CLOSED),
        )
 
 
class TessieChargePortEntity(TessieEntity, CoverEntity):
    """Cover entity for the charge port."""
 
    _attr_device_class = CoverDeviceClass.DOOR
    _attr_supported_features = CoverEntityFeature.OPEN | CoverEntityFeature.CLOSE
 
    def __init__(self, vehicle: TessieVehicleData) -> None:
        """Initialize the sensor."""
        super().__init__(vehicle, "charge_state_charge_port_door_open")
 
    @property
    def is_closed(self) -> bool | None:
        """Return if the cover is closed or not."""
        return not self._value_value_value
 
    async def async_open_cover(self, **kwargs: Any) -> None:
        """Open windows."""
        await self.runrun(open_unlock_charge_port)
        self.setset((self.keykey, True))
 
    async def async_close_cover(self, **kwargs: Any) -> None:
        """Close windows."""
        await self.runrun(close_charge_port)
        self.setset((self.keykey, False))
 
 
class TessieFrontTrunkEntity(TessieEntity, CoverEntity):
    """Cover entity for the charge port."""
 
    _attr_device_class = CoverDeviceClass.DOOR
    _attr_supported_features = CoverEntityFeature.OPEN
 
    def __init__(self, vehicle: TessieVehicleData) -> None:
        """Initialize the sensor."""
        super().__init__(vehicle, "vehicle_state_ft")
 
    @property
    def is_closed(self) -> bool | None:
        """Return if the cover is closed or not."""
        return self._value_value_value_value == TessieCoverStates.CLOSED
 
    async def async_open_cover(self, **kwargs: Any) -> None:
        """Open front trunk."""
        await self.runrun(open_front_trunk)
        self.setset((self.keykey, TessieCoverStates.OPEN))
 
 
class TessieRearTrunkEntity(TessieEntity, CoverEntity):
    """Cover entity for the charge port."""
 
    _attr_device_class = CoverDeviceClass.DOOR
    _attr_supported_features = CoverEntityFeature.OPEN | CoverEntityFeature.CLOSE
 
    def __init__(self, vehicle: TessieVehicleData) -> None:
        """Initialize the sensor."""
        super().__init__(vehicle, "vehicle_state_rt")
 
    @property
    def is_closed(self) -> bool | None:
        """Return if the cover is closed or not."""
        return self._value_value_value_value == TessieCoverStates.CLOSED
 
    async def async_open_cover(self, **kwargs: Any) -> None:
        """Open rear trunk."""
        if self.is_closedis_closedis_closed:
            await self.runrun(open_close_rear_trunk)
            self.setset((self.keykey, TessieCoverStates.OPEN))
 
    async def async_close_cover(self, **kwargs: Any) -> None:
        """Close rear trunk."""
        if not self.is_closedis_closedis_closed:
            await self.runrun(open_close_rear_trunk)
            self.setset((self.keykey, TessieCoverStates.CLOSED))
 
 
class TessieSunroofEntity(TessieEntity, CoverEntity):
    """Cover entity for the sunroof."""
 
    _attr_device_class = CoverDeviceClass.WINDOW
    _attr_supported_features = CoverEntityFeature.OPEN | CoverEntityFeature.CLOSE
 
    def __init__(self, vehicle: TessieVehicleData) -> None:
        """Initialize the sensor."""
        super().__init__(vehicle, "vehicle_state_sun_roof_state")
 
    @property
    def is_closed(self) -> bool | None:
        """Return if the cover is closed or not."""
        return self._value_value_value_value == TessieCoverStates.CLOSED
 
    @property
    def current_cover_position(self) -> bool | None:
        """Return the percentage open."""
        return self.getget("vehicle_state_sun_roof_percent_open")
 
    async def async_open_cover(self, **kwargs: Any) -> None:
        """Open sunroof."""
        await self.runrun(vent_sunroof)
        self.setset((self.keykey, TessieCoverStates.OPEN))
 
    async def async_close_cover(self, **kwargs: Any) -> None:
        """Close sunroof."""
        await self.runrun(close_sunroof)
        self.setset((self.keykey, TessieCoverStates.CLOSED))