Risco integration

CODEOWNERS

@@ -345,6 +345,7 @@ homeassistant/components/random/* @fabaff
 homeassistant/components/repetier/* @MTrab
 homeassistant/components/rfxtrx/* @danielhiversen @elupus
 homeassistant/components/ring/* @balloob
+homeassistant/components/risco/* @OnFreund
 homeassistant/components/rmvtransport/* @cgtobi
 homeassistant/components/roku/* @ctalkington
 homeassistant/components/roomba/* @pschmitt @cyr-ius @shenxn

homeassistant/components/risco/__init__.py

@@ -0,0 +1,49 @@
+"""The Risco integration."""
+import asyncio
+
+from pyrisco import RiscoAPI
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_PASSWORD, CONF_PIN, CONF_USERNAME
+from homeassistant.core import HomeAssistant
+
+from .const import DOMAIN
+
+PLATFORMS = ["alarm_control_panel"]
+
+
+async def async_setup(hass: HomeAssistant, config: dict):
+    """Set up the Risco component."""
+    return True
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry):
+    """Set up Risco from a config entry."""
+    data = entry.data
+    risco = RiscoAPI(data[CONF_USERNAME], data[CONF_PASSWORD], data[CONF_PIN])
+    await risco.login()
+    hass.data.setdefault(DOMAIN, {})[entry.entry_id] = risco
+
+    for component in PLATFORMS:
+        hass.async_create_task(
+            hass.config_entries.async_forward_entry_setup(entry, component)
+        )
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry):
+    """Unload a config entry."""
+    unload_ok = all(
+        await asyncio.gather(
+            *[
+                hass.config_entries.async_forward_entry_unload(entry, component)
+                for component in PLATFORMS
+            ]
+        )
+    )
+    if unload_ok:
+        risco = hass.data[DOMAIN].pop(entry.entry_id)
+        await risco.close()
+
+    return unload_ok

homeassistant/components/risco/alarm_control_panel.py

@@ -0,0 +1,133 @@
+"""Support for Risco alarms."""
+import logging
+
+import homeassistant.components.alarm_control_panel as alarm
+from homeassistant.components.alarm_control_panel.const import (
+    SUPPORT_ALARM_ARM_AWAY,
+    SUPPORT_ALARM_ARM_CUSTOM_BYPASS,
+    SUPPORT_ALARM_ARM_HOME,
+    SUPPORT_ALARM_ARM_NIGHT,
+)
+from homeassistant.const import (
+    STATE_ALARM_ARMED_AWAY,
+    STATE_ALARM_ARMED_CUSTOM_BYPASS,
+    STATE_ALARM_ARMED_HOME,
+    STATE_ALARM_ARMED_NIGHT,
+    STATE_ALARM_ARMING,
+    STATE_ALARM_DISARMED,
+    STATE_ALARM_TRIGGERED,
+    STATE_UNKNOWN,
+)
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+SUPPORTED_STATES = [
+    STATE_ALARM_DISARMED,
+    STATE_ALARM_ARMED_AWAY,
+    STATE_ALARM_ARMED_HOME,
+    STATE_ALARM_ARMED_NIGHT,
+    STATE_ALARM_ARMED_CUSTOM_BYPASS,
+    STATE_ALARM_TRIGGERED,
+]
+
+
+async def async_setup_entry(hass, config_entry, async_add_entities):
+    """Set up the Risco alarm control panel."""
+    risco = hass.data[DOMAIN][config_entry.entry_id]
+    alarm = await risco.get_state()
+    entities = [RiscoAlarm(hass, risco, partition) for partition in alarm.partitions]
+
+    async_add_entities(entities, False)
+
+
+class RiscoAlarm(alarm.AlarmControlPanelEntity):
+    """Representation of a Risco partition."""
+
+    def __init__(self, hass, risco, partition):
+        """Init the partition."""
+        self._hass = hass
+        self._risco = risco
+        self._state = partition
+        self._partition_id = partition.id
+
+    @property
+    def device_info(self):
+        """Return device info for this device."""
+        return {
+            "identifiers": {(DOMAIN, self.unique_id)},
+            "name": self.unique_id,
+            "manufacturer": "Risco",
+        }
+
+    @property
+    def unique_id(self):
+        """Return a unique id for that partition."""
+        return f"{self._risco.site_id}_{self._partition_id}"
+
+    @property
+    def state(self):
+        """Return the state of the device."""
+        if self._state.triggered:
+            return STATE_ALARM_TRIGGERED
+        elif self._state.arming:
+            return STATE_ALARM_ARMING
+        elif self._state.armed:
+            return STATE_ALARM_ARMED_AWAY
+        elif self._state.partially_armed:
+            return STATE_ALARM_ARMED_HOME
+        elif self._state.disarmed:
+            return STATE_ALARM_DISARMED
+
+        return STATE_UNKNOWN
+
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return (
+            SUPPORT_ALARM_ARM_HOME
+            | SUPPORT_ALARM_ARM_AWAY
+            | SUPPORT_ALARM_ARM_NIGHT
+            | SUPPORT_ALARM_ARM_CUSTOM_BYPASS
+        )
+
+    @property
+    def code_arm_required(self):
+        """Whether the code is required for arm actions."""
+        return False
+
+    async def async_alarm_disarm(self, code=None):
+        """Send disarm command."""
+        alarm = await self._risco.disarm(self._partition_id)
+        self._state = alarm.partitions[self._partition_id]
+        self.async_write_ha_state()
+
+    async def async_alarm_arm_home(self, code=None):
+        """Send arm home command."""
+        alarm = await self._risco.partial_arm(self._partition_id)
+        self._state = alarm.partitions[self._partition_id]
+        self.async_write_ha_state()
+
+    async def async_alarm_arm_night(self, code=None):
+        """Send arm night command."""
+        alarm = await self._risco.partial_arm(self._partition_id)
+        self._state = alarm.partitions[self._partition_id]
+        self.async_write_ha_state()
+
+    async def async_alarm_arm_custom_bypass(self, code=None):
+        """Send arm custom bypass command."""
+        alarm = await self._risco.partial_arm(self._partition_id)
+        self._state = alarm.partitions[self._partition_id]
+        self.async_write_ha_state()
+
+    async def async_alarm_arm_away(self, code=None):
+        """Send arm away command."""
+        alarm = await self._risco.arm(self._partition_id)
+        self._state = alarm.partitions[self._partition_id]
+        self.async_write_ha_state()
+
+    async def async_update(self):
+        """Retrieve latest state."""
+        alarm = await self._risco.get_state()
+        self._state = alarm.partitions[self._partition_id]

homeassistant/components/risco/config_flow.py

@@ -0,0 +1,71 @@
+"""Config flow for Risco integration."""
+import logging
+
+from pyrisco import CannotConnectError, RiscoAPI, UnauthorizedError
+import voluptuous as vol
+
+from homeassistant import config_entries, core, exceptions
+from homeassistant.const import CONF_PASSWORD, CONF_PIN, CONF_USERNAME
+
+from .const import DOMAIN  # pylint:disable=unused-import
+
+_LOGGER = logging.getLogger(__name__)
+
+
+DATA_SCHEMA = vol.Schema({CONF_USERNAME: str, CONF_PASSWORD: str, CONF_PIN: str})
+
+
+async def validate_input(hass: core.HomeAssistant, data):
+    """Validate the user input allows us to connect.
+
+    Data has the keys from DATA_SCHEMA with values provided by the user.
+    """
+    risco = RiscoAPI(data[CONF_USERNAME], data[CONF_PASSWORD], data[CONF_PIN])
+
+    try:
+        await risco.login()
+        return {"title": risco.site_id}
+    except UnauthorizedError as e:
+        _LOGGER.error("Unauthorized connection to Risco Cloud")
+        raise InvalidAuth from e
+    except CannotConnectError as e:
+        _LOGGER.error("Error connecting to Risco Cloud")
+        raise CannotConnect from e
+    finally:
+        await risco.close()
+
+
+class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Risco."""
+
+    VERSION = 1
+    # TODO pick one of the available connection classes in homeassistant/config_entries.py
+    CONNECTION_CLASS = config_entries.CONN_CLASS_CLOUD_POLL
+
+    async def async_step_user(self, user_input=None):
+        """Handle the initial step."""
+        errors = {}
+        if user_input is not None:
+            try:
+                info = await validate_input(self.hass, user_input)
+
+                return self.async_create_entry(title=info["title"], data=user_input)
+            except CannotConnect:
+                errors["base"] = "cannot_connect"
+            except InvalidAuth:
+                errors["base"] = "invalid_auth"
+            except Exception:  # pylint: disable=broad-except
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+
+        return self.async_show_form(
+            step_id="user", data_schema=DATA_SCHEMA, errors=errors
+        )
+
+
+class CannotConnect(exceptions.HomeAssistantError):
+    """Error to indicate we cannot connect."""
+
+
+class InvalidAuth(exceptions.HomeAssistantError):
+    """Error to indicate there is invalid auth."""

homeassistant/components/risco/const.py

@@ -0,0 +1,3 @@
+"""Constants for the Risco integration."""
+
+DOMAIN = "risco"

homeassistant/components/risco/manifest.json

@@ -0,0 +1,16 @@
+{
+  "domain": "risco",
+  "name": "Risco",
+  "config_flow": true,
+  "documentation": "https://www.home-assistant.io/integrations/risco",
+  "requirements": [
+    "pyrisco==0.1.0"
+  ],
+  "ssdp": [],
+  "zeroconf": [],
+  "homekit": {},
+  "dependencies": [],
+  "codeowners": [
+    "@OnFreund"
+  ]
+}

homeassistant/components/risco/strings.json

@@ -0,0 +1,22 @@
+{
+  "title": "Risco",
+  "config": {
+    "step": {
+      "user": {
+        "data": {
+          "username": "[%key:common::config_flow::data::username%]",
+          "password": "[%key:common::config_flow::data::password%]",
+          "pin": "Pin code"
+        }
+      }
+    },
+    "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
+    },
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
+    }
+  }
+}

homeassistant/generated/config_flows.py

@@ -142,6 +142,7 @@
     "rachio",
     "rainmachine",
     "ring",
+    "risco",
     "roku",
     "roomba",
     "roon",

requirements_all.txt

@@ -1594,6 +1594,9 @@ pyrecswitch==1.0.2
 # homeassistant.components.repetier
 pyrepetier==3.0.5
 
+# homeassistant.components.risco
+pyrisco==0.1.0
+
 # homeassistant.components.sabnzbd
 pysabnzbd==1.1.0
 

requirements_test_all.txt

@@ -750,6 +750,9 @@ pyps4-2ndscreen==1.1.1
 # homeassistant.components.qwikswitch
 pyqwikswitch==0.93
 
+# homeassistant.components.risco
+pyrisco==0.1.0
+
 # homeassistant.components.acer_projector
 # homeassistant.components.zha
 pyserial==3.4

tests/components/risco/__init__.py

@@ -0,0 +1 @@
+"""Tests for the Risco integration."""