__init__.py

Go to the documentation of this file.

"""The lawn mower integration."""
 
from __future__ import annotations
 
from datetime import timedelta
import logging
from typing import final
 
from propcache import cached_property
 
from homeassistant.config_entries import ConfigEntry
from homeassistant.core import HomeAssistant
from homeassistant.helpers import config_validation as cv
from homeassistant.helpers.entity import Entity, EntityDescription
from homeassistant.helpers.entity_component import EntityComponent
from homeassistant.helpers.typing import ConfigType
from homeassistant.util.hass_dict import HassKey
 
from .const import (
    DOMAIN,
    SERVICE_DOCK,
    SERVICE_PAUSE,
    SERVICE_START_MOWING,
    LawnMowerActivity,
    LawnMowerEntityFeature,
)
 
_LOGGER = logging.getLogger(__name__)
 
DATA_COMPONENT: HassKey[EntityComponent[LawnMowerEntity]] = HassKey(DOMAIN)
PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA
PLATFORM_SCHEMA_BASE = cv.PLATFORM_SCHEMA_BASE
SCAN_INTERVAL = timedelta(seconds=60)
 
 
async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
    """Set up the lawn_mower component."""
    component = hass.data[DATA_COMPONENT] = EntityComponent[LawnMowerEntity](
        _LOGGER, DOMAIN, hass, SCAN_INTERVAL
    )
    await component.async_setup(config)
 
    component.async_register_entity_service(
        SERVICE_START_MOWING,
        None,
        "async_start_mowing",
        [LawnMowerEntityFeature.START_MOWING],
    )
    component.async_register_entity_service(
        SERVICE_PAUSE, None, "async_pause", [LawnMowerEntityFeature.PAUSE]
    )
    component.async_register_entity_service(
        SERVICE_DOCK, None, "async_dock", [LawnMowerEntityFeature.DOCK]
    )
 
    return True
 
 
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
    """Set up lawn mower devices."""
    return await hass.data[DATA_COMPONENT].async_setup_entry(entry)
 
 
async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
    """Unload a config entry."""
    return await hass.data[DATA_COMPONENT].async_unload_entry(entry)
 
 
class LawnMowerEntityEntityDescription(EntityDescription, frozen_or_thawed=True):
    """A class that describes lawn mower entities."""
 
 
CACHED_PROPERTIES_WITH_ATTR_ = {
    "activity",
    "supported_features",
}
 
 
class LawnMowerEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
    """Base class for lawn mower entities."""
 
    entity_description: LawnMowerEntityEntityDescription
    _attr_activity: LawnMowerActivity | None = None
    _attr_supported_features: LawnMowerEntityFeature = LawnMowerEntityFeature(0)
 
    @final
    @property
    def state(self) -> str | None:
        """Return the current state."""
        return self.activityactivity
 
    @cached_property
    def activity(self) -> LawnMowerActivity | None:
        """Return the current lawn mower activity."""
        return self._attr_activity
 
    @cached_property
    def supported_features(self) -> LawnMowerEntityFeature:
        """Flag lawn mower features that are supported."""
        return self._attr_supported_features
 
    def start_mowing(self) -> None:
        """Start or resume mowing."""
        raise NotImplementedError
 
    async def async_start_mowing(self) -> None:
        """Start or resume mowing."""
        await self.hasshass.async_add_executor_job(self.start_mowingstart_mowing)
 
    def dock(self) -> None:
        """Dock the mower."""
        raise NotImplementedError
 
    async def async_dock(self) -> None:
        """Dock the mower."""
        await self.hasshass.async_add_executor_job(self.dockdock)
 
    def pause(self) -> None:
        """Pause the lawn mower."""
        raise NotImplementedError
 
    async def async_pause(self) -> None:
        """Pause the lawn mower."""
        await self.hasshass.async_add_executor_job(self.pausepause)