Ihc component and platforms

.coveragerc

@@ -94,6 +94,9 @@ omit =
     homeassistant/components/homematic/__init__.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,94 @@
+"""IHC binary sensor platform.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.ihc/
+"""
+from xml.etree.ElementTree import Element
+
+import voluptuous as vol
+
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA, DEVICE_CLASSES_SCHEMA)
+from homeassistant.components.ihc import (
+    validate_name, IHC_DATA, IHC_CONTROLLER)
+from homeassistant.components.ihc.const import CONF_INVERTING
+from homeassistant.components.ihc.ihcdevice import IHCDevice
+from homeassistant.const import (
+    CONF_NAME, CONF_TYPE, CONF_ID, CONF_BINARY_SENSORS)
+import homeassistant.helpers.config_validation as cv
+
+DEPENDENCIES = ['ihc']
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_BINARY_SENSORS, default=[]):
+        vol.All(cv.ensure_list, [
+            vol.All({
+                vol.Required(CONF_ID): cv.positive_int,
+                vol.Optional(CONF_NAME): cv.string,
+                vol.Optional(CONF_TYPE, default=None): DEVICE_CLASSES_SCHEMA,
+                vol.Optional(CONF_INVERTING, default=False): cv.boolean,
+            }, validate_name)
+        ])
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the IHC binary setsor platform."""
+    ihc_controller = hass.data[IHC_DATA][IHC_CONTROLLER]
+    devices = []
+    if discovery_info:
+        for name, device in discovery_info.items():
+            ihc_id = device['ihc_id']
+            product_cfg = device['product_cfg']
+            product = device['product']
+            sensor = IHCBinarySensor(ihc_controller, name, ihc_id,
+                                     product_cfg[CONF_TYPE],
+                                     product_cfg[CONF_INVERTING],
+                                     product)
+            devices.append(sensor)
+    else:
+        binary_sensors = config[CONF_BINARY_SENSORS]
+        for sensor_cfg in binary_sensors:
+            ihc_id = sensor_cfg[CONF_ID]
+            name = sensor_cfg[CONF_NAME]
+            sensor_type = sensor_cfg[CONF_TYPE]
+            inverting = sensor_cfg[CONF_INVERTING]
+            sensor = IHCBinarySensor(ihc_controller, name, ihc_id,
+                                     sensor_type, inverting)
+            devices.append(sensor)
+
+    add_devices(devices)
+
+
+class IHCBinarySensor(IHCDevice, BinarySensorDevice):
+    """IHC Binary Sensor.
+
+    The associated IHC resource can be any in or output from a IHC product
+    or function block, but it must be a boolean ON/OFF resources.
+    """
+
+    def __init__(self, ihc_controller, name, ihc_id, sensor_type: str,
+                 inverting: bool, product: Element=None):
+        """Initialize the IHC binary sensor."""
+        super().__init__(ihc_controller, name, ihc_id, product)
+        self._state = None
+        self._sensor_type = sensor_type
+        self.inverting = inverting
+
+    @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 on_ihc_change(self, ihc_id, value):
+        """IHC resource has changed."""
+        if self.inverting:
+            self._state = not value
+        else:
+            self._state = value
+        self.schedule_update_ha_state()

homeassistant/components/ihc/__init__.py

@@ -0,0 +1,220 @@
+"""IHC component.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/ihc/
+"""
+import logging
+import os.path
+import xml.etree.ElementTree
+import voluptuous as vol
+from voluptuous.error import Error as VoluptuousError
+
+from homeassistant.components.ihc.const import (
+    ATTR_IHC_ID, ATTR_VALUE, CONF_INFO, CONF_AUTOSETUP,
+    CONF_BINARY_SENSOR, CONF_LIGHT, CONF_SENSOR, CONF_SWITCH,
+    CONF_XPATH, CONF_NODE, CONF_DIMMABLE, CONF_INVERTING,
+    SERVICE_SET_RUNTIME_VALUE_BOOL, SERVICE_SET_RUNTIME_VALUE_INT,
+    SERVICE_SET_RUNTIME_VALUE_FLOAT)
+from homeassistant.config import load_yaml_config_file
+from homeassistant.const import (
+    CONF_URL, CONF_USERNAME, CONF_PASSWORD, CONF_ID, CONF_NAME,
+    CONF_UNIT_OF_MEASUREMENT, CONF_TYPE)
+from homeassistant.helpers import discovery
+import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers.typing import HomeAssistantType
+
+REQUIREMENTS = ['ihcsdk==2.1.1']
+
+DOMAIN = 'ihc'
+IHC_DATA = 'ihc'
+IHC_CONTROLLER = 'controller'
+IHC_INFO = 'info'
+AUTO_SETUP_YAML = 'ihc_auto_setup.yaml'
+
+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.Optional(CONF_AUTOSETUP, default=True): cv.boolean,
+        vol.Optional(CONF_INFO, default=True): cv.boolean
+    }),
+}, extra=vol.ALLOW_EXTRA)
+
+AUTO_SETUP_SCHEMA = vol.Schema({
+    vol.Optional(CONF_BINARY_SENSOR, default=[]):
+        vol.All(cv.ensure_list, [
+            vol.All({
+                vol.Required(CONF_XPATH): cv.string,
+                vol.Required(CONF_NODE): cv.string,
+                vol.Optional(CONF_TYPE, default=None): cv.string,
+                vol.Optional(CONF_INVERTING, default=False): cv.boolean,
+            })
+        ]),
+    vol.Optional(CONF_LIGHT, default=[]):
+        vol.All(cv.ensure_list, [
+            vol.All({
+                vol.Required(CONF_XPATH): cv.string,
+                vol.Required(CONF_NODE): cv.string,
+                vol.Optional(CONF_DIMMABLE, default=False): cv.boolean,
+            })
+        ]),
+    vol.Optional(CONF_SENSOR, default=[]):
+        vol.All(cv.ensure_list, [
+            vol.All({
+                vol.Required(CONF_XPATH): cv.string,
+                vol.Required(CONF_NODE): cv.string,
+                vol.Optional(CONF_TYPE, default='Temperature'): cv.string,
+                vol.Optional(CONF_UNIT_OF_MEASUREMENT,
+                             default='°C'): cv.string,
+            })
+        ]),
+    vol.Optional(CONF_SWITCH, default=[]):
+        vol.All(cv.ensure_list, [
+            vol.All({
+                vol.Required(CONF_XPATH): cv.string,
+                vol.Required(CONF_NODE): cv.string,
+            })
+        ]),
+})
+
+SET_RUNTIME_VALUE_BOOL_SCHEMA = vol.Schema({
+    vol.Required(ATTR_IHC_ID): cv.positive_int,
+    vol.Required(ATTR_VALUE): cv.boolean
+})
+
+SET_RUNTIME_VALUE_INT_SCHEMA = vol.Schema({
+    vol.Required(ATTR_IHC_ID): cv.positive_int,
+    vol.Required(ATTR_VALUE): int
+})
+
+SET_RUNTIME_VALUE_FLOAT_SCHEMA = vol.Schema({
+    vol.Required(ATTR_IHC_ID): cv.positive_int,
+    vol.Required(ATTR_VALUE): vol.Coerce(float)
+})
+
+_LOGGER = logging.getLogger(__name__)
+
+IHC_PLATFORMS = ('binary_sensor', 'light', 'sensor', 'switch')
+
+
+def setup(hass, config):
+    """Setup the IHC component."""
+    from ihcsdk.ihccontroller import IHCController
+    conf = config[DOMAIN]
+    url = conf[CONF_URL]
+    username = conf[CONF_USERNAME]
+    password = conf[CONF_PASSWORD]
+    ihc_controller = IHCController(url, username, password)
+
+    if not ihc_controller.authenticate():
+        _LOGGER.error("Unable to authenticate on ihc controller.")
+        return False
+
+    if (conf[CONF_AUTOSETUP] and
+            not autosetup_ihc_products(hass, ihc_controller)):
+        return False
+
+    hass.data[IHC_DATA] = {
+        IHC_CONTROLLER: ihc_controller,
+        IHC_INFO: conf[CONF_INFO]}
+
+    setup_service_functions(hass, ihc_controller)
+    return True
+
+
+def autosetup_ihc_products(hass: HomeAssistantType, ihc_controller):
+    """Auto setup of IHC products from the ihc project file."""
+    project_xml = ihc_controller.get_project()
+    if not project_xml:
+        _LOGGER.error("Unable to read project from ihc controller.")
+        return False
+    project = xml.etree.ElementTree.fromstring(project_xml)
+
+    # if an auto setup file exist in the configuration it will override
+    yaml_path = hass.config.path(AUTO_SETUP_YAML)
+    if not os.path.isfile(yaml_path):
+        yaml_path = os.path.join(os.path.dirname(__file__), AUTO_SETUP_YAML)
+    yaml = load_yaml_config_file(yaml_path)
+    try:
+        auto_setup_conf = AUTO_SETUP_SCHEMA(yaml)
+    except VoluptuousError as exception:
+        _LOGGER.error("Invalid IHC auto setup data: %s", exception)
+        return False
+    groups = project.findall('.//group')
+    for component in IHC_PLATFORMS:
+        component_setup = auto_setup_conf[component]
+        discovery_info = get_discovery_info(component_setup, groups)
+        if len(discovery_info) > 0:
+            discovery.load_platform(hass, component, DOMAIN, discovery_info)
+    return True
+
+
+def get_discovery_info(component_setup, groups):
+    """Get discover info for specified component."""
+    discovery_data = {}
+    for group in groups:
+        groupname = group.attrib['name']
+        for product_cfg in component_setup:
+            products = group.findall(product_cfg[CONF_XPATH])
+            for product in products:
+                nodes = product.findall(product_cfg[CONF_NODE])
+                for node in nodes:
+                    if ('setting' in node.attrib
+                            and node.attrib['setting'] == 'yes'):
+                        continue
+                    ihc_id = int(node.attrib['id'].strip('_'), 0)
+                    name = '{}_{}'.format(groupname, ihc_id)
+                    device = {
+                        'ihc_id': ihc_id,
+                        'product': product,
+                        'product_cfg': product_cfg}
+                    discovery_data[name] = device
+    return discovery_data
+
+
+def setup_service_functions(hass: HomeAssistantType, ihc_controller):
+    """Setup the ihc service functions."""
+    def set_runtime_value_bool(call):
+        """Set a IHC runtime bool value service function."""
+        ihc_id = call.data[ATTR_IHC_ID]
+        value = call.data[ATTR_VALUE]
+        ihc_controller.set_runtime_value_bool(ihc_id, value)
+
+    def set_runtime_value_int(call):
+        """Set a IHC runtime integer value service function."""
+        ihc_id = call.data[ATTR_IHC_ID]
+        value = call.data[ATTR_VALUE]
+        ihc_controller.set_runtime_value_int(ihc_id, value)
+
+    def set_runtime_value_float(call):
+        """Set a IHC runtime float value service function."""
+        ihc_id = call.data[ATTR_IHC_ID]
+        value = call.data[ATTR_VALUE]
+        ihc_controller.set_runtime_value_float(ihc_id, value)
+
+    descriptions = load_yaml_config_file(
+        os.path.join(os.path.dirname(__file__), 'services.yaml'))
+
+    hass.services.register(DOMAIN, SERVICE_SET_RUNTIME_VALUE_BOOL,
+                           set_runtime_value_bool,
+                           descriptions[SERVICE_SET_RUNTIME_VALUE_BOOL],
+                           schema=SET_RUNTIME_VALUE_BOOL_SCHEMA)
+    hass.services.register(DOMAIN, SERVICE_SET_RUNTIME_VALUE_INT,
+                           set_runtime_value_int,
+                           descriptions[SERVICE_SET_RUNTIME_VALUE_INT],
+                           schema=SET_RUNTIME_VALUE_INT_SCHEMA)
+    hass.services.register(DOMAIN, SERVICE_SET_RUNTIME_VALUE_FLOAT,
+                           set_runtime_value_float,
+                           descriptions[SERVICE_SET_RUNTIME_VALUE_FLOAT],
+                           schema=SET_RUNTIME_VALUE_FLOAT_SCHEMA)
+
+
+def validate_name(config):
+    """Validate device name."""
+    if CONF_NAME in config:
+        return config
+    ihcid = config[CONF_ID]
+    name = 'ihc_{}'.format(ihcid)
+    config[CONF_NAME] = name
+    return config

homeassistant/components/ihc/const.py

@@ -0,0 +1,19 @@
+"""IHC component constants."""
+
+CONF_AUTOSETUP = 'auto_setup'
+CONF_INFO = 'info'
+CONF_XPATH = 'xpath'
+CONF_NODE = 'node'
+CONF_INVERTING = 'inverting'
+CONF_DIMMABLE = 'dimmable'
+CONF_BINARY_SENSOR = 'binary_sensor'
+CONF_LIGHT = 'light'
+CONF_SENSOR = 'sensor'
+CONF_SWITCH = 'switch'
+
+ATTR_IHC_ID = 'ihc_id'
+ATTR_VALUE = 'value'
+
+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"