153 lines
5.1 KiB
Python
153 lines
5.1 KiB
Python
"""Platform for the cover integration."""
|
|
|
|
from abc import ABC
|
|
import logging
|
|
from typing import Any, Callable, List
|
|
|
|
from wyzeapy import Wyzeapy, CameraService
|
|
from wyzeapy.services.camera_service import Camera
|
|
from wyzeapy.exceptions import AccessTokenError, ParameterError, UnknownApiError
|
|
from wyzeapy.types import DeviceTypes
|
|
|
|
import homeassistant.components.cover
|
|
from homeassistant.config_entries import ConfigEntry
|
|
from homeassistant.const import ATTR_ATTRIBUTION
|
|
from homeassistant.core import HomeAssistant, callback
|
|
from homeassistant.helpers.dispatcher import async_dispatcher_connect
|
|
from homeassistant.helpers import device_registry as dr
|
|
from homeassistant.exceptions import HomeAssistantError
|
|
from homeassistant.components.cover import CoverDeviceClass, CoverEntityFeature
|
|
|
|
|
|
from .const import CAMERA_UPDATED, CONF_CLIENT, DOMAIN
|
|
from .token_manager import token_exception_handler
|
|
|
|
_LOGGER = logging.getLogger(__name__)
|
|
ATTRIBUTION = "Data provided by Wyze"
|
|
|
|
|
|
@token_exception_handler
|
|
async def async_setup_entry(
|
|
hass: HomeAssistant,
|
|
config_entry: ConfigEntry,
|
|
async_add_entities: Callable[[List[Any], bool], None],
|
|
) -> None:
|
|
"""
|
|
This function sets up the config_entry
|
|
|
|
:param hass: Home Assistant instance
|
|
:param config_entry: The current config_entry
|
|
:param async_add_entities: This function adds entities to the config_entry
|
|
:return:
|
|
"""
|
|
|
|
_LOGGER.debug("""Creating new WyzeApi cover component""")
|
|
client: Wyzeapy = hass.data[DOMAIN][config_entry.entry_id][CONF_CLIENT]
|
|
camera_service = await client.camera_service
|
|
cameras: List[Camera] = await camera_service.get_cameras()
|
|
garages = []
|
|
for camera in cameras:
|
|
if camera.device_params["dongle_product_model"] == "HL_CGDC":
|
|
garages.append(WyzeGarageDoor(camera_service, camera))
|
|
|
|
async_add_entities(garages, True)
|
|
|
|
|
|
class WyzeGarageDoor(homeassistant.components.cover.CoverEntity, ABC):
|
|
"""Representation of a Wyze Garage Door."""
|
|
|
|
_attr_device_class = CoverDeviceClass.GARAGE
|
|
_attr_supported_features = CoverEntityFeature.OPEN | CoverEntityFeature.CLOSE
|
|
_attr_has_entity_name = True
|
|
|
|
def __init__(self, camera_service: CameraService, camera: Camera):
|
|
"""Initialize a Wyze garage door."""
|
|
self._camera = camera
|
|
if self._camera.type not in [DeviceTypes.CAMERA]:
|
|
raise HomeAssistantError(f"Invalid device type: {self._camera.type}")
|
|
|
|
self._camera_service = camera_service
|
|
self._available = self._camera.available
|
|
|
|
@property
|
|
def device_info(self):
|
|
"""Return device information about this entity."""
|
|
return {
|
|
"identifiers": {(DOMAIN, self._camera.mac)},
|
|
"name": f"{self._camera.nickname}",
|
|
"connections": {(dr.CONNECTION_NETWORK_MAC, self._camera.mac)},
|
|
}
|
|
|
|
@property
|
|
def extra_state_attributes(self):
|
|
"""Return device attributes of the entity."""
|
|
return {
|
|
ATTR_ATTRIBUTION: ATTRIBUTION,
|
|
"device model": f"{self._camera.product_model}.{self._camera.device_params['dongle_product_model']}",
|
|
}
|
|
|
|
@property
|
|
def should_poll(self) -> bool:
|
|
return False
|
|
|
|
@token_exception_handler
|
|
async def async_open_cover(self, **kwargs):
|
|
"""Open the cover."""
|
|
try:
|
|
await self._camera_service.garage_door_open(self._camera)
|
|
except (AccessTokenError, ParameterError, UnknownApiError) as err:
|
|
raise HomeAssistantError(f"Wyze returned an error: {err.args}") from err
|
|
except Exception as err:
|
|
raise HomeAssistantError(err) from err
|
|
else:
|
|
self._camera.garage = True
|
|
self.async_write_ha_state()
|
|
|
|
@token_exception_handler
|
|
async def async_close_cover(self, **kwargs):
|
|
"""Close the cover."""
|
|
try:
|
|
await self._camera_service.garage_door_close(self._camera)
|
|
except (AccessTokenError, ParameterError, UnknownApiError) as err:
|
|
raise HomeAssistantError(f"Wyze returned an error: {err.args}") from err
|
|
except Exception as err:
|
|
raise HomeAssistantError(err) from err
|
|
else:
|
|
self._camera.garage = False
|
|
self.async_write_ha_state()
|
|
|
|
@property
|
|
def is_closed(self):
|
|
"""Return if the cover is closed."""
|
|
return not self._camera.garage
|
|
|
|
@property
|
|
def available(self):
|
|
"""Return the connection status of this cover."""
|
|
return self._camera.available
|
|
|
|
@property
|
|
def unique_id(self):
|
|
"""Define a unique id for this entity."""
|
|
return f"{self._camera.mac}_GarageDoor"
|
|
|
|
@property
|
|
def name(self):
|
|
"""Return the name of the garage door."""
|
|
return "Garage Door"
|
|
|
|
async def async_added_to_hass(self) -> None:
|
|
self.async_on_remove(
|
|
async_dispatcher_connect(
|
|
self.hass,
|
|
f"{CAMERA_UPDATED}-{self._camera.mac}",
|
|
self.handle_camera_update,
|
|
)
|
|
)
|
|
|
|
@callback
|
|
def handle_camera_update(self, camera: Camera) -> None:
|
|
"""Update the cover whenever there is an update"""
|
|
self._camera = camera
|
|
self.async_write_ha_state()
|