cover apis and tests

Author: dmulcahey

tests/test_cover.py

@@ -10,7 +10,7 @@
 import logging
 import time
 from types import TracebackType
-from typing import TYPE_CHECKING, Any, Final, Self, TypeVar, cast
+from typing import TYPE_CHECKING, Any, Final, Self, cast
 
 from async_timeout import timeout
 import websockets
@@ -116,7 +116,6 @@
     from zha.zigbee.model import ExtendedDeviceInfo, ZHAEvent
 
 BLOCK_LOG_TIMEOUT: Final[int] = 60
-_R = TypeVar("_R")
 _LOGGER = logging.getLogger(__name__)
 
 

zha/application/gateway.py

@@ -27,7 +27,7 @@
     CoverEntityFeature,
     WCAttrs,
 )
-from zha.application.platforms.cover.model import CoverEntityInfo
+from zha.application.platforms.cover.model import CoverEntityInfo, ShadeEntityInfo
 from zha.application.registries import PLATFORM_ENTITIES
 from zha.exceptions import ZHAException
 from zha.zigbee.cluster_handlers.closures import WindowCoveringClusterHandler
@@ -159,6 +159,13 @@ def supported_features(self) -> CoverEntityFeature:
         """Return supported features."""
         return self._attr_supported_features
 
+    @property
+    def info_object(self) -> CoverEntityInfo:
+        """Return the info object for this entity."""
+        return CoverEntityInfo(
+            **super().info_object.__dict__, supported_features=self.supported_features
+        )
+
     @property
     def state(self) -> dict[str, Any]:
         """Get the state of the cover."""
@@ -469,6 +476,13 @@ def __init__(
             | CoverEntityFeature.SET_POSITION
         )
 
+    @property
+    def info_object(self) -> ShadeEntityInfo:
+        """Return the info object for this entity."""
+        return ShadeEntityInfo(
+            **super().info_object.__dict__, supported_features=self.supported_features
+        )
+
     @property
     def state(self) -> dict[str, Any]:
         """Get the state of the cover."""
@@ -481,6 +495,8 @@ def state(self) -> dict[str, Any]:
             {
                 ATTR_CURRENT_POSITION: self.current_cover_position,
                 "is_closed": self.is_closed,
+                "is_opening": self.is_opening,
+                "is_closing": self.is_closing,
                 "state": state,
             }
         )
@@ -641,24 +657,34 @@ def current_cover_tilt_position(self) -> int | None:
 
     async def async_open_cover(self, **kwargs: Any) -> None:
         """Open the cover."""
+        await self._device.gateway.covers.open_cover(self.info_object)
 
     async def async_open_cover_tilt(self, **kwargs: Any) -> None:
         """Open the cover tilt."""
+        await self._device.gateway.covers.open_cover_tilt(self.info_object)
 
     async def async_close_cover(self, **kwargs: Any) -> None:
         """Close the cover."""
+        await self._device.gateway.covers.close_cover(self.info_object)
 
     async def async_close_cover_tilt(self, **kwargs: Any) -> None:
         """Close the cover tilt."""
+        await self._device.gateway.covers.close_cover_tilt(self.info_object)
 
     async def async_set_cover_position(self, **kwargs: Any) -> None:
         """Move the cover to a specific position."""
+        await self._device.gateway.covers.set_cover_position(self.info_object, **kwargs)
 
     async def async_set_cover_tilt_position(self, **kwargs: Any) -> None:
         """Move the cover tilt to a specific position."""
+        await self._device.gateway.covers.set_cover_tilt_position(
+            self.info_object, **kwargs
+        )
 
     async def async_stop_cover(self, **kwargs: Any) -> None:
         """Stop the cover."""
+        await self._device.gateway.covers.stop_cover(self.info_object)
 
     async def async_stop_cover_tilt(self, **kwargs: Any) -> None:
         """Stop the cover tilt."""
+        await self._device.gateway.covers.stop_cover_tilt(self.info_object)

zha/application/platforms/cover/__init__.py

@@ -4,6 +4,7 @@
 
 from typing import Literal
 
+from zha.application.platforms.cover.const import CoverEntityFeature
 from zha.application.platforms.model import BasePlatformEntityInfo
 from zha.model import BaseModel
 
@@ -13,6 +14,8 @@ class CoverState(BaseModel):
 
     class_name: Literal["Cover"] = "Cover"
     current_position: int | None = None
+    target_lift_position: int | None = None
+    target_tilt_position: int | None = None
     state: str | None = None
     is_opening: bool
     is_closing: bool
@@ -34,11 +37,13 @@ class CoverEntityInfo(BasePlatformEntityInfo):
     """Cover entity model."""
 
     class_name: Literal["Cover"]
+    supported_features: CoverEntityFeature
     state: CoverState
 
 
 class ShadeEntityInfo(BasePlatformEntityInfo):
     """Shade entity model."""
 
     class_name: Literal["Shade", "KeenVent"]
+    supported_features: CoverEntityFeature
     state: ShadeState

zha/application/platforms/cover/model.py

@@ -31,6 +31,24 @@ async def open_cover(server: Server, client: Client, command: CoverOpenCommand)
     await execute_platform_entity_command(server, client, command, "async_open_cover")
 
 
+class CoverOpenTiltCommand(PlatformEntityCommand):
+    """Cover open tilt command."""
+
+    command: Literal[APICommands.COVER_OPEN_TILT] = APICommands.COVER_OPEN_TILT
+    platform: str = Platform.COVER
+
+
+@decorators.websocket_command(CoverOpenTiltCommand)
+@decorators.async_response
+async def open_cover_tilt(
+    server: Server, client: Client, command: CoverOpenTiltCommand
+) -> None:
+    """Open the cover tilt."""
+    await execute_platform_entity_command(
+        server, client, command, "async_open_cover_tilt"
+    )
+
+
 class CoverCloseCommand(PlatformEntityCommand):
     """Cover close command."""
 
@@ -47,6 +65,24 @@ async def close_cover(
     await execute_platform_entity_command(server, client, command, "async_close_cover")
 
 
+class CoverCloseTiltCommand(PlatformEntityCommand):
+    """Cover close tilt command."""
+
+    command: Literal[APICommands.COVER_CLOSE_TILT] = APICommands.COVER_CLOSE_TILT
+    platform: str = Platform.COVER
+
+
+@decorators.websocket_command(CoverCloseTiltCommand)
+@decorators.async_response
+async def close_cover_tilt(
+    server: Server, client: Client, command: CoverCloseTiltCommand
+) -> None:
+    """Close the cover tilt."""
+    await execute_platform_entity_command(
+        server, client, command, "async_close_cover_tilt"
+    )
+
+
 class CoverSetPositionCommand(PlatformEntityCommand):
     """Cover set position command."""
 
@@ -66,6 +102,27 @@ async def set_position(
     )
 
 
+class CoverSetTiltPositionCommand(PlatformEntityCommand):
+    """Cover set position command."""
+
+    command: Literal[APICommands.COVER_SET_TILT_POSITION] = (
+        APICommands.COVER_SET_TILT_POSITION
+    )
+    platform: str = Platform.COVER
+    tilt_position: int
+
+
+@decorators.websocket_command(CoverSetTiltPositionCommand)
+@decorators.async_response
+async def set_tilt_position(
+    server: Server, client: Client, command: CoverSetTiltPositionCommand
+) -> None:
+    """Set the cover tilt position."""
+    await execute_platform_entity_command(
+        server, client, command, "async_set_cover_tilt_position"
+    )
+
+
 class CoverStopCommand(PlatformEntityCommand):
     """Cover stop command."""
 
@@ -80,9 +137,31 @@ async def stop_cover(server: Server, client: Client, command: CoverStopCommand)
     await execute_platform_entity_command(server, client, command, "async_stop_cover")
 
 
+class CoverStopTiltCommand(PlatformEntityCommand):
+    """Cover stop tilt command."""
+
+    command: Literal[APICommands.COVER_STOP_TILT] = APICommands.COVER_STOP_TILT
+    platform: str = Platform.COVER
+
+
+@decorators.websocket_command(CoverStopTiltCommand)
+@decorators.async_response
+async def stop_cover_tilt(
+    server: Server, client: Client, command: CoverStopTiltCommand
+) -> None:
+    """Stop the cover tilt."""
+    await execute_platform_entity_command(
+        server, client, command, "async_stop_cover_tilt"
+    )
+
+
 def load_api(server: Server) -> None:
     """Load the api command handlers."""
     register_api_command(server, open_cover)
     register_api_command(server, close_cover)
     register_api_command(server, set_position)
     register_api_command(server, stop_cover)
+    register_api_command(server, open_cover_tilt)
+    register_api_command(server, close_cover_tilt)
+    register_api_command(server, set_tilt_position)
+    register_api_command(server, stop_cover_tilt)

zha/application/platforms/cover/websocket_api.py

@@ -17,13 +17,14 @@
     WebSocketCommand,
     WriteClusterAttributeResponse,
 )
-from zha.zigbee.device import Device
-from zha.zigbee.group import Group
 from zha.zigbee.model import GroupMemberReference
 
 if TYPE_CHECKING:
     from zha.application.gateway import WebSocketServerGateway
     from zha.websocket.server.client import Client
+    from zha.zigbee.device import Device
+    from zha.zigbee.group import Group
+
 
 GROUP = "group"
 MFG_CLUSTER_ID_START = 0xFC00

zha/application/websocket_api.py

@@ -24,8 +24,11 @@
 )
 from zha.application.platforms.cover.websocket_api import (
     CoverCloseCommand,
+    CoverCloseTiltCommand,
     CoverOpenCommand,
+    CoverOpenTiltCommand,
     CoverSetPositionCommand,
+    CoverSetTiltPositionCommand,
     CoverStopCommand,
 )
 from zha.application.platforms.fan.model import FanEntityInfo
@@ -284,6 +287,28 @@ async def close_cover(
         )
         return await self._client.async_send_command(command)
 
+    async def open_cover_tilt(
+        self, cover_platform_entity: BasePlatformEntityInfo
+    ) -> WebSocketCommandResponse:
+        """Open cover tilt."""
+        ensure_platform_entity(cover_platform_entity, Platform.COVER)
+        command = CoverOpenTiltCommand(
+            ieee=cover_platform_entity.device_ieee,
+            unique_id=cover_platform_entity.unique_id,
+        )
+        return await self._client.async_send_command(command)
+
+    async def close_cover_tilt(
+        self, cover_platform_entity: BasePlatformEntityInfo
+    ) -> WebSocketCommandResponse:
+        """Open cover tilt."""
+        ensure_platform_entity(cover_platform_entity, Platform.COVER)
+        command = CoverCloseTiltCommand(
+            ieee=cover_platform_entity.device_ieee,
+            unique_id=cover_platform_entity.unique_id,
+        )
+        return await self._client.async_send_command(command)
+
     async def stop_cover(
         self, cover_platform_entity: BasePlatformEntityInfo
     ) -> WebSocketCommandResponse:
@@ -309,6 +334,31 @@ async def set_cover_position(
         )
         return await self._client.async_send_command(command)
 
+    async def set_cover_tilt_position(
+        self,
+        cover_platform_entity: BasePlatformEntityInfo,
+        tilt_position: int,
+    ) -> WebSocketCommandResponse:
+        """Set a cover tilt position."""
+        ensure_platform_entity(cover_platform_entity, Platform.COVER)
+        command = CoverSetTiltPositionCommand(
+            ieee=cover_platform_entity.device_ieee,
+            unique_id=cover_platform_entity.unique_id,
+            tilt_position=tilt_position,
+        )
+        return await self._client.async_send_command(command)
+
+    async def stop_cover_tilt(
+        self, cover_platform_entity: BasePlatformEntityInfo
+    ) -> WebSocketCommandResponse:
+        """Stop a cover tilt."""
+        ensure_platform_entity(cover_platform_entity, Platform.COVER)
+        command = CoverStopCommand(
+            ieee=cover_platform_entity.device_ieee,
+            unique_id=cover_platform_entity.unique_id,
+        )
+        return await self._client.async_send_command(command)
+
 
 class FanHelper:
     """Helper to issue fan commands."""

zha/websocket/client/helpers.py

@@ -54,9 +54,13 @@ class APICommands(StrEnum):
     CLIMATE_SET_PRESET_MODE = "climate_set_preset_mode"
 
     COVER_OPEN = "cover_open"
+    COVER_OPEN_TILT = "cover_open_tilt"
     COVER_CLOSE = "cover_close"
+    COVER_CLOSE_TILT = "cover_close_tilt"
     COVER_STOP = "cover_stop"
     COVER_SET_POSITION = "cover_set_position"
+    COVER_SET_TILT_POSITION = "cover_set_tilt_position"
+    COVER_STOP_TILT = "cover_stop_tilt"
 
     FAN_TURN_ON = "fan_turn_on"
     FAN_TURN_OFF = "fan_turn_off"

zha/websocket/const.py

@@ -75,6 +75,10 @@ class WebSocketCommand(BaseModel):
         APICommands.COVER_SET_POSITION,
         APICommands.COVER_OPEN,
         APICommands.COVER_CLOSE,
+        APICommands.COVER_OPEN_TILT,
+        APICommands.COVER_CLOSE_TILT,
+        APICommands.COVER_SET_TILT_POSITION,
+        APICommands.COVER_STOP_TILT,
         APICommands.CLIMATE_SET_TEMPERATURE,
         APICommands.CLIMATE_SET_HVAC_MODE,
         APICommands.CLIMATE_SET_FAN_MODE,
@@ -118,9 +122,13 @@ class ErrorResponse(WebSocketCommandResponse):
         "error.fan_set_percentage",
         "error.fan_set_preset_mode",
         "error.cover_open",
+        "error.cover_open_tilt",
         "error.cover_close",
+        "error.cover_close_tilt",
         "error.cover_set_position",
+        "error.cover_set_tilt_position",
         "error.cover_stop",
+        "error.cover_stop_tilt",
         "error.climate_set_fan_mode",
         "error.climate_set_hvac_mode",
         "error.climate_set_preset_mode",
@@ -170,6 +178,10 @@ class DefaultResponse(WebSocketCommandResponse):
         "cover_close",
         "cover_set_position",
         "cover_stop",
+        "cover_stop_tilt",
+        "cover_open_tilt",
+        "cover_close_tilt",
+        "cover_set_tilt_position",
         "climate_set_fan_mode",
         "climate_set_hvac_mode",
         "climate_set_preset_mode",