Ihc component and platforms

.coveragerc

@@ -88,6 +88,9 @@ omit =
     homeassistant/components/homematic.py
     homeassistant/components/*/homematic.py
 
+    homeassistant/components/ihc/*
+    homeassistant/components/*/ihc.py
+
     homeassistant/components/insteon_local.py
     homeassistant/components/*/insteon_local.py
 

homeassistant/components/binary_sensor/ihc.py

@@ -0,0 +1,168 @@
+"""
+IHC binary sensor platform.
+"""
+# pylint: disable=too-many-arguments, too-many-instance-attributes, bare-except, missing-docstring
+import logging
+import voluptuous as vol
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA, DEVICE_CLASSES_SCHEMA)
+from homeassistant.const import STATE_UNKNOWN, CONF_NAME, CONF_TYPE, CONF_ID, CONF_BINARY_SENSORS
+
+from homeassistant.components.ihc.const import CONF_AUTOSETUP, CONF_INVERTING
+from homeassistant.components.ihc import get_ihc_platform
+from homeassistant.components.ihc.ihcdevice import IHCDevice
+
+DEPENDENCIES = ['ihc']
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_AUTOSETUP, default='False'): cv.boolean,
+    vol.Optional(CONF_BINARY_SENSORS) :
+        [{
+            vol.Required(CONF_ID): cv.positive_int,
+            vol.Optional(CONF_NAME): cv.string,
+            vol.Optional(CONF_TYPE): DEVICE_CLASSES_SCHEMA,
+            vol.Optional(CONF_INVERTING): cv.boolean,
+        }]
+})
+
+
+PRODUCTAUTOSETUP = [
+    # Magnet contact
+    {'xpath': './/product_dataline[@product_identifier="_0x2109"]',
+     'node': 'dataline_input',
+     'type': 'opening',
+     'inverting': True},
+    # Pir sensors
+    {'xpath': './/product_dataline[@product_identifier="_0x210e"]',
+     'node': 'dataline_input',
+     'type': 'motion',
+     'inverting': False},
+    # Pir sensors twilight sensor
+    {'xpath': './/product_dataline[@product_identifier="_0x0"]',
+     'node': 'dataline_input',
+     'type': 'motion',
+     'inverting': False},
+    # Pir sensors alarm
+    {'xpath': './/product_dataline[@product_identifier="_0x210f"]',
+     'node': 'dataline_input',
+     'type': 'motion',
+     'inverting': False},
+    # Smoke detector
+    {'xpath': './/product_dataline[@product_identifier="_0x210a"]',
+     'node': 'dataline_input',
+     'type': 'smoke',
+     'inverting': False},
+    # leak detector
+    {'xpath': './/product_dataline[@product_identifier="_0x210c"]',
+     'node': 'dataline_input',
+     'type': 'moisture',
+     'inverting': False},
+    # light detector
+    {'xpath': './/product_dataline[@product_identifier="_0x2110"]',
+     'node': 'dataline_input',
+     'type': 'light',
+     'inverting': False},
+]
+
+_LOGGER = logging.getLogger(__name__)
+_IHCBINARYSENSORS = {}
+
+# pylint: disable=unused-argument
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the IHC binary setsor platform."""
+    ihcplatform = get_ihc_platform(hass)
+    devices = []
+    if config.get(CONF_AUTOSETUP):
+        auto_setup(ihcplatform, devices)
+
+    binarysensors = config.get(CONF_BINARY_SENSORS)
+    if binarysensors:
+        _LOGGER.info("Adding IHC Binary Sensors")
+        for binarysensor in binarysensors:
+            ihcid = binarysensor[CONF_ID]
+            name = binarysensor[CONF_NAME] if CONF_NAME in binarysensor else "ihc_" + str(ihcid)
+            sensortype = binarysensor[CONF_TYPE] if CONF_TYPE in binarysensor else None
+            inverting = binarysensor[CONF_INVERTING] if CONF_INVERTING in binarysensor else False
+            add_sensor(devices, ihcplatform.ihc, int(ihcid), name, sensortype, True, inverting)
+
+    add_devices(devices)
+    # Start notification after devices has been added
+    for device in devices:
+        device.ihc.add_notify_event(device.get_ihcid(), device.on_ihc_change, True)
+
+def auto_setup(ihcplatform, devices):
+    """auto setup ihc binary sensors from ihc project."""
+    _LOGGER.info("Auto setup - IHC Binary sensors")
+    def setup_product(ihcid, name, product, productcfg):
+        add_sensor_from_node(devices, ihcplatform.ihc, ihcid, name,
+                             product, productcfg['type'],
+                             productcfg['inverting'])
+    ihcplatform.autosetup(PRODUCTAUTOSETUP, setup_product)
+
+
+class IHCBinarySensor(IHCDevice, BinarySensorDevice):
+    """IHC Binary Sensor."""
+    def __init__(self, ihccontroller, name, ihcid, sensortype: str, inverting: bool,
+                 ihcname: str, ihcnote: str, ihcposition: str):
+        IHCDevice.__init__(self, ihccontroller, name, ihcid, ihcname, ihcnote, ihcposition)
+        self._state = STATE_UNKNOWN
+        self._sensor_type = sensortype
+        self.inverting = inverting
+
+    @property
+    def should_poll(self):
+        """Return the polling state."""
+        return False
+
+    @property
+    def device_class(self):
+        """Return the class of this sensor."""
+        return self._sensor_type
+
+    @property
+    def is_on(self):
+        """Return true if the binary sensor is on/open."""
+        return self._state
+
+    def update(self):
+        pass
+
+    def on_ihc_change(self, ihcid, value):
+        """Callback when ihc resource changes."""
+        try:
+            if self.inverting:
+                self._state = not value
+            else:
+                self._state = value
+            self.schedule_update_ha_state()
+        except:
+            pass
+
+
+def add_sensor_from_node(devices, ihccontroller, ihcid: int, name: str,
+                         product, sensortype, inverting: bool) -> IHCBinarySensor:
+    """Add a sensor from the ihc project node."""
+    ihcname = product.attrib['name']
+    ihcnote = product.attrib['note']
+    ihcposition = product.attrib['position']
+    return add_sensor(devices, ihccontroller, ihcid, name, sensortype, False,
+                      inverting, ihcname, ihcnote, ihcposition)
+
+def add_sensor(devices, ihccontroller, ihcid: int, name: str,
+               sensortype: str = None, overwrite: bool = False,
+               inverting: bool = False, ihcname: str = "",
+               ihcnote: str = "", ihcposition: str = "") -> IHCBinarySensor:
+    """Add a new a sensor."""
+    if ihcid in _IHCBINARYSENSORS:
+        sensor = _IHCBINARYSENSORS[ihcid]
+        if overwrite:
+            sensor.set_name(name)
+            _LOGGER.info("IHC sensor set name: " + name + " " + str(ihcid))
+    else:
+        sensor = IHCBinarySensor(ihccontroller, name, ihcid, sensortype,
+                                 inverting, ihcname, ihcnote, ihcposition)
+        _IHCBINARYSENSORS[ihcid] = sensor
+        devices.append(sensor)
+        _LOGGER.info("IHC sensor added: " + name + " " + str(ihcid))
+    return sensor

homeassistant/components/ihc/__init__.py

@@ -0,0 +1,125 @@
+"""
+IHC platform.
+"""
+# pylint: disable=too-many-arguments, too-many-instance-attributes, bare-except
+import time
+import logging
+import os.path
+import asyncio
+import xml.etree.ElementTree
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.const import CONF_URL, CONF_USERNAME, CONF_PASSWORD
+from homeassistant.config import load_yaml_config_file
+
+from homeassistant.components.ihc import const
+
+REQUIREMENTS = ['ihcsdk==2.1.0']
+DOMAIN = 'ihc'
+
+CONF_INFO = 'info'
+
+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: vol.Schema({
+        vol.Required(CONF_URL): cv.string,
+        vol.Required(CONF_USERNAME): cv.string,
+        vol.Required(CONF_PASSWORD): cv.string,
+        vol.Required(CONF_INFO): cv.boolean
+    }),
+}, extra=vol.ALLOW_EXTRA)
+
+_LOGGER = logging.getLogger(__name__)
+
+def setup(hass, config):
+    """Setyp the IHC platform."""
+    from ihcsdk.ihccontroller import IHCController
+    url = config[DOMAIN].get(CONF_URL)
+    username = config[DOMAIN].get(CONF_USERNAME)
+    password = config[DOMAIN].get(CONF_PASSWORD)
+    ihc = IHCController(url, username, password)
+    ihc.info = config[DOMAIN].get(CONF_INFO)
+
+    if  not ihc.authenticate():
+        _LOGGER.error("Unable to authenticate on ihc controller. Username/password may be wrong")
+        return False
+
+    hass.data[DOMAIN] = IHCPlatform(ihc)
+
+    #Service functions
+
+    def set_runtime_value_bool(call):
+        """Set a IHC runtime bool value service function """
+        ihcid = int(call.data.get('ihcid', 0))
+        value = bool(call.data.get('value', 0))
+        ihc.set_runtime_value_bool(ihcid, value)
+
+    def set_runtime_value_int(call):
+        """Set a IHC runtime integer value service function """
+        ihcid = int(call.data.get('ihcid', 0))
+        value = int(call.data.get('value', 0))
+        ihc.set_runtime_value_int(ihcid, value)
+
+    def set_runtime_value_float(call):
+        """Set a IHC runtime float value service function """
+        ihcid = int(call.data.get('ihcid', 0))
+        value = float(call.data.get('value', 0))
+        ihc.set_runtime_value_float(ihcid, value)
+
+    descriptions = load_yaml_config_file(
+        os.path.join(os.path.dirname(__file__), 'services.yaml'))
+
+    hass.services.register(DOMAIN, const.SERVICE_SET_RUNTIME_VALUE_BOOL,
+                           set_runtime_value_bool,
+                           descriptions[const.SERVICE_SET_RUNTIME_VALUE_BOOL])
+    hass.services.register(DOMAIN, const.SERVICE_SET_RUNTIME_VALUE_INT,
+                           set_runtime_value_int,
+                           descriptions[const.SERVICE_SET_RUNTIME_VALUE_INT])
+    hass.services.register(DOMAIN, const.SERVICE_SET_RUNTIME_VALUE_FLOAT,
+                           set_runtime_value_float,
+                           descriptions[const.SERVICE_SET_RUNTIME_VALUE_FLOAT])
+
+    #hass.http.register_view(IHCSetupView())
+    return True
+
+
+
+class IHCPlatform:
+    """Wraps the IHCController for caching of ihc project and autosetup"""
+    def __init__(self, ihccontroller):
+        self.ihc = ihccontroller
+        project = self.ihc.get_project()
+        self._project = xml.etree.ElementTree.fromstring(project)
+        self._groups = self._project.findall(r'.//group')
+
+    def get_project_xml(self):
+        """Get the cached ihc project as xml"""
+        return self._project
+
+    def get_groups_xml(self):
+        """Get the groups from the ihc project and cache the result"""
+        return self._groups
+
+    def autosetup(self, productautosetup, callback):
+        """Do autosetup of a component usign the specified productautosetup"""
+        groups = self.get_groups_xml()
+        for group in groups:
+            groupname = group.attrib['name']
+            for productcfg in productautosetup:
+                products = group.findall(productcfg['xpath'])
+                for product in products:
+                    nodes = product.findall(productcfg['node'])
+                    for node in nodes:
+                        if 'setting' in node.attrib and node.attrib['setting'] == 'yes':
+                            continue
+                        ihcid = int(node.attrib['id'].strip('_'), 0)
+                        name = groupname + "_" + str(ihcid)
+                        callback(ihcid, name, product, productcfg)
+
+def get_ihc_platform(hass) -> IHCPlatform:
+    """Get the ihc platform instance from the hass configuration
+    This is a singleton object.
+    """
+    while not DOMAIN in hass.data:
+        time.sleep(0.1)
+    return hass.data[DOMAIN]

homeassistant/components/ihc/const.py

@@ -0,0 +1,11 @@
+"""
+IHC platform constants
+"""
+
+CONF_AUTOSETUP = 'autosetup'
+CONF_INVERTING = 'inverting'
+
+
+SERVICE_SET_RUNTIME_VALUE_BOOL = "set_runtime_value_bool"
+SERVICE_SET_RUNTIME_VALUE_INT = "set_runtime_value_int"
+SERVICE_SET_RUNTIME_VALUE_FLOAT = "set_runtime_value_float"

homeassistant/components/ihc/ihcdevice.py

@@ -0,0 +1,36 @@
+# pylint: disable=missing-docstring, too-many-arguments
+
+class IHCDevice:
+    """Base class for all ihc devices"""
+    def __init__(self, ihccontroller, name, ihcid, ihcname: str, ihcnote: str, ihcposition: str):
+        self.ihc = ihccontroller
+        self._name = name
+        self._ihcid = ihcid
+        self.ihcname = ihcname
+        self.ihcnote = ihcnote
+        self.ihcposition = ihcposition
+
+    @property
+    def name(self):
+        """Return the device name"""
+        return self._name
+
+    def get_ihcid(self) -> int:
+        """Return the ihc resource id."""
+        return self._ihcid
+
+    def set_name(self, name):
+        """Set the name"""
+        self._name = name
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        if not self.ihc.info:
+            return {}
+        return {
+            'ihcid': self._ihcid,
+            'ihcname' : self.ihcname,
+            'ihcnote' : self.ihcnote,
+            'ihcposition' : self.ihcposition
+        }

homeassistant/components/ihc/services.yaml

@@ -0,0 +1,26 @@
+# Describes the format for available ihc services
+
+set_runtime_value_bool:
+  description: Set a boolean runtime value on the ihc controller
+  fields:
+    ihcid:
+      description: The integer ihc resource id
+    value:
+      description: The boolean value to set
+
+set_runtime_value_int:
+  description: Set a integer runtime value on the ihc controller
+  fields:
+    ihcid:
+      description: The integer ihc resource id
+    value:
+      description: The integer value to set
+
+set_runtime_value_float:
+  description: Set a float runtime value on the ihc controller
+  fields:
+    ihcid:
+      description: The integer ihc resource id
+    value:
+      description: The float value to set
+