Merge pull request #132 from c-st/cover-group

Add support for cover groups

Author: c-st

custom_components/auto_areas/__init__.py

@@ -16,8 +16,12 @@
 
 from .const import DOMAIN, LOGGER, ISSUE_TYPE_YAML_DETECTED
 
-PLATFORMS: list[Platform] = [Platform.SWITCH,
-                             Platform.BINARY_SENSOR, Platform.SENSOR]
+PLATFORMS: list[Platform] = [
+    Platform.SWITCH,
+    Platform.BINARY_SENSOR,
+    Platform.SENSOR,
+    Platform.COVER,
+]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:

custom_components/auto_areas/auto_area.py

@@ -93,6 +93,15 @@ def get_valid_entities(self) -> list[RegistryEntry]:
         ]
         return entities
 
+    def get_area_entity_ids(self, device_classes: list[str]) -> list[str]:
+        """Return all entity ids in a list of device classes."""
+        return [
+            entity.entity_id
+            for entity in self.get_valid_entities()
+            if entity.device_class in device_classes
+            or entity.original_device_class in device_classes
+        ]
+
     @property
     def area_name(self) -> str:
         """Return area name or fallback."""

custom_components/auto_areas/auto_entity.py

@@ -10,20 +10,25 @@
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.typing import StateType
 from homeassistant.components.sensor.const import SensorDeviceClass
+from homeassistant.components.cover import CoverDeviceClass
 from homeassistant.helpers.event import async_track_state_change_event
 
 from custom_components.auto_areas.calculations import get_calculation
 
 from .auto_area import AutoArea
 from .const import DOMAIN, LOGGER, NAME, VERSION
 
-_TDeviceClass = TypeVar(
-    "_TDeviceClass", BinarySensorDeviceClass, SensorDeviceClass)
 _TEntity = TypeVar("_TEntity", bound=Entity)
+_TDeviceClass = TypeVar(
+    "_TDeviceClass",
+    BinarySensorDeviceClass,
+    SensorDeviceClass,
+    CoverDeviceClass
+)
 
 
 class AutoEntity(Entity, Generic[_TEntity, _TDeviceClass]):
-    """Set up an aggregated entity."""
+    """Set up an Auto Area entity."""
 
     def __init__(self,
                  hass: HomeAssistant,

custom_components/auto_areas/const.py

@@ -10,6 +10,7 @@
 from homeassistant.components.light import DOMAIN as LIGHT_DOMAIN
 from homeassistant.components.sensor.const import DOMAIN as SENSOR_DOMAIN
 from homeassistant.components.switch.const import DOMAIN as SWITCH_DOMAIN
+from homeassistant.components.cover import DOMAIN as COVER_DOMAIN
 from homeassistant.const import STATE_HOME, STATE_ON, STATE_PLAYING
 
 
@@ -44,6 +45,9 @@
 HUMIDITY_SENSOR_PREFIX = "Area Humidity "
 HUMIDITY_SENSOR_ENTITY_PREFIX = "sensor.area_humidity_"
 
+COVER_GROUP_PREFIX = "Area Covers "
+COVER_GROUP_ENTITY_PREFIX = "cover.area_covers_"
+
 #
 # Config flow constants
 #
@@ -55,15 +59,14 @@
 CONFIG_TEMPERATURE_CALCULATION = "temperature_calculation"
 CONFIG_ILLUMINANCE_CALCULATION = "illuminance_calculation"
 
-#
-
 
-# Fetch entities from these domains
+# Fetch entities from these domains:
 RELEVANT_DOMAINS = [
     BINARY_SENSOR_DOMAIN,
     SENSOR_DOMAIN,
     SWITCH_DOMAIN,
     LIGHT_DOMAIN,
+    COVER_DOMAIN,
 ]
 
 # Presence entities

custom_components/auto_areas/cover.py

@@ -0,0 +1,83 @@
+"""Cover group."""
+
+from functools import cached_property
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.components.group.cover import CoverGroup
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.components.cover import (
+    CoverDeviceClass,
+    DEVICE_CLASSES as COVER_DEVICE_CLASSES,
+)
+
+from custom_components.auto_areas.auto_area import AutoArea
+from custom_components.auto_areas.const import (
+    COVER_GROUP_ENTITY_PREFIX,
+    COVER_GROUP_PREFIX,
+    DOMAIN,
+    LOGGER,
+    NAME,
+    VERSION
+)
+
+
+async def async_setup_entry(hass, entry, async_add_entities: AddEntitiesCallback):
+    """Set up the cover platform."""
+    auto_area: AutoArea = hass.data[DOMAIN][entry.entry_id]
+
+    cover_entity_ids: list[str] = auto_area.get_area_entity_ids(
+        COVER_DEVICE_CLASSES
+    )
+    if not cover_entity_ids:
+        LOGGER.info(
+            "%s: No covers found in area. Not creating cover group.",
+            auto_area.area_name,
+        )
+    else:
+        async_add_entities([AutoCoverGroup(
+            hass,
+            auto_area,
+            entity_ids=cover_entity_ids
+        )])
+
+
+class AutoCoverGroup(CoverGroup):
+    """Cover group with area covers."""
+
+    def __init__(self, hass, auto_area: AutoArea, entity_ids: list[str]) -> None:
+        """Initialize cover group."""
+        self.hass = hass
+        self.auto_area = auto_area
+        self._device_class = CoverDeviceClass.BLIND
+        self._name_prefix = COVER_GROUP_PREFIX
+        self._prefix = COVER_GROUP_ENTITY_PREFIX
+        self.entity_ids: list[str] = entity_ids
+
+        CoverGroup.__init__(
+            self,
+            entities=self.entity_ids,
+            name=None,
+            unique_id=self._attr_unique_id,
+        )
+
+        LOGGER.debug("Initialized cover group %s", self.entity_ids)
+
+    @cached_property
+    def name(self):
+        """Name of this entity."""
+        return f"{self._name_prefix}{self.auto_area.area_name}"
+
+    @cached_property
+    def device_info(self) -> DeviceInfo:
+        """Information about this device."""
+        return {
+            "identifiers": {(DOMAIN, self.auto_area.config_entry.entry_id)},
+            "name": NAME,
+            "model": VERSION,
+            "manufacturer": NAME,
+            "suggested_area": self.auto_area.area_name,
+        }
+
+    @cached_property
+    def unique_id(self) -> str | None:
+        """Return a unique ID."""
+        return f"{self.auto_area.config_entry.entry_id}_cover_group"