Merge pull request #3937 from home-assistant/dev

0.31
Update version
2016-10-22 15:22:07 -07:00 · 2016-10-22 15:09:05 -07:00 · 2016-10-22 16:59:20 -04:00 · 2016-10-22 21:01:12 +02:00 · 2016-10-22 11:24:06 -07:00 · 2016-10-22 14:08:24 +02:00
337 changed files with 15059 additions and 5056 deletions
@@ -16,6 +16,9 @@ omit =
    homeassistant/components/bloomsky.py
    homeassistant/components/*/bloomsky.py

+    homeassistant/components/digital_ocean.py
+    homeassistant/components/*/digital_ocean.py
+
    homeassistant/components/dweet.py
    homeassistant/components/*/dweet.py

@@ -28,6 +31,9 @@ omit =
    homeassistant/components/insteon_hub.py
    homeassistant/components/*/insteon_hub.py

+    homeassistant/components/ios.py
+    homeassistant/components/*/ios.py
+
    homeassistant/components/isy994.py
    homeassistant/components/*/isy994.py

@@ -46,6 +52,9 @@ omit =
    homeassistant/components/qwikswitch.py
    homeassistant/components/*/qwikswitch.py

+    homeassistant/components/rfxtrx.py
+    homeassistant/components/*/rfxtrx.py
+
    homeassistant/components/rpi_gpio.py
    homeassistant/components/*/rpi_gpio.py

@@ -77,7 +86,7 @@ omit =
    homeassistant/components/zigbee.py
    homeassistant/components/*/zigbee.py

-    homeassistant/components/zwave.py
+    homeassistant/components/zwave/*
    homeassistant/components/*/zwave.py

    homeassistant/components/enocean.py
@@ -89,8 +98,7 @@ omit =
    homeassistant/components/homematic.py
    homeassistant/components/*/homematic.py

-    homeassistant/components/pilight.py
-    homeassistant/components/*/pilight.py
+    homeassistant/components/switch/pilight.py

    homeassistant/components/knx.py
    homeassistant/components/*/knx.py
@@ -98,16 +106,22 @@ omit =
    homeassistant/components/ffmpeg.py
    homeassistant/components/*/ffmpeg.py

+    homeassistant/components/zoneminder.py
+    homeassistant/components/*/zoneminder.py
+
    homeassistant/components/alarm_control_panel/alarmdotcom.py
+    homeassistant/components/alarm_control_panel/concord232.py
    homeassistant/components/alarm_control_panel/nx584.py
    homeassistant/components/alarm_control_panel/simplisafe.py
    homeassistant/components/binary_sensor/arest.py
+    homeassistant/components/binary_sensor/concord232.py
    homeassistant/components/binary_sensor/rest.py
    homeassistant/components/browser.py
    homeassistant/components/camera/bloomsky.py
    homeassistant/components/camera/foscam.py
    homeassistant/components/camera/mjpeg.py
    homeassistant/components/camera/rpi_camera.py
+    homeassistant/components/camera/synology.py
    homeassistant/components/climate/eq3btsmart.py
    homeassistant/components/climate/heatmiser.py
    homeassistant/components/climate/homematic.py
@@ -121,6 +135,7 @@ omit =
    homeassistant/components/device_tracker/actiontec.py
    homeassistant/components/device_tracker/aruba.py
    homeassistant/components/device_tracker/asuswrt.py
+    homeassistant/components/device_tracker/bbox.py
    homeassistant/components/device_tracker/bluetooth_tracker.py
    homeassistant/components/device_tracker/bluetooth_le_tracker.py
    homeassistant/components/device_tracker/bt_home_hub_5.py
@@ -135,8 +150,10 @@ omit =
    homeassistant/components/device_tracker/tomato.py
    homeassistant/components/device_tracker/tplink.py
    homeassistant/components/device_tracker/ubus.py
+    homeassistant/components/device_tracker/volvooncall.py
    homeassistant/components/discovery.py
    homeassistant/components/downloader.py
+    homeassistant/components/emoncms_history.py
    homeassistant/components/fan/mqtt.py
    homeassistant/components/feedreader.py
    homeassistant/components/foursquare.py
@@ -190,6 +207,7 @@ omit =
    homeassistant/components/notify/joaoapps_join.py
    homeassistant/components/notify/kodi.py
    homeassistant/components/notify/llamalab_automate.py
+    homeassistant/components/notify/matrix.py
    homeassistant/components/notify/message_bird.py
    homeassistant/components/notify/nma.py
    homeassistant/components/notify/pushbullet.py
@@ -202,6 +220,7 @@ omit =
    homeassistant/components/notify/smtp.py
    homeassistant/components/notify/syslog.py
    homeassistant/components/notify/telegram.py
+    homeassistant/components/notify/telstra.py
    homeassistant/components/notify/twilio_sms.py
    homeassistant/components/notify/twitter.py
    homeassistant/components/notify/xmpp.py
@@ -209,10 +228,13 @@ omit =
    homeassistant/components/openalpr.py
    homeassistant/components/scene/hunterdouglas_powerview.py
    homeassistant/components/sensor/arest.py
+    homeassistant/components/sensor/arwn.py
+    homeassistant/components/sensor/bbox.py
    homeassistant/components/sensor/bitcoin.py
    homeassistant/components/sensor/bom.py
    homeassistant/components/sensor/coinmarketcap.py
    homeassistant/components/sensor/cpuspeed.py
+    homeassistant/components/sensor/darksky.py
    homeassistant/components/sensor/deutsche_bahn.py
    homeassistant/components/sensor/dht.py
    homeassistant/components/sensor/dte_energy_bridge.py
@@ -222,12 +244,12 @@ omit =
    homeassistant/components/sensor/fastdotcom.py
    homeassistant/components/sensor/fitbit.py
    homeassistant/components/sensor/fixer.py
-    homeassistant/components/sensor/forecast.py
    homeassistant/components/sensor/fritzbox_callmonitor.py
    homeassistant/components/sensor/glances.py
    homeassistant/components/sensor/google_travel_time.py
    homeassistant/components/sensor/gpsd.py
    homeassistant/components/sensor/gtfs.py
+    homeassistant/components/sensor/haveibeenpwned.py
    homeassistant/components/sensor/hp_ilo.py
    homeassistant/components/sensor/imap.py
    homeassistant/components/sensor/imap_email_content.py
@@ -247,6 +269,7 @@ omit =
    homeassistant/components/sensor/plex.py
    homeassistant/components/sensor/rest.py
    homeassistant/components/sensor/sabnzbd.py
+    homeassistant/components/sensor/scrape.py
    homeassistant/components/sensor/serial_pm.py
    homeassistant/components/sensor/snmp.py
    homeassistant/components/sensor/speedtest.py
@@ -255,22 +278,25 @@ omit =
    homeassistant/components/sensor/swiss_hydrological_data.py
    homeassistant/components/sensor/swiss_public_transport.py
    homeassistant/components/sensor/systemmonitor.py
+    homeassistant/components/sensor/ted5000.py
    homeassistant/components/sensor/temper.py
    homeassistant/components/sensor/time_date.py
    homeassistant/components/sensor/torque.py
    homeassistant/components/sensor/transmission.py
    homeassistant/components/sensor/twitch.py
    homeassistant/components/sensor/uber.py
+    homeassistant/components/sensor/vasttrafik.py
    homeassistant/components/sensor/worldclock.py
    homeassistant/components/sensor/xbox_live.py
-    homeassistant/components/sensor/yahoo_finance.py
    homeassistant/components/sensor/yweather.py
    homeassistant/components/switch/acer_projector.py
+    homeassistant/components/switch/anel_pwrctrl.py
    homeassistant/components/switch/arest.py
    homeassistant/components/switch/dlink.py
    homeassistant/components/switch/edimax.py
    homeassistant/components/switch/hikvisioncam.py
    homeassistant/components/switch/mystrom.py
+    homeassistant/components/switch/neato.py
    homeassistant/components/switch/netio.py
    homeassistant/components/switch/orvibo.py
    homeassistant/components/switch/pulseaudio_loopback.py
@@ -1,9 +1,9 @@
 **Description:**


-**Related issue (if applicable):** fixes #
+**Related issue (if applicable):** fixes #<home-assistant issue number goes here>

-**Pull request in [home-assistant.io](https://github.com/home-assistant/home-assistant.io) with documentation (if applicable):** home-assistant/home-assistant.io#
+**Pull request in [home-assistant.github.io](https://github.com/home-assistant/home-assistant.github.io) with documentation (if applicable):** home-assistant/home-assistant.github.io#<home-assistant.github.io PR number goes here>

 **Example entry for `configuration.yaml` (if applicable):**
 ```yaml
@@ -13,9 +13,9 @@
 **Checklist:**

 If user exposed functionality or configuration variables are added/changed:
-  - [ ] Documentation added/updated in [home-assistant.io](https://github.com/home-assistant/home-assistant.io)
+  - [ ] Documentation added/updated in [home-assistant.github.io](https://github.com/home-assistant/home-assistant.github.io)

-If code communicates with devices, web services, or a:
+If the code communicates with devices, web services, or third-party tools:
  - [ ] Local tests with `tox` run successfully. **Your PR cannot be merged unless tests pass**
  - [ ] New dependencies have been added to the `REQUIREMENTS` variable ([example][ex-requir]).
  - [ ] New dependencies are only imported inside functions that use them ([example][ex-import]).
@@ -19,8 +19,7 @@ RUN script/build_python_openzwave && \
  ln -sf /usr/src/app/build/python-openzwave/openzwave/config /usr/local/share/python-openzwave/config

 COPY requirements_all.txt requirements_all.txt
-# certifi breaks Debian based installs
-RUN pip3 install --no-cache-dir -r requirements_all.txt && pip3 uninstall -y certifi && \
+RUN pip3 install --no-cache-dir -r requirements_all.txt && \
    pip3 install mysqlclient psycopg2 uvloop

 # Copy source
@@ -8,11 +8,31 @@
 .. autoclass:: Config
    :members:

+.. autoclass:: Event
+    :members:
+
 .. autoclass:: EventBus
    :members:

+.. autoclass:: HomeAssistant
+    :members:
+
+.. autoclass:: State
+    :members:
+
 .. autoclass:: StateMachine
    :members:

+.. autoclass:: ServiceCall
+    :members:
+
 .. autoclass:: ServiceRegistry
    :members:
+
+Module contents
+---------------
+
+.. automodule:: homeassistant.core
+    :members:
+    :undoc-members:
+    :show-inheritance:
@@ -4,6 +4,14 @@ homeassistant.util package
 Submodules
 ----------

+homeassistant.util.async module
+-------------------------------
+
+.. automodule:: homeassistant.util.async
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
 homeassistant.util.color module
 -------------------------------

@@ -340,8 +340,8 @@ latex_elements = {
 # (source start file, target name, title,
 #  author, documentclass [howto, manual, or own class]).
 latex_documents = [
-    (master_doc, 'Home-Assistant.tex', 'Home-Assistant Documentation',
-     'Home-Assistant Team', 'manual'),
+    (master_doc, 'home-assistant.tex', 'Home Assistant Documentation',
+     'Home Assistant Team', 'manual'),
 ]

 # The name of an image file (relative to this directory) to place at the top of
@@ -382,7 +382,7 @@ latex_documents = [
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
 man_pages = [
-    (master_doc, 'home-assistant', 'Home-Assistant Documentation',
+    (master_doc, 'home-assistant', 'Home Assistant Documentation',
     [author], 1)
 ]

@@ -397,8 +397,8 @@ man_pages = [
 # (source start file, target name, title, author,
 #  dir menu entry, description, category)
 texinfo_documents = [
-    (master_doc, 'Home-Assistant', 'Home-Assistant Documentation',
-     author, 'Home-Assistant', 'One line description of project.',
+    (master_doc, 'Home-Assistant', 'Home Assistant Documentation',
+     author, 'Home Assistant', 'Open-source home automation platform.',
     'Miscellaneous'),
 ]

@@ -2,7 +2,7 @@ swagger: '2.0'
 info:
  title: Home Assistant
  description: Home Assistant REST API
-  version: "1.0.0"
+  version: "1.0.1"
 # the domain of the service
 host: localhost:8123

@@ -12,17 +12,17 @@ schemes:
  - https

 securityDefinitions:
-  api_key:
-    type: apiKey
-    description: API password
-    name: api_password
-    in: query
-  
-  # api_key:
+  #api_key:
  #  type: apiKey
  #  description: API password
-  #  name: x-ha-access
-  #  in: header
+  #  name: api_password
+  #  in: query
+  
+   api_key:
+    type: apiKey
+    description: API password
+    name: x-ha-access
+    in: header

 # will be prefixed to all paths
 basePath: /api
@@ -38,6 +38,8 @@ paths:
      description: Returns message if API is up and running.
      tags:
        - Core
+      security:
+        - api_key: []
      responses:
        200:
          description: API is up and running
@@ -53,6 +55,8 @@ paths:
      description: Returns the current configuration as JSON.
      tags:
        - Core
+      security:
+        - api_key: []
      responses:
        200:
          description: Current configuration
@@ -81,6 +85,8 @@ paths:
      summary: Returns all data needed to bootstrap Home Assistant.
      tags:
        - Core
+      security:
+        - api_key: []
      responses:
        200:
          description: Bootstrap information
@@ -96,6 +102,8 @@ paths:
      description: Returns an array of event objects. Each event object contain event name and listener count.
      tags:
        - Events
+      security:
+        - api_key: []
      responses:
        200:
          description: Events
@@ -113,6 +121,8 @@ paths:
      description: Returns an array of service objects. Each object contains the domain and which services it contains.
      tags:
        - Services
+      security:
+        - api_key: []
      responses:
        200:
          description: Services
@@ -130,6 +140,8 @@ paths:
      description: Returns an array of state changes in the past. Each object contains further detail for the entities.
      tags:
        - State
+      security:
+        - api_key: []
      responses:
        200:
          description: State changes
@@ -148,6 +160,8 @@ paths:
        Returns an array of state objects. Each state has the following attributes: entity_id, state, last_changed and attributes.
      tags:
        - State
+      security:
+        - api_key: []
      responses:
        200:
          description: States
@@ -166,6 +180,8 @@ paths:
        Returns a state object for specified entity_id.
      tags:
        - State
+      security:
+        - api_key: []
      parameters:
      - name: entity_id
        in: path
@@ -223,6 +239,8 @@ paths:
        Retrieve all errors logged during the current session of Home Assistant as a plaintext response.
      tags:
        - Core
+      security:
+        - api_key: []
      produces:
        - text/plain
      responses:
@@ -239,6 +257,8 @@ paths:
        Returns the data (image) from the specified camera entity_id.
      tags:
        - Camera
+      security:
+        - api_key: []
      produces:
        - image/jpeg
      parameters:
@@ -262,6 +282,8 @@ paths:
        Fires an event with event_type
      tags:
        - Events
+      security:
+        - api_key: []
      consumes:
        - application/json
      parameters:
@@ -286,6 +308,8 @@ paths:
        Calls a service within a specific domain. Will return when the service has been executed or 10 seconds has past, whichever comes first.
      tags:
        - Services
+      security:
+        - api_key: []
      consumes:
        - application/json
      parameters:
@@ -317,6 +341,8 @@ paths:
        Render a Home Assistant template.
      tags:
        - Template
+      security:
+        - api_key: []
      consumes:
        - application/json
      produces:
@@ -338,6 +364,8 @@ paths:
        Setup event forwarding to another Home Assistant instance.
      tags:
        - Core
+      security:
+        - api_key: []
      consumes:
        - application/json
      parameters:
@@ -376,6 +404,8 @@ paths:
      tags:
        - Core
        - Events
+      security:
+        - api_key: []
      produces:
        - text/event-stream
      parameters:
@@ -420,8 +450,16 @@ definitions:
      location_name:
        type: string
      unit_system:
-        type: string
-        description: The system for measurement units
+        type: object
+        properties:
+          length:
+            type: string
+          mass:
+            type: string
+          temperature: 
+            type: string
+          volume:
+            type: string
      time_zone:
        type: string
      version:
@@ -19,6 +19,49 @@ from homeassistant.const import (
 from homeassistant.util.async import run_callback_threadsafe


+def monkey_patch_asyncio():
+    """Replace weakref.WeakSet to address Python 3 bug.
+
+    Under heavy threading operations that schedule calls into
+    the asyncio event loop, Task objects are created. Due to
+    a bug in Python, GC may have an issue when switching between
+    the threads and objects with __del__ (which various components
+    in HASS have).
+
+    This monkey-patch removes the weakref.Weakset, and replaces it
+    with an object that ignores the only call utilizing it (the
+    Task.__init__ which calls _all_tasks.add(self)). It also removes
+    the __del__ which could trigger the future objects __del__ at
+    unpredictable times.
+
+    The side-effect of this manipulation of the Task is that
+    Task.all_tasks() is no longer accurate, and there will be no
+    warning emitted if a Task is GC'd while in use.
+
+    On Python 3.6, after the bug is fixed, this monkey-patch can be
+    disabled.
+
+    See https://bugs.python.org/issue26617 for details of the Python
+    bug.
+    """
+    # pylint: disable=no-self-use, too-few-public-methods, protected-access
+    # pylint: disable=bare-except
+    import asyncio.tasks
+
+    class IgnoreCalls:
+        """Ignore add calls."""
+
+        def add(self, other):
+            """No-op add."""
+            return
+
+    asyncio.tasks.Task._all_tasks = IgnoreCalls()
+    try:
+        del asyncio.tasks.Task.__del__
+    except:
+        pass
+
+
 def validate_python() -> None:
    """Validate we're running the right Python version."""
    if sys.version_info[:3] < REQUIRED_PYTHON_VER:
@@ -308,6 +351,8 @@ def try_to_restart() -> None:

 def main() -> int:
    """Start Home Assistant."""
+    monkey_patch_asyncio()
+
    validate_python()

    args = get_arguments()
@@ -32,12 +32,15 @@ _CURRENT_SETUP = []
 ATTR_COMPONENT = 'component'

 ERROR_LOG_FILENAME = 'home-assistant.log'
+_PERSISTENT_PLATFORMS = set()
+_PERSISTENT_VALIDATION = set()


 def setup_component(hass: core.HomeAssistant, domain: str,
                    config: Optional[Dict]=None) -> bool:
    """Setup a component and all its dependencies."""
    if domain in hass.config.components:
+        _LOGGER.debug('Component %s already set up.', domain)
        return True

    _ensure_loader_prepared(hass)
@@ -53,6 +56,7 @@ def setup_component(hass: core.HomeAssistant, domain: str,

    for component in components:
        if not _setup_component(hass, component, config):
+            _LOGGER.error('Component %s failed to setup', component)
            return False

    return True
@@ -147,7 +151,7 @@ def prepare_setup_component(hass: core.HomeAssistant, config: dict,
        try:
            config = component.CONFIG_SCHEMA(config)
        except vol.Invalid as ex:
-            log_exception(ex, domain, config)
+            log_exception(ex, domain, config, hass)
            return None

    elif hasattr(component, 'PLATFORM_SCHEMA'):
@@ -157,8 +161,8 @@ def prepare_setup_component(hass: core.HomeAssistant, config: dict,
            try:
                p_validated = component.PLATFORM_SCHEMA(p_config)
            except vol.Invalid as ex:
-                log_exception(ex, domain, config)
-                return None
+                log_exception(ex, domain, config, hass)
+                continue

            # Not all platform components follow same pattern for platforms
            # So if p_name is None we are not going to validate platform
@@ -171,7 +175,7 @@ def prepare_setup_component(hass: core.HomeAssistant, config: dict,
                                              p_name)

            if platform is None:
-                return None
+                continue

            # Validate platform specific schema
            if hasattr(platform, 'PLATFORM_SCHEMA'):
@@ -179,8 +183,8 @@ def prepare_setup_component(hass: core.HomeAssistant, config: dict,
                    p_validated = platform.PLATFORM_SCHEMA(p_validated)
                except vol.Invalid as ex:
                    log_exception(ex, '{}.{}'.format(domain, p_name),
-                                  p_validated)
-                    return None
+                                  p_validated, hass)
+                    continue

            platforms.append(p_validated)

@@ -209,6 +213,13 @@ def prepare_setup_platform(hass: core.HomeAssistant, config, domain: str,
    # Not found
    if platform is None:
        _LOGGER.error('Unable to find platform %s', platform_path)
+
+        _PERSISTENT_PLATFORMS.add(platform_path)
+        message = ('Unable to find the following platforms: ' +
+                   ', '.join(list(_PERSISTENT_PLATFORMS)) +
+                   '(please check your configuration)')
+        persistent_notification.create(
+            hass, message, 'Invalid platforms', 'platform_errors')
        return None

    # Already loaded
@@ -255,7 +266,7 @@ def from_config_dict(config: Dict[str, Any],
    try:
        conf_util.process_ha_core_config(hass, core_config)
    except vol.Invalid as ex:
-        log_exception(ex, 'homeassistant', core_config)
+        log_exception(ex, 'homeassistant', core_config, hass)
        return None

    conf_util.process_ha_config_upgrade(hass)
@@ -303,6 +314,7 @@ def from_config_dict(config: Dict[str, Any],
    hass.loop.run_until_complete(
        hass.loop.run_in_executor(None, component_setup)
    )
+
    return hass


@@ -343,6 +355,11 @@ def enable_logging(hass: core.HomeAssistant, verbose: bool=False,
    logging.basicConfig(level=logging.INFO)
    fmt = ("%(log_color)s%(asctime)s %(levelname)s (%(threadName)s) "
           "[%(name)s] %(message)s%(reset)s")
+
+    # suppress overly verbose logs from libraries that aren't helpful
+    logging.getLogger("requests").setLevel(logging.WARNING)
+    logging.getLogger("urllib3").setLevel(logging.WARNING)
+
    try:
        from colorlog import ColoredFormatter
        logging.getLogger().handlers[0].setFormatter(ColoredFormatter(
@@ -395,9 +412,16 @@ def _ensure_loader_prepared(hass: core.HomeAssistant) -> None:
        loader.prepare(hass)


-def log_exception(ex, domain, config):
+def log_exception(ex, domain, config, hass=None):
    """Generate log exception for config validation."""
    message = 'Invalid config for [{}]: '.format(domain)
+    if hass is not None:
+        _PERSISTENT_VALIDATION.add(domain)
+        message = ('The following platforms contain invalid configuration:  ' +
+                   ', '.join(list(_PERSISTENT_VALIDATION)) +
+                   '  (please check your configuration)')
+        persistent_notification.create(
+            hass, message, 'Invalid config', 'invalid_config')

    if 'extra keys not allowed' in ex.error_message:
        message += '[{}] is an invalid option for [{}]. Check: {}->{}.'\
@@ -0,0 +1,136 @@
+"""
+Support for Concord232 alarm control panels.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/alarm_control_panel.concord232/
+"""
+
+import datetime
+
+import logging
+
+import homeassistant.components.alarm_control_panel as alarm
+from homeassistant.components.alarm_control_panel import PLATFORM_SCHEMA
+from homeassistant.const import (
+    CONF_HOST, CONF_NAME, CONF_PORT,
+    STATE_ALARM_ARMED_AWAY, STATE_ALARM_ARMED_HOME,
+    STATE_ALARM_DISARMED, STATE_UNKNOWN)
+import homeassistant.helpers.config_validation as cv
+
+import requests
+
+import voluptuous as vol
+
+REQUIREMENTS = ['concord232==0.14']
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_HOST = 'localhost'
+DEFAULT_NAME = 'CONCORD232'
+DEFAULT_PORT = 5007
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Optional(CONF_HOST, default=DEFAULT_HOST): cv.string,
+})
+
+SCAN_INTERVAL = 1
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup concord232 platform."""
+    name = config.get(CONF_NAME)
+    host = config.get(CONF_HOST)
+    port = config.get(CONF_PORT)
+
+    url = 'http://{}:{}'.format(host, port)
+
+    try:
+        add_devices([Concord232Alarm(hass, url, name)])
+    except requests.exceptions.ConnectionError as ex:
+        _LOGGER.error('Unable to connect to Concord232: %s', str(ex))
+        return False
+
+
+class Concord232Alarm(alarm.AlarmControlPanel):
+    """Represents the Concord232-based alarm panel."""
+
+    def __init__(self, hass, url, name):
+        """Initalize the concord232 alarm panel."""
+        from concord232 import client as concord232_client
+
+        self._state = STATE_UNKNOWN
+        self._hass = hass
+        self._name = name
+        self._url = url
+
+        try:
+            client = concord232_client.Client(self._url)
+        except requests.exceptions.ConnectionError as ex:
+            _LOGGER.error('Unable to connect to Concord232: %s', str(ex))
+
+        self._alarm = client
+        self._alarm.partitions = self._alarm.list_partitions()
+        self._alarm.last_partition_update = datetime.datetime.now()
+        self.update()
+
+    @property
+    def should_poll(self):
+        """Polling needed."""
+        return True
+
+    @property
+    def name(self):
+        """Return the name of the device."""
+        return self._name
+
+    @property
+    def code_format(self):
+        """The characters if code is defined."""
+        return '[0-9]{4}([0-9]{2})?'
+
+    @property
+    def state(self):
+        """Return the state of the device."""
+        return self._state
+
+    def update(self):
+        """Update values from API."""
+        try:
+            part = self._alarm.list_partitions()[0]
+        except requests.exceptions.ConnectionError as ex:
+            _LOGGER.error('Unable to connect to %(host)s: %(reason)s',
+                          dict(host=self._url, reason=ex))
+            newstate = STATE_UNKNOWN
+        except IndexError:
+            _LOGGER.error('concord232 reports no partitions')
+            newstate = STATE_UNKNOWN
+
+        if part['arming_level'] == "Off":
+            newstate = STATE_ALARM_DISARMED
+        elif "Home" in part['arming_level']:
+            newstate = STATE_ALARM_ARMED_HOME
+        else:
+            newstate = STATE_ALARM_ARMED_AWAY
+
+        if not newstate == self._state:
+            _LOGGER.info("State Chnage from %s to %s", self._state, newstate)
+            self._state = newstate
+        return self._state
+
+    def alarm_disarm(self, code=None):
+        """Send disarm command."""
+        self._alarm.disarm(code)
+
+    def alarm_arm_home(self, code=None):
+        """Send arm home command."""
+        self._alarm.arm('home')
+
+    def alarm_arm_away(self, code=None):
+        """Send arm away command."""
+        self._alarm.arm('auto')
+
+    def alarm_trigger(self, code=None):
+        """Alarm trigger command."""
+        raise NotImplementedError()
@@ -60,6 +60,7 @@ class NX584Alarm(alarm.AlarmControlPanel):
        # talk to the API and trigger a requests exception for setup_platform()
        # to catch
        self._alarm.list_zones()
+        self._state = STATE_UNKNOWN

    @property
    def should_poll(self):
@@ -79,16 +80,20 @@ class NX584Alarm(alarm.AlarmControlPanel):
    @property
    def state(self):
        """Return the state of the device."""
+        return self._state
+
+    def update(self):
+        """Process new events from panel."""
        try:
            part = self._alarm.list_partitions()[0]
            zones = self._alarm.list_zones()
        except requests.exceptions.ConnectionError as ex:
            _LOGGER.error('Unable to connect to %(host)s: %(reason)s',
                          dict(host=self._url, reason=ex))
-            return STATE_UNKNOWN
+            self._state = STATE_UNKNOWN
        except IndexError:
            _LOGGER.error('nx584 reports no partitions')
-            return STATE_UNKNOWN
+            self._state = STATE_UNKNOWN

        bypassed = False
        for zone in zones:
@@ -100,11 +105,11 @@ class NX584Alarm(alarm.AlarmControlPanel):
                break

        if not part['armed']:
-            return STATE_ALARM_DISARMED
+            self._state = STATE_ALARM_DISARMED
        elif bypassed:
-            return STATE_ALARM_ARMED_HOME
+            self._state = STATE_ALARM_ARMED_HOME
        else:
-            return STATE_ALARM_ARMED_AWAY
+            self._state = STATE_ALARM_ARMED_AWAY

    def alarm_disarm(self, code=None):
        """Send disarm command."""
@@ -7,16 +7,20 @@ https://home-assistant.io/components/alexa/
 import copy
 import enum
 import logging
+import uuid
+from datetime import datetime

 import voluptuous as vol

 from homeassistant.const import HTTP_BAD_REQUEST
 from homeassistant.helpers import template, script, config_validation as cv
 from homeassistant.components.http import HomeAssistantView
+import homeassistant.util.dt as dt_util

 _LOGGER = logging.getLogger(__name__)

-API_ENDPOINT = '/api/alexa'
+INTENTS_API_ENDPOINT = '/api/alexa'
+FLASH_BRIEFINGS_API_ENDPOINT = '/api/alexa/flash_briefings/<briefing_id>'

 CONF_ACTION = 'action'
 CONF_CARD = 'card'
@@ -28,6 +32,23 @@ CONF_TITLE = 'title'
 CONF_CONTENT = 'content'
 CONF_TEXT = 'text'

+CONF_FLASH_BRIEFINGS = 'flash_briefings'
+CONF_UID = 'uid'
+CONF_DATE = 'date'
+CONF_TITLE = 'title'
+CONF_AUDIO = 'audio'
+CONF_TEXT = 'text'
+CONF_DISPLAY_URL = 'display_url'
+
+ATTR_UID = 'uid'
+ATTR_UPDATE_DATE = 'updateDate'
+ATTR_TITLE_TEXT = 'titleText'
+ATTR_STREAM_URL = 'streamUrl'
+ATTR_MAIN_TEXT = 'mainText'
+ATTR_REDIRECTION_URL = 'redirectionURL'
+
+DATE_FORMAT = '%Y-%m-%dT%H:%M:%S.0Z'
+
 DOMAIN = 'alexa'
 DEPENDENCIES = ['http']

@@ -61,23 +82,36 @@ CONFIG_SCHEMA = vol.Schema({
                    vol.Required(CONF_TEXT): cv.template,
                }
            }
+        },
+        CONF_FLASH_BRIEFINGS: {
+            cv.string: vol.All(cv.ensure_list, [{
+                vol.Required(CONF_UID, default=str(uuid.uuid4())): cv.string,
+                vol.Optional(CONF_DATE, default=datetime.utcnow()): cv.string,
+                vol.Required(CONF_TITLE): cv.template,
+                vol.Optional(CONF_AUDIO): cv.template,
+                vol.Required(CONF_TEXT, default=""): cv.template,
+                vol.Optional(CONF_DISPLAY_URL): cv.template,
+            }]),
        }
    }
-})
+}, extra=vol.ALLOW_EXTRA)


 def setup(hass, config):
    """Activate Alexa component."""
-    hass.wsgi.register_view(AlexaView(hass,
-                                      config[DOMAIN].get(CONF_INTENTS, {})))
+    intents = config[DOMAIN].get(CONF_INTENTS, {})
+    flash_briefings = config[DOMAIN].get(CONF_FLASH_BRIEFINGS, {})
+
+    hass.wsgi.register_view(AlexaIntentsView(hass, intents))
+    hass.wsgi.register_view(AlexaFlashBriefingView(hass, flash_briefings))

    return True


-class AlexaView(HomeAssistantView):
+class AlexaIntentsView(HomeAssistantView):
    """Handle Alexa requests."""

-    url = API_ENDPOINT
+    url = INTENTS_API_ENDPOINT
    name = 'api:alexa'

    def __init__(self, hass, intents):
@@ -235,3 +269,69 @@ class AlexaResponse(object):
            'sessionAttributes': self.session_attributes,
            'response': response,
        }
+
+
+class AlexaFlashBriefingView(HomeAssistantView):
+    """Handle Alexa Flash Briefing skill requests."""
+
+    url = FLASH_BRIEFINGS_API_ENDPOINT
+    name = 'api:alexa:flash_briefings'
+
+    def __init__(self, hass, flash_briefings):
+        """Initialize Alexa view."""
+        super().__init__(hass)
+        self.flash_briefings = copy.deepcopy(flash_briefings)
+        template.attach(hass, self.flash_briefings)
+
+    # pylint: disable=too-many-branches
+    def get(self, request, briefing_id):
+        """Handle Alexa Flash Briefing request."""
+        _LOGGER.debug('Received Alexa flash briefing request for: %s',
+                      briefing_id)
+
+        if self.flash_briefings.get(briefing_id) is None:
+            err = 'No configured Alexa flash briefing was found for: %s'
+            _LOGGER.error(err, briefing_id)
+            return self.Response(status=404)
+
+        briefing = []
+
+        for item in self.flash_briefings.get(briefing_id, []):
+            output = {}
+            if item.get(CONF_TITLE) is not None:
+                if isinstance(item.get(CONF_TITLE), template.Template):
+                    output[ATTR_TITLE_TEXT] = item[CONF_TITLE].render()
+                else:
+                    output[ATTR_TITLE_TEXT] = item.get(CONF_TITLE)
+
+            if item.get(CONF_TEXT) is not None:
+                if isinstance(item.get(CONF_TEXT), template.Template):
+                    output[ATTR_MAIN_TEXT] = item[CONF_TEXT].render()
+                else:
+                    output[ATTR_MAIN_TEXT] = item.get(CONF_TEXT)
+
+            if item.get(CONF_UID) is not None:
+                output[ATTR_UID] = item.get(CONF_UID)
+
+            if item.get(CONF_AUDIO) is not None:
+                if isinstance(item.get(CONF_AUDIO), template.Template):
+                    output[ATTR_STREAM_URL] = item[CONF_AUDIO].render()
+                else:
+                    output[ATTR_STREAM_URL] = item.get(CONF_AUDIO)
+
+            if item.get(CONF_DISPLAY_URL) is not None:
+                if isinstance(item.get(CONF_DISPLAY_URL),
+                              template.Template):
+                    output[ATTR_REDIRECTION_URL] = \
+                        item[CONF_DISPLAY_URL].render()
+                else:
+                    output[ATTR_REDIRECTION_URL] = item.get(CONF_DISPLAY_URL)
+
+            if isinstance(item[CONF_DATE], str):
+                item[CONF_DATE] = dt_util.parse_datetime(item[CONF_DATE])
+
+            output[ATTR_UPDATE_DATE] = item[CONF_DATE].strftime(DATE_FORMAT)
+
+            briefing.append(output)
+
+        return self.json(briefing)
@@ -4,12 +4,14 @@ Allow to setup simple automation rules via the config file.
 For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/automation/
 """
+import asyncio
 from functools import partial
 import logging
 import os

 import voluptuous as vol

+from homeassistant.core import callback
 from homeassistant.bootstrap import prepare_setup_platform
 from homeassistant import config as conf_util
 from homeassistant.const import (
@@ -23,12 +25,15 @@ from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.loader import get_platform
 from homeassistant.util.dt import utcnow
 import homeassistant.helpers.config_validation as cv
+from homeassistant.util.async import run_coroutine_threadsafe

 DOMAIN = 'automation'
 ENTITY_ID_FORMAT = DOMAIN + '.{}'

 DEPENDENCIES = ['group']

+GROUP_NAME_ALL_AUTOMATIONS = 'all automations'
+
 CONF_ALIAS = 'alias'
 CONF_HIDE_ENTITY = 'hide_entity'

@@ -36,6 +41,7 @@ CONF_CONDITION = 'condition'
 CONF_ACTION = 'action'
 CONF_TRIGGER = 'trigger'
 CONF_CONDITION_TYPE = 'condition_type'
+CONF_INITIAL_STATE = 'initial_state'

 CONDITION_USE_TRIGGER_VALUES = 'use_trigger_values'
 CONDITION_TYPE_AND = 'and'
@@ -43,9 +49,7 @@ CONDITION_TYPE_OR = 'or'

 DEFAULT_CONDITION_TYPE = CONDITION_TYPE_AND
 DEFAULT_HIDE_ENTITY = False
-
-METHOD_TRIGGER = 'trigger'
-METHOD_IF_ACTION = 'if_action'
+DEFAULT_INITIAL_STATE = True

 ATTR_LAST_TRIGGERED = 'last_triggered'
 ATTR_VARIABLES = 'variables'
@@ -55,21 +59,14 @@ SERVICE_RELOAD = 'reload'
 _LOGGER = logging.getLogger(__name__)


-def _platform_validator(method, schema):
-    """Generate platform validator for different steps."""
-    def validator(config):
-        """Validate it is a valid  platform."""
-        platform = get_platform(DOMAIN, config[CONF_PLATFORM])
+def _platform_validator(config):
+    """Validate it is a valid  platform."""
+    platform = get_platform(DOMAIN, config[CONF_PLATFORM])

-        if not hasattr(platform, method):
-            raise vol.Invalid('invalid method platform')
+    if not hasattr(platform, 'TRIGGER_SCHEMA'):
+        return config

-        if not hasattr(platform, schema):
-            return config
-
-        return getattr(platform, schema)(config)
-
-    return validator
+    return getattr(platform, 'TRIGGER_SCHEMA')(config)

 _TRIGGER_SCHEMA = vol.All(
    cv.ensure_list,
@@ -78,33 +75,19 @@ _TRIGGER_SCHEMA = vol.All(
            vol.Schema({
                vol.Required(CONF_PLATFORM): cv.platform_validator(DOMAIN)
            }, extra=vol.ALLOW_EXTRA),
-            _platform_validator(METHOD_TRIGGER, 'TRIGGER_SCHEMA')
+            _platform_validator
        ),
    ]
 )

-_CONDITION_SCHEMA = vol.Any(
-    CONDITION_USE_TRIGGER_VALUES,
-    vol.All(
-        cv.ensure_list,
-        [
-            vol.All(
-                vol.Schema({
-                    CONF_PLATFORM: str,
-                    CONF_CONDITION: str,
-                }, extra=vol.ALLOW_EXTRA),
-                cv.has_at_least_one_key(CONF_PLATFORM, CONF_CONDITION),
-            ),
-        ]
-    )
-)
+_CONDITION_SCHEMA = vol.All(cv.ensure_list, [cv.CONDITION_SCHEMA])

 PLATFORM_SCHEMA = vol.Schema({
    CONF_ALIAS: cv.string,
+    vol.Optional(CONF_INITIAL_STATE,
+                 default=DEFAULT_INITIAL_STATE): cv.boolean,
    vol.Optional(CONF_HIDE_ENTITY, default=DEFAULT_HIDE_ENTITY): cv.boolean,
    vol.Required(CONF_TRIGGER): _TRIGGER_SCHEMA,
-    vol.Required(CONF_CONDITION_TYPE, default=DEFAULT_CONDITION_TYPE):
-        vol.All(vol.Lower, vol.Any(CONDITION_TYPE_AND, CONDITION_TYPE_OR)),
    vol.Optional(CONF_CONDITION): _CONDITION_SCHEMA,
    vol.Required(CONF_ACTION): cv.SCRIPT_SCHEMA,
 })
@@ -163,9 +146,11 @@ def reload(hass):

 def setup(hass, config):
    """Setup the automation."""
-    component = EntityComponent(_LOGGER, DOMAIN, hass)
+    component = EntityComponent(_LOGGER, DOMAIN, hass,
+                                group_name=GROUP_NAME_ALL_AUTOMATIONS)

-    success = _process_config(hass, config, component)
+    success = run_coroutine_threadsafe(
+        _async_process_config(hass, config, component), hass.loop).result()

    if not success:
        return False
@@ -173,22 +158,36 @@ def setup(hass, config):
    descriptions = conf_util.load_yaml_config_file(
        os.path.join(os.path.dirname(__file__), 'services.yaml'))

+    @callback
    def trigger_service_handler(service_call):
        """Handle automation triggers."""
-        for entity in component.extract_from_service(service_call):
-            entity.trigger(service_call.data.get(ATTR_VARIABLES))
+        for entity in component.async_extract_from_service(service_call):
+            hass.loop.create_task(entity.async_trigger(
+                service_call.data.get(ATTR_VARIABLES), True))

-    def service_handler(service_call):
-        """Handle automation service calls."""
-        for entity in component.extract_from_service(service_call):
-            getattr(entity, service_call.service)()
+    @callback
+    def turn_onoff_service_handler(service_call):
+        """Handle automation turn on/off service calls."""
+        method = 'async_{}'.format(service_call.service)
+        for entity in component.async_extract_from_service(service_call):
+            hass.loop.create_task(getattr(entity, method)())

+    @callback
+    def toggle_service_handler(service_call):
+        """Handle automation toggle service calls."""
+        for entity in component.async_extract_from_service(service_call):
+            if entity.is_on:
+                hass.loop.create_task(entity.async_turn_off())
+            else:
+                hass.loop.create_task(entity.async_turn_on())
+
+    @asyncio.coroutine
    def reload_service_handler(service_call):
        """Remove all automations and load new ones from config."""
-        conf = component.prepare_reload()
+        conf = yield from component.async_prepare_reload()
        if conf is None:
            return
-        _process_config(hass, conf, component)
+        hass.loop.create_task(_async_process_config(hass, conf, component))

    hass.services.register(DOMAIN, SERVICE_TRIGGER, trigger_service_handler,
                           descriptions.get(SERVICE_TRIGGER),
@@ -198,8 +197,12 @@ def setup(hass, config):
                           descriptions.get(SERVICE_RELOAD),
                           schema=RELOAD_SERVICE_SCHEMA)

-    for service in (SERVICE_TURN_ON, SERVICE_TURN_OFF, SERVICE_TOGGLE):
-        hass.services.register(DOMAIN, service, service_handler,
+    hass.services.register(DOMAIN, SERVICE_TOGGLE, toggle_service_handler,
+                           descriptions.get(SERVICE_TOGGLE),
+                           schema=SERVICE_SCHEMA)
+
+    for service in (SERVICE_TURN_ON, SERVICE_TURN_OFF):
+        hass.services.register(DOMAIN, service, turn_onoff_service_handler,
                               descriptions.get(service),
                               schema=SERVICE_SCHEMA)

@@ -209,15 +212,17 @@ def setup(hass, config):
 class AutomationEntity(ToggleEntity):
    """Entity to show status of entity."""

+    # pylint: disable=abstract-method
    # pylint: disable=too-many-arguments, too-many-instance-attributes
-    def __init__(self, name, attach_triggers, cond_func, action, hidden):
+    def __init__(self, name, async_attach_triggers, cond_func, async_action,
+                 hidden):
        """Initialize an automation entity."""
        self._name = name
-        self._attach_triggers = attach_triggers
-        self._detach_triggers = attach_triggers(self.trigger)
+        self._async_attach_triggers = async_attach_triggers
+        self._async_detach_triggers = None
        self._cond_func = cond_func
-        self._action = action
-        self._enabled = True
+        self._async_action = async_action
+        self._enabled = False
        self._last_triggered = None
        self._hidden = hidden

@@ -248,41 +253,67 @@ class AutomationEntity(ToggleEntity):
        """Return True if entity is on."""
        return self._enabled

-    def turn_on(self, **kwargs) -> None:
-        """Turn the entity on."""
+    @asyncio.coroutine
+    def async_turn_on(self, **kwargs) -> None:
+        """Turn the entity on and update the state."""
        if self._enabled:
            return

-        self._detach_triggers = self._attach_triggers(self.trigger)
-        self._enabled = True
-        self.update_ha_state()
+        yield from self.async_enable()
+        self.hass.loop.create_task(self.async_update_ha_state())

-    def turn_off(self, **kwargs) -> None:
+    @asyncio.coroutine
+    def async_turn_off(self, **kwargs) -> None:
        """Turn the entity off."""
        if not self._enabled:
            return

-        self._detach_triggers()
-        self._detach_triggers = None
+        self._async_detach_triggers()
+        self._async_detach_triggers = None
        self._enabled = False
-        self.update_ha_state()
+        # It's important that the update is finished before this method
+        # ends because async_remove depends on it.
+        yield from self.async_update_ha_state()

-    def trigger(self, variables):
-        """Trigger automation."""
-        if self._cond_func(variables):
-            self._action(variables)
+    @asyncio.coroutine
+    def async_trigger(self, variables, skip_condition=False):
+        """Trigger automation.
+
+        This method is a coroutine.
+        """
+        if skip_condition or self._cond_func(variables):
+            yield from self._async_action(self.entity_id, variables)
            self._last_triggered = utcnow()
-            self.update_ha_state()
+            self.hass.loop.create_task(self.async_update_ha_state())

-    def remove(self):
+    @asyncio.coroutine
+    def async_remove(self):
        """Remove automation from HASS."""
-        self.turn_off()
-        super().remove()
+        yield from self.async_turn_off()
+        yield from super().async_remove()
+
+    @asyncio.coroutine
+    def async_enable(self):
+        """Enable this automation entity.
+
+        This method is a coroutine.
+        """
+        if self._enabled:
+            return
+
+        self._async_detach_triggers = yield from self._async_attach_triggers(
+            self.async_trigger)
+        self._enabled = True


-def _process_config(hass, config, component):
-    """Process config and add automations."""
-    success = False
+@asyncio.coroutine
+def _async_process_config(hass, config, component):
+    """Process config and add automations.
+
+    This method is a coroutine.
+    """
+    entities = []
+    tasks = []

    for config_key in extract_domain_configs(config, DOMAIN):
        conf = config[config_key]
@@ -293,10 +324,11 @@ def _process_config(hass, config, component):

            hidden = config_block[CONF_HIDE_ENTITY]

-            action = _get_action(hass, config_block.get(CONF_ACTION, {}), name)
+            action = _async_get_action(hass, config_block.get(CONF_ACTION, {}),
+                                       name)

            if CONF_CONDITION in config_block:
-                cond_func = _process_if(hass, config, config_block)
+                cond_func = _async_process_if(hass, config, config_block)

                if cond_func is None:
                    continue
@@ -305,101 +337,78 @@ def _process_config(hass, config, component):
                    """Condition will always pass."""
                    return True

-            attach_triggers = partial(_process_trigger, hass, config,
-                                      config_block.get(CONF_TRIGGER, []), name)
-            entity = AutomationEntity(name, attach_triggers, cond_func, action,
-                                      hidden)
-            component.add_entities((entity,))
-            success = True
+            async_attach_triggers = partial(
+                _async_process_trigger, hass, config,
+                config_block.get(CONF_TRIGGER, []), name)
+            entity = AutomationEntity(name, async_attach_triggers, cond_func,
+                                      action, hidden)
+            if config_block[CONF_INITIAL_STATE]:
+                tasks.append(entity.async_enable())
+            entities.append(entity)

-    return success
+    yield from asyncio.gather(*tasks, loop=hass.loop)
+    hass.loop.create_task(component.async_add_entities(entities))
+
+    return len(entities) > 0


-def _get_action(hass, config, name):
+def _async_get_action(hass, config, name):
    """Return an action based on a configuration."""
    script_obj = script.Script(hass, config, name)

-    def action(variables=None):
+    @asyncio.coroutine
+    def action(entity_id, variables):
        """Action to be executed."""
        _LOGGER.info('Executing %s', name)
-        logbook.log_entry(hass, name, 'has been triggered', DOMAIN)
-        script_obj.run(variables)
+        logbook.async_log_entry(
+            hass, name, 'has been triggered', DOMAIN, entity_id)
+        hass.loop.create_task(script_obj.async_run(variables))

    return action


-def _process_if(hass, config, p_config):
+def _async_process_if(hass, config, p_config):
    """Process if checks."""
-    cond_type = p_config.get(CONF_CONDITION_TYPE,
-                             DEFAULT_CONDITION_TYPE).lower()
-
-    # Deprecated since 0.19 - 5/5/2016
-    if cond_type != DEFAULT_CONDITION_TYPE:
-        _LOGGER.warning('Using condition_type: "or" is deprecated. Please use '
-                        '"condition: or" instead.')
-
    if_configs = p_config.get(CONF_CONDITION)
-    use_trigger = if_configs == CONDITION_USE_TRIGGER_VALUES
-
-    if use_trigger:
-        if_configs = p_config[CONF_TRIGGER]

    checks = []
    for if_config in if_configs:
-        # Deprecated except for used by use_trigger_values
-        # since 0.19 - 5/5/2016
-        if CONF_PLATFORM in if_config:
-            if not use_trigger:
-                _LOGGER.warning("Please switch your condition configuration "
-                                "to use 'condition' instead of 'platform'.")
-            if_config = dict(if_config)
-            if_config[CONF_CONDITION] = if_config.pop(CONF_PLATFORM)
-
-            # To support use_trigger_values with state trigger accepting
-            # multiple entity_ids to monitor.
-            if_entity_id = if_config.get(ATTR_ENTITY_ID)
-            if isinstance(if_entity_id, list) and len(if_entity_id) == 1:
-                if_config[ATTR_ENTITY_ID] = if_entity_id[0]
-
        try:
-            checks.append(condition.from_config(if_config))
+            checks.append(condition.async_from_config(if_config, False))
        except HomeAssistantError as ex:
-            # Invalid conditions are allowed if we base it on trigger
-            if use_trigger:
-                _LOGGER.warning('Ignoring invalid condition: %s', ex)
-            else:
-                _LOGGER.warning('Invalid condition: %s', ex)
-                return None
+            _LOGGER.warning('Invalid condition: %s', ex)
+            return None

-    if cond_type == CONDITION_TYPE_AND:
-        def if_action(variables=None):
-            """AND all conditions."""
-            return all(check(hass, variables) for check in checks)
-    else:
-        def if_action(variables=None):
-            """OR all conditions."""
-            return any(check(hass, variables) for check in checks)
+    def if_action(variables=None):
+        """AND all conditions."""
+        return all(check(hass, variables) for check in checks)

    return if_action


-def _process_trigger(hass, config, trigger_configs, name, action):
-    """Setup the triggers."""
+@asyncio.coroutine
+def _async_process_trigger(hass, config, trigger_configs, name, action):
+    """Setup the triggers.
+
+    This method is a coroutine.
+    """
    removes = []

    for conf in trigger_configs:
-        platform = _resolve_platform(METHOD_TRIGGER, hass, config,
-                                     conf.get(CONF_PLATFORM))
-        if platform is None:
-            continue
+        platform = yield from hass.loop.run_in_executor(
+            None, prepare_setup_platform, hass, config, DOMAIN,
+            conf.get(CONF_PLATFORM))

-        remove = platform.trigger(hass, conf, action)
+        if platform is None:
+            return None
+
+        remove = platform.async_trigger(hass, conf, action)

        if not remove:
-            _LOGGER.error("Error setting up rule %s", name)
+            _LOGGER.error("Error setting up trigger %s", name)
            continue

-        _LOGGER.info("Initialized rule %s", name)
+        _LOGGER.info("Initialized trigger %s", name)
        removes.append(remove)

    if not removes:
@@ -411,17 +420,3 @@ def _process_trigger(hass, config, trigger_configs, name, action):
            remove()

    return remove_triggers
-
-
-def _resolve_platform(method, hass, config, platform):
-    """Find the automation platform."""
-    if platform is None:
-        return None
-    platform = prepare_setup_platform(hass, config, DOMAIN, platform)
-
-    if platform is None or not hasattr(platform, method):
-        _LOGGER.error("Unknown automation platform specified for %s: %s",
-                      method, platform)
-        return None
-
-    return platform
@@ -4,11 +4,11 @@ Offer event listening automation rules.
 For more details about this automation rule, please refer to the documentation
 at https://home-assistant.io/components/automation/#event-trigger
 """
-import asyncio
 import logging

 import voluptuous as vol

+from homeassistant.core import callback
 from homeassistant.const import CONF_PLATFORM
 from homeassistant.helpers import config_validation as cv

@@ -24,21 +24,21 @@ TRIGGER_SCHEMA = vol.Schema({
 })


-def trigger(hass, config, action):
+def async_trigger(hass, config, action):
    """Listen for events based on configuration."""
    event_type = config.get(CONF_EVENT_TYPE)
    event_data = config.get(CONF_EVENT_DATA)

-    @asyncio.coroutine
+    @callback
    def handle_event(event):
        """Listen for events and calls the action when data matches."""
        if not event_data or all(val == event.data.get(key) for key, val
                                 in event_data.items()):
-            hass.async_add_job(action, {
+            hass.async_run_job(action, {
                'trigger': {
                    'platform': 'event',
                    'event': event,
                },
            })

-    return hass.bus.listen(event_type, handle_event)
+    return hass.bus.async_listen(event_type, handle_event)
@@ -6,6 +6,7 @@ at https://home-assistant.io/components/automation/#mqtt-trigger
 """
 import voluptuous as vol

+from homeassistant.core import callback
 import homeassistant.components.mqtt as mqtt
 from homeassistant.const import (CONF_PLATFORM, CONF_PAYLOAD)
 import homeassistant.helpers.config_validation as cv
@@ -21,15 +22,16 @@ TRIGGER_SCHEMA = vol.Schema({
 })


-def trigger(hass, config, action):
+def async_trigger(hass, config, action):
    """Listen for state changes based on configuration."""
    topic = config.get(CONF_TOPIC)
    payload = config.get(CONF_PAYLOAD)

+    @callback
    def mqtt_automation_listener(msg_topic, msg_payload, qos):
        """Listen for MQTT messages."""
        if payload is None or payload == msg_payload:
-            action({
+            hass.async_run_job(action, {
                'trigger': {
                    'platform': 'mqtt',
                    'topic': msg_topic,
@@ -38,4 +40,4 @@ def trigger(hass, config, action):
                }
            })

-    return mqtt.subscribe(hass, topic, mqtt_automation_listener)
+    return mqtt.async_subscribe(hass, topic, mqtt_automation_listener)
@@ -8,10 +8,11 @@ import logging

 import voluptuous as vol

+from homeassistant.core import callback
 from homeassistant.const import (
    CONF_VALUE_TEMPLATE, CONF_PLATFORM, CONF_ENTITY_ID,
    CONF_BELOW, CONF_ABOVE)
-from homeassistant.helpers.event import track_state_change
+from homeassistant.helpers.event import async_track_state_change
 from homeassistant.helpers import condition, config_validation as cv

 TRIGGER_SCHEMA = vol.All(vol.Schema({
@@ -25,7 +26,7 @@ TRIGGER_SCHEMA = vol.All(vol.Schema({
 _LOGGER = logging.getLogger(__name__)


-def trigger(hass, config, action):
+def async_trigger(hass, config, action):
    """Listen for state changes based on configuration."""
    entity_id = config.get(CONF_ENTITY_ID)
    below = config.get(CONF_BELOW)
@@ -34,7 +35,7 @@ def trigger(hass, config, action):
    if value_template is not None:
        value_template.hass = hass

-    # pylint: disable=unused-argument
+    @callback
    def state_automation_listener(entity, from_s, to_s):
        """Listen for state changes and calls action."""
        if to_s is None:
@@ -50,19 +51,19 @@ def trigger(hass, config, action):
        }

        # If new one doesn't match, nothing to do
-        if not condition.numeric_state(
+        if not condition.async_numeric_state(
                hass, to_s, below, above, value_template, variables):
            return

        # Only match if old didn't exist or existed but didn't match
        # Written as: skip if old one did exist and matched
-        if from_s is not None and condition.numeric_state(
+        if from_s is not None and condition.async_numeric_state(
                hass, from_s, below, above, value_template, variables):
            return

        variables['trigger']['from_state'] = from_s
        variables['trigger']['to_state'] = to_s

-        action(variables)
+        hass.async_run_job(action, variables)

-    return track_state_change(hass, entity_id, state_automation_listener)
+    return async_track_state_change(hass, entity_id, state_automation_listener)
@@ -6,9 +6,11 @@ at https://home-assistant.io/components/automation/#state-trigger
 """
 import voluptuous as vol

+from homeassistant.core import callback
 import homeassistant.util.dt as dt_util
 from homeassistant.const import MATCH_ALL, CONF_PLATFORM
-from homeassistant.helpers.event import track_state_change, track_point_in_time
+from homeassistant.helpers.event import (
+    async_track_state_change, async_track_point_in_utc_time)
 import homeassistant.helpers.config_validation as cv

 CONF_ENTITY_ID = "entity_id"
@@ -32,22 +34,23 @@ TRIGGER_SCHEMA = vol.All(
 )


-def trigger(hass, config, action):
+def async_trigger(hass, config, action):
    """Listen for state changes based on configuration."""
    entity_id = config.get(CONF_ENTITY_ID)
    from_state = config.get(CONF_FROM, MATCH_ALL)
    to_state = config.get(CONF_TO) or config.get(CONF_STATE) or MATCH_ALL
    time_delta = config.get(CONF_FOR)
-    remove_state_for_cancel = None
-    remove_state_for_listener = None
+    async_remove_state_for_cancel = None
+    async_remove_state_for_listener = None

+    @callback
    def state_automation_listener(entity, from_s, to_s):
        """Listen for state changes and calls action."""
-        nonlocal remove_state_for_cancel, remove_state_for_listener
+        nonlocal async_remove_state_for_cancel, async_remove_state_for_listener

        def call_action():
            """Call action with right context."""
-            action({
+            hass.async_run_job(action, {
                'trigger': {
                    'platform': 'state',
                    'entity_id': entity,
@@ -61,35 +64,37 @@ def trigger(hass, config, action):
            call_action()
            return

+        @callback
        def state_for_listener(now):
            """Fire on state changes after a delay and calls action."""
-            remove_state_for_cancel()
+            async_remove_state_for_cancel()
            call_action()

+        @callback
        def state_for_cancel_listener(entity, inner_from_s, inner_to_s):
            """Fire on changes and cancel for listener if changed."""
            if inner_to_s.state == to_s.state:
                return
-            remove_state_for_listener()
-            remove_state_for_cancel()
+            async_remove_state_for_listener()
+            async_remove_state_for_cancel()

-        remove_state_for_listener = track_point_in_time(
+        async_remove_state_for_listener = async_track_point_in_utc_time(
            hass, state_for_listener, dt_util.utcnow() + time_delta)

-        remove_state_for_cancel = track_state_change(
+        async_remove_state_for_cancel = async_track_state_change(
            hass, entity, state_for_cancel_listener)

-    unsub = track_state_change(hass, entity_id, state_automation_listener,
-                               from_state, to_state)
+    unsub = async_track_state_change(
+        hass, entity_id, state_automation_listener, from_state, to_state)

-    def remove():
-        """Remove state listeners."""
+    def async_remove():
+        """Remove state listeners async."""
        unsub()
        # pylint: disable=not-callable
-        if remove_state_for_cancel is not None:
-            remove_state_for_cancel()
+        if async_remove_state_for_cancel is not None:
+            async_remove_state_for_cancel()

-        if remove_state_for_listener is not None:
-            remove_state_for_listener()
+        if async_remove_state_for_listener is not None:
+            async_remove_state_for_listener()

-    return remove
+    return async_remove
@@ -9,9 +9,10 @@ import logging

 import voluptuous as vol

+from homeassistant.core import callback
 from homeassistant.const import (
    CONF_EVENT, CONF_OFFSET, CONF_PLATFORM, SUN_EVENT_SUNRISE)
-from homeassistant.helpers.event import track_sunrise, track_sunset
+from homeassistant.helpers.event import async_track_sunrise, async_track_sunset
 import homeassistant.helpers.config_validation as cv

 DEPENDENCIES = ['sun']
@@ -25,14 +26,15 @@ TRIGGER_SCHEMA = vol.Schema({
 })


-def trigger(hass, config, action):
+def async_trigger(hass, config, action):
    """Listen for events based on configuration."""
    event = config.get(CONF_EVENT)
    offset = config.get(CONF_OFFSET)

+    @callback
    def call_action():
        """Call action with right context."""
-        action({
+        hass.async_run_job(action, {
            'trigger': {
                'platform': 'sun',
                'event': event,
@@ -42,6 +44,6 @@ def trigger(hass, config, action):

    # Do something to call action
    if event == SUN_EVENT_SUNRISE:
-        return track_sunrise(hass, call_action, offset)
+        return async_track_sunrise(hass, call_action, offset)
    else:
-        return track_sunset(hass, call_action, offset)
+        return async_track_sunset(hass, call_action, offset)
@@ -4,14 +4,14 @@ Offer template automation rules.
 For more details about this automation rule, please refer to the documentation
 at https://home-assistant.io/components/automation/#template-trigger
 """
-import asyncio
 import logging

 import voluptuous as vol

+from homeassistant.core import callback
 from homeassistant.const import CONF_VALUE_TEMPLATE, CONF_PLATFORM
 from homeassistant.helpers import condition
-from homeassistant.helpers.event import track_state_change
+from homeassistant.helpers.event import async_track_state_change
 import homeassistant.helpers.config_validation as cv


@@ -23,7 +23,7 @@ TRIGGER_SCHEMA = IF_ACTION_SCHEMA = vol.Schema({
 })


-def trigger(hass, config, action):
+def async_trigger(hass, config, action):
    """Listen for state changes based on configuration."""
    value_template = config.get(CONF_VALUE_TEMPLATE)
    value_template.hass = hass
@@ -31,7 +31,7 @@ def trigger(hass, config, action):
    # Local variable to keep track of if the action has already been triggered
    already_triggered = False

-    @asyncio.coroutine
+    @callback
    def state_changed_listener(entity_id, from_s, to_s):
        """Listen for state changes and calls action."""
        nonlocal already_triggered
@@ -40,7 +40,7 @@ def trigger(hass, config, action):
        # Check to see if template returns true
        if template_result and not already_triggered:
            already_triggered = True
-            hass.async_add_job(action, {
+            hass.async_run_job(action, {
                'trigger': {
                    'platform': 'template',
                    'entity_id': entity_id,
@@ -51,5 +51,5 @@ def trigger(hass, config, action):
        elif not template_result:
            already_triggered = False

-    return track_state_change(hass, value_template.extract_entities(),
-                              state_changed_listener)
+    return async_track_state_change(hass, value_template.extract_entities(),
+                                    state_changed_listener)
@@ -8,9 +8,10 @@ import logging

 import voluptuous as vol

+from homeassistant.core import callback
 from homeassistant.const import CONF_AFTER, CONF_PLATFORM
 from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.event import track_time_change
+from homeassistant.helpers.event import async_track_time_change

 CONF_HOURS = "hours"
 CONF_MINUTES = "minutes"
@@ -28,7 +29,7 @@ TRIGGER_SCHEMA = vol.All(vol.Schema({
                            CONF_SECONDS, CONF_AFTER))


-def trigger(hass, config, action):
+def async_trigger(hass, config, action):
    """Listen for state changes based on configuration."""
    if CONF_AFTER in config:
        after = config.get(CONF_AFTER)
@@ -38,14 +39,15 @@ def trigger(hass, config, action):
        minutes = config.get(CONF_MINUTES)
        seconds = config.get(CONF_SECONDS)

+    @callback
    def time_automation_listener(now):
        """Listen for time changes and calls action."""
-        action({
+        hass.async_run_job(action, {
            'trigger': {
                'platform': 'time',
                'now': now,
            },
        })

-    return track_time_change(hass, time_automation_listener,
-                             hour=hours, minute=minutes, second=seconds)
+    return async_track_time_change(hass, time_automation_listener,
+                                   hour=hours, minute=minutes, second=seconds)
@@ -6,9 +6,10 @@ at https://home-assistant.io/components/automation/#zone-trigger
 """
 import voluptuous as vol

+from homeassistant.core import callback
 from homeassistant.const import (
    CONF_EVENT, CONF_ENTITY_ID, CONF_ZONE, MATCH_ALL, CONF_PLATFORM)
-from homeassistant.helpers.event import track_state_change
+from homeassistant.helpers.event import async_track_state_change
 from homeassistant.helpers import (
    condition, config_validation as cv, location)

@@ -25,12 +26,13 @@ TRIGGER_SCHEMA = vol.Schema({
 })


-def trigger(hass, config, action):
+def async_trigger(hass, config, action):
    """Listen for state changes based on configuration."""
    entity_id = config.get(CONF_ENTITY_ID)
    zone_entity_id = config.get(CONF_ZONE)
    event = config.get(CONF_EVENT)

+    @callback
    def zone_automation_listener(entity, from_s, to_s):
        """Listen for state changes and calls action."""
        if from_s and not location.has_location(from_s) or \
@@ -47,7 +49,7 @@ def trigger(hass, config, action):
        # pylint: disable=too-many-boolean-expressions
        if event == EVENT_ENTER and not from_match and to_match or \
           event == EVENT_LEAVE and from_match and not to_match:
-            action({
+            hass.async_run_job(action, {
                'trigger': {
                    'platform': 'zone',
                    'entity_id': entity,
@@ -58,5 +60,5 @@ def trigger(hass, config, action):
                },
            })

-    return track_state_change(hass, entity_id, zone_automation_listener,
-                              MATCH_ALL, MATCH_ALL)
+    return async_track_state_change(hass, entity_id, zone_automation_listener,
+                                    MATCH_ALL, MATCH_ALL)
@@ -1,5 +1,5 @@
 """
-Support for exposed aREST RESTful API of a device.
+Support for an exposed aREST RESTful API of a device.

 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/binary_sensor.arest/
@@ -8,31 +8,32 @@ import logging
 from datetime import timedelta

 import requests
+import voluptuous as vol

 from homeassistant.components.binary_sensor import (
-    BinarySensorDevice, SENSOR_CLASSES)
-from homeassistant.const import CONF_RESOURCE, CONF_PIN
+    BinarySensorDevice, PLATFORM_SCHEMA, SENSOR_CLASSES_SCHEMA)
+from homeassistant.const import (
+    CONF_RESOURCE, CONF_PIN, CONF_NAME, CONF_SENSOR_CLASS)
 from homeassistant.util import Throttle
+import homeassistant.helpers.config_validation as cv

 _LOGGER = logging.getLogger(__name__)

 MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=30)

+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_RESOURCE): cv.url,
+    vol.Optional(CONF_NAME): cv.string,
+    vol.Required(CONF_PIN): cv.string,
+    vol.Optional(CONF_SENSOR_CLASS): SENSOR_CLASSES_SCHEMA,
+})
+

 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Setup the aREST binary sensor."""
    resource = config.get(CONF_RESOURCE)
    pin = config.get(CONF_PIN)
-
-    sensor_class = config.get('sensor_class')
-    if sensor_class not in SENSOR_CLASSES:
-        _LOGGER.warning('Unknown sensor class: %s', sensor_class)
-        sensor_class = None
-
-    if None in (resource, pin):
-        _LOGGER.error('Not all required config keys present: %s',
-                      ', '.join((CONF_RESOURCE, CONF_PIN)))
-        return False
+    sensor_class = config.get(CONF_SENSOR_CLASS)

    try:
        response = requests.get(resource, timeout=10).json()
@@ -49,11 +50,8 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    arest = ArestData(resource, pin)

    add_devices([ArestBinarySensor(
-        arest,
-        resource,
-        config.get('name', response['name']),
-        sensor_class,
-        pin)])
+        arest, resource, config.get(CONF_NAME, response[CONF_NAME]),
+        sensor_class, pin)])


 # pylint: disable=too-many-instance-attributes, too-many-arguments
@@ -0,0 +1,143 @@
+"""
+Support for exposing Concord232 elements as sensors.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.concord232/
+"""
+import datetime
+
+import logging
+
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA, SENSOR_CLASSES)
+from homeassistant.const import (CONF_HOST, CONF_PORT)
+
+import homeassistant.helpers.config_validation as cv
+
+import requests
+
+import voluptuous as vol
+
+
+REQUIREMENTS = ['concord232==0.14']
+
+_LOGGER = logging.getLogger(__name__)
+
+CONF_EXCLUDE_ZONES = 'exclude_zones'
+CONF_ZONE_TYPES = 'zone_types'
+
+DEFAULT_HOST = 'localhost'
+DEFAULT_PORT = '5007'
+DEFAULT_SSL = False
+
+ZONE_TYPES_SCHEMA = vol.Schema({
+    cv.positive_int: vol.In(SENSOR_CLASSES),
+})
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_EXCLUDE_ZONES, default=[]):
+        vol.All(cv.ensure_list, [cv.positive_int]),
+    vol.Optional(CONF_HOST, default=DEFAULT_HOST): cv.string,
+    vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
+    vol.Optional(CONF_ZONE_TYPES, default={}): ZONE_TYPES_SCHEMA,
+})
+
+SCAN_INTERVAL = 1
+
+DEFAULT_NAME = "Alarm"
+
+
+# pylint: disable=too-many-locals
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup the Concord232 binary sensor platform."""
+    from concord232 import client as concord232_client
+
+    host = config.get(CONF_HOST)
+    port = config.get(CONF_PORT)
+    exclude = config.get(CONF_EXCLUDE_ZONES)
+    zone_types = config.get(CONF_ZONE_TYPES)
+    sensors = []
+
+    try:
+        _LOGGER.debug('Initializing Client.')
+        client = concord232_client.Client('http://{}:{}'
+                                          .format(host, port))
+        client.zones = client.list_zones()
+        client.last_zone_update = datetime.datetime.now()
+
+    except requests.exceptions.ConnectionError as ex:
+        _LOGGER.error('Unable to connect to Concord232: %s', str(ex))
+        return False
+
+    for zone in client.zones:
+        _LOGGER.info('Loading Zone found: %s', zone['name'])
+        if zone['number'] not in exclude:
+            sensors.append(Concord232ZoneSensor(
+                hass,
+                client,
+                zone,
+                zone_types.get(zone['number'], get_opening_type(zone))))
+
+        add_devices(sensors)
+
+    return True
+
+
+def get_opening_type(zone):
+    """Helper function to try to guess sensor type frm name."""
+    if "MOTION" in zone["name"]:
+        return "motion"
+    if "KEY" in zone["name"]:
+        return "safety"
+    if "SMOKE" in zone["name"]:
+        return "smoke"
+    if "WATER" in zone["name"]:
+        return "water"
+    return "opening"
+
+
+class Concord232ZoneSensor(BinarySensorDevice):
+    """Representation of a Concord232 zone as a sensor."""
+
+    def __init__(self, hass, client, zone, zone_type):
+        """Initialize the Concord232 binary sensor."""
+        self._hass = hass
+        self._client = client
+        self._zone = zone
+        self._number = zone['number']
+        self._zone_type = zone_type
+        self.update()
+
+    @property
+    def sensor_class(self):
+        """Return the class of this sensor, from SENSOR_CLASSES."""
+        return self._zone_type
+
+    @property
+    def should_poll(self):
+        """No polling needed."""
+        return True
+
+    @property
+    def name(self):
+        """Return the name of the binary sensor."""
+        return self._zone['name']
+
+    @property
+    def is_on(self):
+        """Return true if the binary sensor is on."""
+        # True means "faulted" or "open" or "abnormal state"
+        return bool(self._zone['state'] == 'Normal')
+
+    def update(self):
+        """"Get updated stats from API."""
+        last_update = datetime.datetime.now() - self._client.last_zone_update
+        _LOGGER.debug("Zone: %s ", self._zone)
+        if last_update > datetime.timedelta(seconds=1):
+            self._client.zones = self._client.list_zones()
+            self._client.last_zone_update = datetime.datetime.now()
+            _LOGGER.debug("Updated from Zone: %s", self._zone['name'])
+
+        if hasattr(self._client, 'zones'):
+            self._zone = next((x for x in self._client.zones
+                               if x['number'] == self._number), None)
@@ -0,0 +1,91 @@
+"""
+Support for monitoring the state of Digital Ocean droplets.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.digital_ocean/
+"""
+import logging
+
+import voluptuous as vol
+
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.components.digital_ocean import (
+    CONF_DROPLETS, ATTR_CREATED_AT, ATTR_DROPLET_ID, ATTR_DROPLET_NAME,
+    ATTR_FEATURES, ATTR_IPV4_ADDRESS, ATTR_IPV6_ADDRESS, ATTR_MEMORY,
+    ATTR_REGION, ATTR_VCPUS)
+from homeassistant.loader import get_component
+import homeassistant.helpers.config_validation as cv
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_NAME = 'Droplet'
+DEFAULT_SENSOR_CLASS = 'motion'
+DEPENDENCIES = ['digital_ocean']
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_DROPLETS): vol.All(cv.ensure_list, [cv.string]),
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup the Digital Ocean droplet sensor."""
+    digital_ocean = get_component('digital_ocean')
+    droplets = config.get(CONF_DROPLETS)
+
+    dev = []
+    for droplet in droplets:
+        droplet_id = digital_ocean.DIGITAL_OCEAN.get_droplet_id(droplet)
+        dev.append(DigitalOceanBinarySensor(
+            digital_ocean.DIGITAL_OCEAN, droplet_id))
+
+    add_devices(dev)
+
+
+class DigitalOceanBinarySensor(BinarySensorDevice):
+    """Representation of a Digital Ocean droplet sensor."""
+
+    def __init__(self, do, droplet_id):
+        """Initialize a new Digital Ocean sensor."""
+        self._digital_ocean = do
+        self._droplet_id = droplet_id
+        self._state = None
+        self.update()
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self.data.name
+
+    @property
+    def is_on(self):
+        """Return true if the binary sensor is on."""
+        return self.data.status == 'active'
+
+    @property
+    def sensor_class(self):
+        """Return the class of this sensor."""
+        return DEFAULT_SENSOR_CLASS
+
+    @property
+    def state_attributes(self):
+        """Return the state attributes of the Digital Ocean droplet."""
+        return {
+            ATTR_CREATED_AT: self.data.created_at,
+            ATTR_DROPLET_ID: self.data.id,
+            ATTR_DROPLET_NAME: self.data.name,
+            ATTR_FEATURES: self.data.features,
+            ATTR_IPV4_ADDRESS: self.data.ip_address,
+            ATTR_IPV6_ADDRESS: self.data.ip_v6_address,
+            ATTR_MEMORY: self.data.memory,
+            ATTR_REGION: self.data.region['name'],
+            ATTR_VCPUS: self.data.vcpus,
+        }
+
+    def update(self):
+        """Update state of sensor."""
+        self._digital_ocean.update()
+
+        for droplet in self._digital_ocean.data:
+            if droplet.id == self._droplet_id:
+                self.data = droplet
@@ -16,6 +16,7 @@ DEPENDENCIES = ['homematic']
 SENSOR_TYPES_CLASS = {
    "Remote": None,
    "ShutterContact": "opening",
+    "IPShutterContact": "opening",
    "Smoke": "smoke",
    "SmokeV2": "smoke",
    "Motion": "motion",
@@ -0,0 +1,127 @@
+"""
+Support for the Netatmo binary sensors.
+
+The binary sensors based on events seen by the NetatmoCamera
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.netatmo/
+"""
+import logging
+import voluptuous as vol
+
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.components.netatmo import WelcomeData
+from homeassistant.loader import get_component
+from homeassistant.const import CONF_MONITORED_CONDITIONS
+from homeassistant.helpers import config_validation as cv
+
+DEPENDENCIES = ["netatmo"]
+
+_LOGGER = logging.getLogger(__name__)
+
+
+# These are the available sensors mapped to binary_sensor class
+SENSOR_TYPES = {
+    "Someone known": "motion",
+    "Someone unknown": "motion",
+    "Motion": "motion",
+}
+
+CONF_HOME = 'home'
+CONF_CAMERAS = 'cameras'
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_HOME): cv.string,
+    vol.Optional(CONF_CAMERAS, default=[]):
+        vol.All(cv.ensure_list, [cv.string]),
+    vol.Optional(CONF_MONITORED_CONDITIONS, default=SENSOR_TYPES.keys()):
+        vol.All(cv.ensure_list, [vol.In(SENSOR_TYPES)]),
+})
+
+
+# pylint: disable=unused-argument
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup access to Netatmo binary sensor."""
+    netatmo = get_component('netatmo')
+    home = config.get(CONF_HOME, None)
+
+    import lnetatmo
+    try:
+        data = WelcomeData(netatmo.NETATMO_AUTH, home)
+        if data.get_camera_names() == []:
+            return None
+    except lnetatmo.NoDevice:
+        return None
+
+    sensors = config.get(CONF_MONITORED_CONDITIONS, SENSOR_TYPES)
+
+    for camera_name in data.get_camera_names():
+        if CONF_CAMERAS in config:
+            if config[CONF_CAMERAS] != [] and \
+               camera_name not in config[CONF_CAMERAS]:
+                continue
+        for variable in sensors:
+            add_devices([WelcomeBinarySensor(data, camera_name, home,
+                                             variable)])
+
+
+class WelcomeBinarySensor(BinarySensorDevice):
+    """Represent a single binary sensor in a Netatmo Welcome device."""
+
+    def __init__(self, data, camera_name, home, sensor):
+        """Setup for access to the Netatmo camera events."""
+        self._data = data
+        self._camera_name = camera_name
+        self._home = home
+        if home:
+            self._name = home + ' / ' + camera_name
+        else:
+            self._name = camera_name
+        self._sensor_name = sensor
+        self._name += ' ' + sensor
+        camera_id = data.welcomedata.cameraByName(camera=camera_name,
+                                                  home=home)['id']
+        self._unique_id = "Welcome_binary_sensor {0} - {1}".format(self._name,
+                                                                   camera_id)
+        self.update()
+
+    @property
+    def name(self):
+        """The name of the Netatmo device and this sensor."""
+        return self._name
+
+    @property
+    def unique_id(self):
+        """Return the unique ID for this sensor."""
+        return self._unique_id
+
+    @property
+    def sensor_class(self):
+        """Return the class of this sensor, from SENSOR_CLASSES."""
+        return SENSOR_TYPES.get(self._sensor_name)
+
+    @property
+    def is_on(self):
+        """Return true if binary sensor is on."""
+        return self._state
+
+    def update(self):
+        """Request an update from the Netatmo API."""
+        self._data.update()
+        self._data.welcomedata.updateEvent(home=self._data.home)
+
+        if self._sensor_name == "Someone known":
+            self._state =\
+                    self._data.welcomedata.someoneKnownSeen(self._home,
+                                                            self._camera_name)
+        elif self._sensor_name == "Someone unknown":
+            self._state =\
+                self._data.welcomedata.someoneUnknownSeen(self._home,
+                                                          self._camera_name)
+        elif self._sensor_name == "Motion":
+            self._state =\
+                self._data.welcomedata.motionDetected(self._home,
+                                                      self._camera_name)
+        else:
+            return None
@@ -1,41 +1,56 @@
 """
-Support for exposing nx584 elements as sensors.
+Support for exposing NX584 elements as sensors.

 For more details about this platform, please refer to the documentation at
-https://home-assistant.io/components/sensor.nx584/
+https://home-assistant.io/components/binary_sensor.nx584/
 """
 import logging
 import threading
 import time

 import requests
+import voluptuous as vol

 from homeassistant.components.binary_sensor import (
-    SENSOR_CLASSES, BinarySensorDevice)
+    SENSOR_CLASSES, BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.const import (CONF_HOST, CONF_PORT)
+import homeassistant.helpers.config_validation as cv

 REQUIREMENTS = ['pynx584==0.2']
+
 _LOGGER = logging.getLogger(__name__)

+CONF_EXCLUDE_ZONES = 'exclude_zones'
+CONF_ZONE_TYPES = 'zone_types'
+
+DEFAULT_HOST = 'localhost'
+DEFAULT_PORT = '5007'
+DEFAULT_SSL = False
+
+ZONE_TYPES_SCHEMA = vol.Schema({
+    cv.positive_int: vol.In(SENSOR_CLASSES),
+})
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_EXCLUDE_ZONES, default=[]):
+        vol.All(cv.ensure_list, [cv.positive_int]),
+    vol.Optional(CONF_HOST, default=DEFAULT_HOST): cv.string,
+    vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
+    vol.Optional(CONF_ZONE_TYPES, default={}): ZONE_TYPES_SCHEMA,
+})
+

 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup nx584 binary sensor platform."""
+    """Setup the NX584 binary sensor platform."""
    from nx584 import client as nx584_client

-    host = config.get('host', 'localhost:5007')
-    exclude = config.get('exclude_zones', [])
-    zone_types = config.get('zone_types', {})
-
-    if not all(isinstance(zone, int) for zone in exclude):
-        _LOGGER.error('Invalid excluded zone specified (use zone number)')
-        return False
-
-    if not all(isinstance(zone, int) and ztype in SENSOR_CLASSES
-               for zone, ztype in zone_types.items()):
-        _LOGGER.error('Invalid zone_types entry')
-        return False
+    host = config.get(CONF_HOST)
+    port = config.get(CONF_PORT)
+    exclude = config.get(CONF_EXCLUDE_ZONES)
+    zone_types = config.get(CONF_ZONE_TYPES)

    try:
-        client = nx584_client.Client('http://%s' % host)
+        client = nx584_client.Client('http://{}:{}'.format(host, port))
        zones = client.list_zones()
    except requests.exceptions.ConnectionError as ex:
        _LOGGER.error('Unable to connect to NX584: %s', str(ex))
@@ -43,7 +58,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):

    version = [int(v) for v in client.get_version().split('.')]
    if version < [1, 1]:
-        _LOGGER.error('NX584 is too old to use for sensors (>=0.2 required)')
+        _LOGGER.error("NX584 is too old to use for sensors (>=0.2 required)")
        return False

    zone_sensors = {
@@ -57,13 +72,12 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
        watcher = NX584Watcher(client, zone_sensors)
        watcher.start()
    else:
-        _LOGGER.warning('No zones found on NX584')
-
+        _LOGGER.warning("No zones found on NX584")
    return True


 class NX584ZoneSensor(BinarySensorDevice):
-    """Represents a NX584 zone as a sensor."""
+    """Representation of a NX584 zone as a sensor."""

    def __init__(self, zone, zone_type):
        """Initialize the nx594 binary sensor."""
@@ -96,7 +110,7 @@ class NX584Watcher(threading.Thread):
    """Event listener thread to process NX584 events."""

    def __init__(self, client, zone_sensors):
-        """Initialize nx584 watcher thread."""
+        """Initialize NX584 watcher thread."""
        super(NX584Watcher, self).__init__()
        self.daemon = True
        self._client = client
@@ -130,5 +144,5 @@ class NX584Watcher(threading.Thread):
            try:
                self._run()
            except requests.exceptions.ConnectionError:
-                _LOGGER.error('Failed to reach NX584 server')
+                _LOGGER.error("Failed to reach NX584 server")
                time.sleep(10)
@@ -7,13 +7,16 @@ https://home-assistant.io/components/binary_sensor.rest/
 import logging

 import voluptuous as vol
+from requests.auth import HTTPBasicAuth, HTTPDigestAuth

 from homeassistant.components.binary_sensor import (
    BinarySensorDevice, SENSOR_CLASSES_SCHEMA, PLATFORM_SCHEMA)
 from homeassistant.components.sensor.rest import RestData
 from homeassistant.const import (
    CONF_PAYLOAD, CONF_NAME, CONF_VALUE_TEMPLATE, CONF_METHOD, CONF_RESOURCE,
-    CONF_SENSOR_CLASS, CONF_VERIFY_SSL)
+    CONF_SENSOR_CLASS, CONF_VERIFY_SSL, CONF_USERNAME, CONF_PASSWORD,
+    CONF_HEADERS, CONF_AUTHENTICATION, HTTP_BASIC_AUTHENTICATION,
+    HTTP_DIGEST_AUTHENTICATION)
 import homeassistant.helpers.config_validation as cv

 _LOGGER = logging.getLogger(__name__)
@@ -24,16 +27,21 @@ DEFAULT_VERIFY_SSL = True

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Required(CONF_RESOURCE): cv.url,
+    vol.Optional(CONF_AUTHENTICATION):
+        vol.In([HTTP_BASIC_AUTHENTICATION, HTTP_DIGEST_AUTHENTICATION]),
+    vol.Optional(CONF_HEADERS): {cv.string: cv.string},
    vol.Optional(CONF_METHOD, default=DEFAULT_METHOD): vol.In(['POST', 'GET']),
    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Optional(CONF_PASSWORD): cv.string,
    vol.Optional(CONF_PAYLOAD): cv.string,
    vol.Optional(CONF_SENSOR_CLASS): SENSOR_CLASSES_SCHEMA,
+    vol.Optional(CONF_USERNAME): cv.string,
    vol.Optional(CONF_VALUE_TEMPLATE): cv.template,
    vol.Optional(CONF_VERIFY_SSL, default=DEFAULT_VERIFY_SSL): cv.boolean,
 })


-# pylint: disable=unused-variable
+# pylint: disable=unused-variable, too-many-locals
 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Setup the REST binary sensor."""
    name = config.get(CONF_NAME)
@@ -41,15 +49,27 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    method = config.get(CONF_METHOD)
    payload = config.get(CONF_PAYLOAD)
    verify_ssl = config.get(CONF_VERIFY_SSL)
+    username = config.get(CONF_USERNAME)
+    password = config.get(CONF_PASSWORD)
+    headers = config.get(CONF_HEADERS)
    sensor_class = config.get(CONF_SENSOR_CLASS)
    value_template = config.get(CONF_VALUE_TEMPLATE)
    if value_template is not None:
        value_template.hass = hass
-    rest = RestData(method, resource, payload, verify_ssl)
+
+    if username and password:
+        if config.get(CONF_AUTHENTICATION) == HTTP_DIGEST_AUTHENTICATION:
+            auth = HTTPDigestAuth(username, password)
+        else:
+            auth = HTTPBasicAuth(username, password)
+    else:
+        auth = None
+
+    rest = RestData(method, resource, auth, headers, payload, verify_ssl)
    rest.update()

    if rest.data is None:
-        _LOGGER.error('Unable to fetch REST data')
+        _LOGGER.error("Unable to fetch REST data from %s", resource)
        return False

    add_devices([RestBinarySensor(
@@ -88,8 +108,8 @@ class RestBinarySensor(BinarySensorDevice):
            return False

        if self._value_template is not None:
-            response = self._value_template.render_with_possible_json_value(
-                self.rest.data, False)
+            response = self._value_template.\
+                async_render_with_possible_json_value(self.rest.data, False)

        try:
            return bool(int(response))
@@ -7,21 +7,20 @@ https://home-assistant.io/components/binary_sensor.tcp/
 import logging

 from homeassistant.components.binary_sensor import BinarySensorDevice
-from homeassistant.components.sensor.tcp import Sensor, CONF_VALUE_ON
-
+from homeassistant.components.sensor.tcp import (
+    TcpSensor, CONF_VALUE_ON, PLATFORM_SCHEMA)

 _LOGGER = logging.getLogger(__name__)

-
-def setup_platform(hass, config, add_entities, discovery_info=None):
-    """Create the binary sensor."""
-    if not BinarySensor.validate_config(config):
-        return False
-
-    add_entities((BinarySensor(hass, config),))
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({})


-class BinarySensor(BinarySensorDevice, Sensor):
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the TCP binary sensor."""
+    add_devices([TcpBinarySensor(hass, config)])
+
+
+class TcpBinarySensor(BinarySensorDevice, TcpSensor):
    """A binary sensor which is on when its state == CONF_VALUE_ON."""

    required = (CONF_VALUE_ON,)
@@ -4,10 +4,12 @@ Support for exposing a templated binary sensor.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/binary_sensor.template/
 """
+import asyncio
 import logging

 import voluptuous as vol

+from homeassistant.core import callback
 from homeassistant.components.binary_sensor import (
    BinarySensorDevice, ENTITY_ID_FORMAT, PLATFORM_SCHEMA,
    SENSOR_CLASSES_SCHEMA)
@@ -15,8 +17,8 @@ from homeassistant.const import (
    ATTR_FRIENDLY_NAME, ATTR_ENTITY_ID, CONF_VALUE_TEMPLATE,
    CONF_SENSOR_CLASS, CONF_SENSORS)
 from homeassistant.exceptions import TemplateError
-from homeassistant.helpers.entity import generate_entity_id
-from homeassistant.helpers.event import track_state_change
+from homeassistant.helpers.entity import async_generate_entity_id
+from homeassistant.helpers.event import async_track_state_change
 import homeassistant.helpers.config_validation as cv

 _LOGGER = logging.getLogger(__name__)
@@ -33,7 +35,8 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 })


-def setup_platform(hass, config, add_devices, discovery_info=None):
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
    """Setup template binary sensors."""
    sensors = []

@@ -59,8 +62,8 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    if not sensors:
        _LOGGER.error('No sensors added')
        return False
-    add_devices(sensors)

+    hass.loop.create_task(async_add_devices(sensors))
    return True


@@ -72,20 +75,22 @@ class BinarySensorTemplate(BinarySensorDevice):
                 value_template, entity_ids):
        """Initialize the Template binary sensor."""
        self.hass = hass
-        self.entity_id = generate_entity_id(ENTITY_ID_FORMAT, device,
-                                            hass=hass)
+        self.entity_id = async_generate_entity_id(ENTITY_ID_FORMAT, device,
+                                                  hass=hass)
        self._name = friendly_name
        self._sensor_class = sensor_class
        self._template = value_template
        self._state = None

-        self.update()
+        self._async_render()

+        @callback
        def template_bsensor_state_listener(entity, old_state, new_state):
            """Called when the target device changes state."""
-            self.update_ha_state(True)
+            hass.loop.create_task(self.async_update_ha_state(True))

-        track_state_change(hass, entity_ids, template_bsensor_state_listener)
+        async_track_state_change(
+            hass, entity_ids, template_bsensor_state_listener)

    @property
    def name(self):
@@ -107,10 +112,15 @@ class BinarySensorTemplate(BinarySensorDevice):
        """No polling needed."""
        return False

-    def update(self):
-        """Get the latest data and update the state."""
+    @asyncio.coroutine
+    def async_update(self):
+        """Update the state from the template."""
+        self._async_render()
+
+    def _async_render(self):
+        """Render the state from the template."""
        try:
-            self._state = self._template.render().lower() == 'true'
+            self._state = self._template.async_render().lower() == 'true'
        except TemplateError as ex:
            if ex.args and ex.args[0].startswith(
                    "UndefinedError: 'None' has no attribute"):
@@ -20,7 +20,10 @@ SENSOR_TYPES = {
    "vibration": "vibration",
    "loudness": "sound",
    "liquid_detected": "moisture",
-    "motion": "motion"
+    "motion": "motion",
+    "presence": "occupancy",
+    "co_detected": "gas",
+    "smoke_detected": "smoke"
 }


@@ -35,6 +38,9 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    for key in pywink.get_keys():
        add_devices([WinkBinarySensorDevice(key)])

+    for sensor in pywink.get_smoke_and_co_detectors():
+        add_devices([WinkBinarySensorDevice(sensor)])
+

 class WinkBinarySensorDevice(WinkDevice, BinarySensorDevice, Entity):
    """Representation of a Wink binary sensor."""
@@ -58,17 +64,25 @@ class WinkBinarySensorDevice(WinkDevice, BinarySensorDevice, Entity):
    def is_on(self):
        """Return true if the binary sensor is on."""
        if self.capability == "loudness":
-            return self.wink.loudness_boolean()
+            state = self.wink.loudness_boolean()
        elif self.capability == "vibration":
-            return self.wink.vibration_boolean()
+            state = self.wink.vibration_boolean()
        elif self.capability == "brightness":
-            return self.wink.brightness_boolean()
+            state = self.wink.brightness_boolean()
        elif self.capability == "liquid_detected":
-            return self.wink.liquid_boolean()
+            state = self.wink.liquid_boolean()
        elif self.capability == "motion":
-            return self.wink.motion_boolean()
+            state = self.wink.motion_boolean()
+        elif self.capability == "presence":
+            state = self.wink.presence_boolean()
+        elif self.capability == "co_detected":
+            state = self.wink.co_detected_boolean()
+        elif self.capability == "smoke_detected":
+            state = self.wink.smoke_detected_boolean()
        else:
-            return self.wink.state()
+            state = self.wink.state()
+
+        return state

    @property
    def sensor_class(self):
@@ -36,8 +36,8 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    if discovery_info is None or zwave.NETWORK is None:
        return

-    node = zwave.NETWORK.nodes[discovery_info[zwave.ATTR_NODE_ID]]
-    value = node.values[discovery_info[zwave.ATTR_VALUE_ID]]
+    node = zwave.NETWORK.nodes[discovery_info[zwave.const.ATTR_NODE_ID]]
+    value = node.values[discovery_info[zwave.const.ATTR_VALUE_ID]]
    value.set_change_verified(False)

    # Make sure that we have values for the key before converting to int
@@ -58,7 +58,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
                ])
                return

-    if value.command_class == zwave.COMMAND_CLASS_SENSOR_BINARY:
+    if value.command_class == zwave.const.COMMAND_CLASS_SENSOR_BINARY:
        add_devices([ZWaveBinarySensor(value, None)])


@@ -5,12 +5,11 @@ For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/camera.netatmo/
 """
 import logging
-from datetime import timedelta

 import requests
 import voluptuous as vol

-from homeassistant.util import Throttle
+from homeassistant.components.netatmo import WelcomeData
 from homeassistant.components.camera import (Camera, PLATFORM_SCHEMA)
 from homeassistant.loader import get_component
 from homeassistant.helpers import config_validation as cv
@@ -22,8 +21,6 @@ _LOGGER = logging.getLogger(__name__)
 CONF_HOME = 'home'
 CONF_CAMERAS = 'cameras'

-MIN_TIME_BETWEEN_UPDATES = timedelta(minutes=10)
-
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Optional(CONF_HOME): cv.string,
    vol.Optional(CONF_CAMERAS, default=[]):
@@ -36,20 +33,24 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    """Setup access to Netatmo Welcome cameras."""
    netatmo = get_component('netatmo')
    home = config.get(CONF_HOME)
-    data = WelcomeData(netatmo.NETATMO_AUTH, home)
-
-    for camera_name in data.get_camera_names():
-        if CONF_CAMERAS in config:
-            if camera_name not in config[CONF_CAMERAS]:
-                continue
-        add_devices([WelcomeCamera(data, camera_name, home)])
+    import lnetatmo
+    try:
+        data = WelcomeData(netatmo.NETATMO_AUTH, home)
+        for camera_name in data.get_camera_names():
+            if CONF_CAMERAS in config:
+                if config[CONF_CAMERAS] != [] and \
+                   camera_name not in config[CONF_CAMERAS]:
+                    continue
+            add_devices([WelcomeCamera(data, camera_name, home)])
+    except lnetatmo.NoDevice:
+        return None


 class WelcomeCamera(Camera):
    """Representation of the images published from Welcome camera."""

    def __init__(self, data, camera_name, home):
-        """Setup for access to the BloomSky camera images."""
+        """Setup for access to the Netatmo camera images."""
        super(WelcomeCamera, self).__init__()
        self._data = data
        self._camera_name = camera_name
@@ -57,6 +58,10 @@ class WelcomeCamera(Camera):
            self._name = home + ' / ' + camera_name
        else:
            self._name = camera_name
+        camera_id = data.welcomedata.cameraByName(camera=camera_name,
+                                                  home=home)['id']
+        self._unique_id = "Welcome_camera {0} - {1}".format(self._name,
+                                                            camera_id)
        self._vpnurl, self._localurl = self._data.welcomedata.cameraUrls(
            camera=camera_name
            )
@@ -83,31 +88,7 @@ class WelcomeCamera(Camera):
        """Return the name of this Netatmo Welcome device."""
        return self._name

-
-class WelcomeData(object):
-    """Get the latest data from NetAtmo."""
-
-    def __init__(self, auth, home=None):
-        """Initialize the data object."""
-        self.auth = auth
-        self.welcomedata = None
-        self.camera_names = []
-        self.home = home
-
-    def get_camera_names(self):
-        """Return all module available on the API as a list."""
-        self.update()
-        if not self.home:
-            for home in self.welcomedata.cameras:
-                for camera in self.welcomedata.cameras[home].values():
-                    self.camera_names.append(camera['name'])
-        else:
-            for camera in self.welcomedata.cameras[self.home].values():
-                self.camera_names.append(camera['name'])
-        return self.camera_names
-
-    @Throttle(MIN_TIME_BETWEEN_UPDATES)
-    def update(self):
-        """Call the NetAtmo API to update the data."""
-        import lnetatmo
-        self.welcomedata = lnetatmo.WelcomeData(self.auth)
+    @property
+    def unique_id(self):
+        """Return the unique ID for this sensor."""
+        return self._unique_id
@@ -0,0 +1,223 @@
+"""
+Support for Synology Surveillance Station Cameras.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/camera.synology/
+"""
+import logging
+
+import voluptuous as vol
+
+import requests
+
+from homeassistant.const import (
+    CONF_NAME, CONF_USERNAME, CONF_PASSWORD,
+    CONF_URL, CONF_WHITELIST)
+from homeassistant.components.camera import (
+    Camera, PLATFORM_SCHEMA)
+import homeassistant.helpers.config_validation as cv
+
+_LOGGER = logging.getLogger(__name__)
+
+#  pylint: disable=too-many-locals
+DEFAULT_NAME = 'Synology Camera'
+DEFAULT_STREAM_ID = '0'
+TIMEOUT = 5
+CONF_CAMERA_NAME = 'camera_name'
+CONF_STREAM_ID = 'stream_id'
+CONF_VALID_CERT = 'valid_cert'
+
+QUERY_CGI = 'query.cgi'
+QUERY_API = 'SYNO.API.Info'
+AUTH_API = 'SYNO.API.Auth'
+CAMERA_API = 'SYNO.SurveillanceStation.Camera'
+STREAMING_API = 'SYNO.SurveillanceStation.VideoStream'
+SESSION_ID = '0'
+
+WEBAPI_PATH = '/webapi/'
+AUTH_PATH = 'auth.cgi'
+CAMERA_PATH = 'camera.cgi'
+STREAMING_PATH = 'SurveillanceStation/videoStreaming.cgi'
+
+SYNO_API_URL = '{0}{1}{2}'
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Required(CONF_USERNAME): cv.string,
+    vol.Required(CONF_PASSWORD): cv.string,
+    vol.Required(CONF_URL): cv.string,
+    vol.Optional(CONF_WHITELIST, default=[]): cv.ensure_list,
+    vol.Optional(CONF_VALID_CERT, default=True): cv.boolean,
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup a Synology IP Camera."""
+    # Determine API to use for authentication
+    syno_api_url = SYNO_API_URL.format(config.get(CONF_URL),
+                                       WEBAPI_PATH,
+                                       QUERY_CGI)
+    query_payload = {'api': QUERY_API,
+                     'method': 'Query',
+                     'version': '1',
+                     'query': 'SYNO.'}
+    query_req = requests.get(syno_api_url,
+                             params=query_payload,
+                             verify=config.get(CONF_VALID_CERT),
+                             timeout=TIMEOUT)
+    query_resp = query_req.json()
+    auth_path = query_resp['data'][AUTH_API]['path']
+    camera_api = query_resp['data'][CAMERA_API]['path']
+    camera_path = query_resp['data'][CAMERA_API]['path']
+    streaming_path = query_resp['data'][STREAMING_API]['path']
+
+    # Authticate to NAS to get a session id
+    syno_auth_url = SYNO_API_URL.format(config.get(CONF_URL),
+                                        WEBAPI_PATH,
+                                        auth_path)
+    session_id = get_session_id(config.get(CONF_USERNAME),
+                                config.get(CONF_PASSWORD),
+                                syno_auth_url,
+                                config.get(CONF_VALID_CERT))
+
+    # Use SessionID to get cameras in system
+    syno_camera_url = SYNO_API_URL.format(config.get(CONF_URL),
+                                          WEBAPI_PATH,
+                                          camera_api)
+    camera_payload = {'api': CAMERA_API,
+                      'method': 'List',
+                      'version': '1'}
+    camera_req = requests.get(syno_camera_url,
+                              params=camera_payload,
+                              verify=config.get(CONF_VALID_CERT),
+                              timeout=TIMEOUT,
+                              cookies={'id': session_id})
+    camera_resp = camera_req.json()
+    cameras = camera_resp['data']['cameras']
+    for camera in cameras:
+        if not config.get(CONF_WHITELIST):
+            camera_id = camera['id']
+            snapshot_path = camera['snapshot_path']
+
+            add_devices([SynologyCamera(config,
+                                        camera_id,
+                                        camera['name'],
+                                        snapshot_path,
+                                        streaming_path,
+                                        camera_path,
+                                        auth_path)])
+
+
+def get_session_id(username, password, login_url, valid_cert):
+    """Get a session id."""
+    auth_payload = {'api': AUTH_API,
+                    'method': 'Login',
+                    'version': '2',
+                    'account': username,
+                    'passwd': password,
+                    'session': 'SurveillanceStation',
+                    'format': 'sid'}
+    auth_req = requests.get(login_url,
+                            params=auth_payload,
+                            verify=valid_cert,
+                            timeout=TIMEOUT)
+    auth_resp = auth_req.json()
+    return auth_resp['data']['sid']
+
+
+# pylint: disable=too-many-instance-attributes
+class SynologyCamera(Camera):
+    """An implementation of a Synology NAS based IP camera."""
+
+# pylint: disable=too-many-arguments
+    def __init__(self, config, camera_id, camera_name,
+                 snapshot_path, streaming_path, camera_path, auth_path):
+        """Initialize a Synology Surveillance Station camera."""
+        super().__init__()
+        self._name = camera_name
+        self._username = config.get(CONF_USERNAME)
+        self._password = config.get(CONF_PASSWORD)
+        self._synology_url = config.get(CONF_URL)
+        self._api_url = config.get(CONF_URL) + 'webapi/'
+        self._login_url = config.get(CONF_URL) + '/webapi/' + 'auth.cgi'
+        self._camera_name = config.get(CONF_CAMERA_NAME)
+        self._stream_id = config.get(CONF_STREAM_ID)
+        self._valid_cert = config.get(CONF_VALID_CERT)
+        self._camera_id = camera_id
+        self._snapshot_path = snapshot_path
+        self._streaming_path = streaming_path
+        self._camera_path = camera_path
+        self._auth_path = auth_path
+
+        self._session_id = get_session_id(self._username,
+                                          self._password,
+                                          self._login_url,
+                                          self._valid_cert)
+
+    def get_sid(self):
+        """Get a session id."""
+        auth_payload = {'api': AUTH_API,
+                        'method': 'Login',
+                        'version': '2',
+                        'account': self._username,
+                        'passwd': self._password,
+                        'session': 'SurveillanceStation',
+                        'format': 'sid'}
+        auth_req = requests.get(self._login_url,
+                                params=auth_payload,
+                                verify=self._valid_cert,
+                                timeout=TIMEOUT)
+        auth_resp = auth_req.json()
+        self._session_id = auth_resp['data']['sid']
+
+    def camera_image(self):
+        """Return a still image response from the camera."""
+        image_url = SYNO_API_URL.format(self._synology_url,
+                                        WEBAPI_PATH,
+                                        self._camera_path)
+        image_payload = {'api': CAMERA_API,
+                         'method': 'GetSnapshot',
+                         'version': '1',
+                         'cameraId': self._camera_id}
+        try:
+            response = requests.get(image_url,
+                                    params=image_payload,
+                                    timeout=TIMEOUT,
+                                    verify=self._valid_cert,
+                                    cookies={'id': self._session_id})
+        except requests.exceptions.RequestException as error:
+            _LOGGER.error('Error getting camera image: %s', error)
+            return None
+
+        return response.content
+
+    def camera_stream(self):
+        """Return a MJPEG stream image response directly from the camera."""
+        streaming_url = SYNO_API_URL.format(self._synology_url,
+                                            WEBAPI_PATH,
+                                            self._streaming_path)
+        streaming_payload = {'api': STREAMING_API,
+                             'method': 'Stream',
+                             'version': '1',
+                             'cameraId': self._camera_id,
+                             'format': 'mjpeg'}
+        response = requests.get(streaming_url,
+                                payload=streaming_payload,
+                                stream=True,
+                                timeout=TIMEOUT,
+                                cookies={'id': self._session_id})
+        return response
+
+    def mjpeg_steam(self, response):
+        """Generate an HTTP MJPEG Stream from the Synology NAS."""
+        stream = self.camera_stream()
+        return response(
+            stream.iter_content(chunk_size=1024),
+            mimetype=stream.headers['CONTENT_TYPE_HEADER'],
+            direct_passthrough=True
+        )
+
+    @property
+    def name(self):
+        """Return the name of this device."""
+        return self._name
@@ -0,0 +1,103 @@
+"""
+Camera that loads a picture from a local file.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/camera.verisure/
+"""
+import errno
+import logging
+import os
+
+from homeassistant.components.camera import Camera
+from homeassistant.const import EVENT_HOMEASSISTANT_STOP
+from homeassistant.components.verisure import HUB as hub
+from homeassistant.components.verisure import CONF_SMARTCAM
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup the Camera."""
+    if not int(hub.config.get(CONF_SMARTCAM, 1)):
+        return False
+    directory_path = hass.config.config_dir
+    if not os.access(directory_path, os.R_OK):
+        _LOGGER.error("file path %s is not readable", directory_path)
+        return False
+    hub.update_smartcam()
+    smartcams = []
+    smartcams.extend([
+        VerisureSmartcam(hass, value.deviceLabel, directory_path)
+        for value in hub.smartcam_status.values()])
+    add_devices(smartcams)
+
+
+class VerisureSmartcam(Camera):
+    """Local camera."""
+
+    def __init__(self, hass, device_id, directory_path):
+        """Initialize Verisure File Camera component."""
+        super().__init__()
+
+        self._device_id = device_id
+        self._directory_path = directory_path
+        self._image = None
+        self._image_id = None
+        hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP,
+                             self.delete_image)
+
+    def camera_image(self):
+        """Return image response."""
+        self.check_imagelist()
+        if not self._image:
+            _LOGGER.debug('No image to display')
+            return
+        _LOGGER.debug('Trying to open %s', self._image)
+        with open(self._image, 'rb') as file:
+            return file.read()
+
+    def check_imagelist(self):
+        """Check the contents of the image list."""
+        hub.update_smartcam_imagelist()
+        if (self._device_id not in hub.smartcam_dict or
+                not hub.smartcam_dict[self._device_id]):
+            return
+        images = hub.smartcam_dict[self._device_id]
+        new_image_id = images[0]
+        _LOGGER.debug('self._device_id=%s, self._images=%s, '
+                      'self._new_image_id=%s', self._device_id,
+                      images, new_image_id)
+        if (new_image_id == '-1' or
+                self._image_id == new_image_id):
+            _LOGGER.debug('The image is the same, or loading image_id')
+            return
+        _LOGGER.debug('Download new image %s', new_image_id)
+        hub.my_pages.smartcam.download_image(self._device_id,
+                                             new_image_id,
+                                             self._directory_path)
+        _LOGGER.debug('Old image_id=%s', self._image_id)
+        self.delete_image(self)
+
+        self._image_id = new_image_id
+        self._image = os.path.join(self._directory_path,
+                                   '{}{}'.format(
+                                       self._image_id,
+                                       '.jpg'))
+
+    def delete_image(self, event):
+        """Delete an old image."""
+        remove_image = os.path.join(self._directory_path,
+                                    '{}{}'.format(
+                                        self._image_id,
+                                        '.jpg'))
+        try:
+            os.remove(remove_image)
+            _LOGGER.debug('Deleting old image %s', remove_image)
+        except OSError as error:
+            if error.errno != errno.ENOENT:
+                raise
+
+    @property
+    def name(self):
+        """Return the name of this camera."""
+        return hub.smartcam_status[self._device_id].location
@@ -58,6 +58,12 @@ ATTR_OPERATION_LIST = "operation_list"
 ATTR_SWING_MODE = "swing_mode"
 ATTR_SWING_LIST = "swing_list"

+CONVERTIBLE_ATTRIBUTE = [
+    ATTR_TEMPERATURE,
+    ATTR_TARGET_TEMP_LOW,
+    ATTR_TARGET_TEMP_HIGH,
+]
+
 _LOGGER = logging.getLogger(__name__)

 SET_AWAY_MODE_SCHEMA = vol.Schema({
@@ -73,6 +79,7 @@ SET_TEMPERATURE_SCHEMA = vol.Schema({
    vol.Inclusive(ATTR_TARGET_TEMP_HIGH, 'temperature'): vol.Coerce(float),
    vol.Inclusive(ATTR_TARGET_TEMP_LOW, 'temperature'): vol.Coerce(float),
    vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
+    vol.Optional(ATTR_OPERATION_MODE): cv.string,
 })
 SET_FAN_MODE_SCHEMA = vol.Schema({
    vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
@@ -116,8 +123,10 @@ def set_aux_heat(hass, aux_heat, entity_id=None):
    hass.services.call(DOMAIN, SERVICE_SET_AUX_HEAT, data)


+# pylint: disable=too-many-arguments
 def set_temperature(hass, temperature=None, entity_id=None,
-                    target_temp_high=None, target_temp_low=None):
+                    target_temp_high=None, target_temp_low=None,
+                    operation_mode=None):
    """Set new target temperature."""
    kwargs = {
        key: value for key, value in [
@@ -125,6 +134,7 @@ def set_temperature(hass, temperature=None, entity_id=None,
            (ATTR_TARGET_TEMP_HIGH, target_temp_high),
            (ATTR_TARGET_TEMP_LOW, target_temp_low),
            (ATTR_ENTITY_ID, entity_id),
+            (ATTR_OPERATION_MODE, operation_mode)
        ] if value is not None
    }
    _LOGGER.debug("set_temperature start data=%s", kwargs)
@@ -235,10 +245,20 @@ def setup(hass, config):
    def temperature_set_service(service):
        """Set temperature on the target climate devices."""
        target_climate = component.extract_from_service(service)
-        kwargs = service.data
-        for climate in target_climate:
-            climate.set_temperature(**kwargs)

+        for climate in target_climate:
+            kwargs = {}
+            for value, temp in service.data.items():
+                if value in CONVERTIBLE_ATTRIBUTE:
+                    kwargs[value] = convert_temperature(
+                        temp,
+                        hass.config.units.temperature_unit,
+                        climate.temperature_unit
+                    )
+                else:
+                    kwargs[value] = temp
+
+            climate.set_temperature(**kwargs)
            if climate.should_poll:
                climate.update_ha_state(True)

@@ -348,7 +368,10 @@ class ClimateDevice(Entity):
    @property
    def state(self):
        """Return the current state."""
-        return self.current_operation or STATE_UNKNOWN
+        if self.current_operation:
+            return self.current_operation
+        else:
+            return STATE_UNKNOWN

    @property
    def state_attributes(self):
@@ -378,17 +401,20 @@ class ClimateDevice(Entity):
        fan_mode = self.current_fan_mode
        if fan_mode is not None:
            data[ATTR_FAN_MODE] = fan_mode
-            data[ATTR_FAN_LIST] = self.fan_list
+            if self.fan_list:
+                data[ATTR_FAN_LIST] = self.fan_list

        operation_mode = self.current_operation
        if operation_mode is not None:
            data[ATTR_OPERATION_MODE] = operation_mode
-            data[ATTR_OPERATION_LIST] = self.operation_list
+            if self.operation_list:
+                data[ATTR_OPERATION_LIST] = self.operation_list

        swing_mode = self.current_swing_mode
        if swing_mode is not None:
            data[ATTR_SWING_MODE] = swing_mode
-            data[ATTR_SWING_LIST] = self.swing_list
+            if self.swing_list:
+                data[ATTR_SWING_LIST] = self.swing_list

        is_away = self.is_away_mode_on
        if is_away is not None:
@@ -402,7 +428,12 @@ class ClimateDevice(Entity):

    @property
    def unit_of_measurement(self):
-        """Return the unit of measurement."""
+        """The unit of measurement to display."""
+        return self.hass.config.units.temperature_unit
+
+    @property
+    def temperature_unit(self):
+        """The unit of measurement used by the platform."""
        raise NotImplementedError

    @property
@@ -514,12 +545,12 @@ class ClimateDevice(Entity):
    @property
    def min_temp(self):
        """Return the minimum temperature."""
-        return convert_temperature(7, TEMP_CELSIUS, self.unit_of_measurement)
+        return convert_temperature(7, TEMP_CELSIUS, self.temperature_unit)

    @property
    def max_temp(self):
        """Return the maximum temperature."""
-        return convert_temperature(35, TEMP_CELSIUS, self.unit_of_measurement)
+        return convert_temperature(35, TEMP_CELSIUS, self.temperature_unit)

    @property
    def min_humidity(self):
@@ -536,10 +567,10 @@ class ClimateDevice(Entity):
        if temp is None or not isinstance(temp, Number):
            return temp

-        value = convert_temperature(temp, self.unit_of_measurement,
-                                    self.hass.config.units.temperature_unit)
+        value = convert_temperature(temp, self.temperature_unit,
+                                    self.unit_of_measurement)

-        if self.hass.config.units.temperature_unit is TEMP_CELSIUS:
+        if self.unit_of_measurement is TEMP_CELSIUS:
            decimal_count = 1
        else:
            # Users of fahrenheit generally expect integer units.
@@ -59,7 +59,7 @@ class DemoClimate(ClimateDevice):
        return self._name

    @property
-    def unit_of_measurement(self):
+    def temperature_unit(self):
        """Return the unit of measurement."""
        return self._unit_of_measurement

@@ -14,7 +14,7 @@ from homeassistant.components.climate import (
    DOMAIN, STATE_COOL, STATE_HEAT, STATE_IDLE, ClimateDevice,
    ATTR_TARGET_TEMP_LOW, ATTR_TARGET_TEMP_HIGH)
 from homeassistant.const import (
-    ATTR_ENTITY_ID, STATE_OFF, STATE_ON, TEMP_FAHRENHEIT, TEMP_CELSIUS)
+    ATTR_ENTITY_ID, STATE_OFF, STATE_ON, TEMP_FAHRENHEIT)
 from homeassistant.config import load_yaml_config_file
 import homeassistant.helpers.config_validation as cv

@@ -105,12 +105,9 @@ class Thermostat(ClimateDevice):
        return self.thermostat['name']

    @property
-    def unit_of_measurement(self):
+    def temperature_unit(self):
        """Return the unit of measurement."""
-        if self.thermostat['settings']['useCelsius']:
-            return TEMP_CELSIUS
-        else:
-            return TEMP_FAHRENHEIT
+        return TEMP_FAHRENHEIT

    @property
    def current_temperature(self):
@@ -1,24 +1,38 @@
 """
-Support for eq3 Bluetooth Smart thermostats.
+Support for eQ-3 Bluetooth Smart thermostats.

 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/climate.eq3btsmart/
 """
 import logging

-from homeassistant.components.climate import ClimateDevice
-from homeassistant.const import TEMP_CELSIUS, CONF_DEVICES, ATTR_TEMPERATURE
+import voluptuous as vol
+
+from homeassistant.components.climate import ClimateDevice, PLATFORM_SCHEMA
+from homeassistant.const import (
+    CONF_MAC, TEMP_CELSIUS, CONF_DEVICES, ATTR_TEMPERATURE)
 from homeassistant.util.temperature import convert
+import homeassistant.helpers.config_validation as cv

 REQUIREMENTS = ['bluepy_devices==0.2.0']

-CONF_MAC = 'mac'
-
 _LOGGER = logging.getLogger(__name__)

+ATTR_MODE = 'mode'
+ATTR_MODE_READABLE = 'mode_readable'
+
+DEVICE_SCHEMA = vol.Schema({
+    vol.Required(CONF_MAC): cv.string,
+})
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_DEVICES):
+        vol.Schema({cv.string: DEVICE_SCHEMA}),
+})
+

 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the eq3 BLE thermostats."""
+    """Setup the eQ-3 BLE thermostats."""
    devices = []

    for name, device_cfg in config[CONF_DEVICES].items():
@@ -30,14 +44,13 @@ def setup_platform(hass, config, add_devices, discovery_info=None):

 # pylint: disable=too-many-instance-attributes, import-error, abstract-method
 class EQ3BTSmartThermostat(ClimateDevice):
-    """Representation of a EQ3 Bluetooth Smart thermostat."""
+    """Representation of a eQ-3 Bluetooth Smart thermostat."""

    def __init__(self, _mac, _name):
        """Initialize the thermostat."""
        from bluepy_devices.devices import eq3btsmart

        self._name = _name
-
        self._thermostat = eq3btsmart.EQ3BTSmartThermostat(_mac)

    @property
@@ -46,7 +59,7 @@ class EQ3BTSmartThermostat(ClimateDevice):
        return self._name

    @property
-    def unit_of_measurement(self):
+    def temperature_unit(self):
        """Return the unit of measurement that is used."""
        return TEMP_CELSIUS

@@ -70,8 +83,10 @@ class EQ3BTSmartThermostat(ClimateDevice):
    @property
    def device_state_attributes(self):
        """Return the device specific state attributes."""
-        return {"mode": self._thermostat.mode,
-                "mode_readable": self._thermostat.mode_readable}
+        return {
+            ATTR_MODE: self._thermostat.mode,
+            ATTR_MODE_READABLE: self._thermostat.mode_readable,
+        }

    @property
    def min_temp(self):
@@ -100,7 +100,7 @@ class GenericThermostat(ClimateDevice):
        return self._name

    @property
-    def unit_of_measurement(self):
+    def temperature_unit(self):
        """Return the unit of measurement."""
        return self._unit

@@ -1,56 +1,54 @@
 """
 Support for the PRT Heatmiser themostats using the V3 protocol.

-See https://github.com/andylockran/heatmiserV3 for more info on the
-heatmiserV3 module dependency.
-
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/climate.heatmiser/
 """
 import logging

-from homeassistant.components.climate import ClimateDevice
-from homeassistant.const import TEMP_CELSIUS, ATTR_TEMPERATURE
+import voluptuous as vol

-CONF_IPADDRESS = 'ipaddress'
-CONF_PORT = 'port'
-CONF_TSTATS = 'tstats'
+from homeassistant.components.climate import ClimateDevice, PLATFORM_SCHEMA
+from homeassistant.const import (
+    TEMP_CELSIUS, ATTR_TEMPERATURE, CONF_PORT, CONF_NAME, CONF_ID)
+import homeassistant.helpers.config_validation as cv

-REQUIREMENTS = ["heatmiserV3==0.9.1"]
+REQUIREMENTS = ['heatmiserV3==0.9.1']

 _LOGGER = logging.getLogger(__name__)

+CONF_IPADDRESS = 'ipaddress'
+CONF_TSTATS = 'tstats'

+TSTATS_SCHEMA = vol.Schema({
+    vol.Required(CONF_ID): cv.string,
+    vol.Required(CONF_NAME): cv.string,
+})
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_IPADDRESS): cv.string,
+    vol.Required(CONF_PORT): cv.port,
+    vol.Required(CONF_TSTATS, default={}):
+        vol.Schema({cv.string: TSTATS_SCHEMA}),
+})
+
+
+# pylint: disable=unused-variable
 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Setup the heatmiser thermostat."""
    from heatmiserV3 import heatmiser, connection

-    ipaddress = str(config[CONF_IPADDRESS])
-    port = str(config[CONF_PORT])
-
-    if ipaddress is None or port is None:
-        _LOGGER.error("Missing required configuration items %s or %s",
-                      CONF_IPADDRESS, CONF_PORT)
-        return False
+    ipaddress = config.get(CONF_IPADDRESS)
+    port = str(config.get(CONF_PORT))
+    tstats = config.get(CONF_TSTATS)

    serport = connection.connection(ipaddress, port)
    serport.open()

-    tstats = []
-    if CONF_TSTATS in config:
-        tstats = config[CONF_TSTATS]
-
-    if tstats is None:
-        _LOGGER.error("No thermostats configured.")
-        return False
-
-    for tstat in tstats:
+    for thermostat, tstat in tstats.items():
        add_devices([
            HeatmiserV3Thermostat(
-                heatmiser,
-                tstat.get("id"),
-                tstat.get("name"),
-                serport)
+                heatmiser, tstat.get(CONF_ID), tstat.get(CONF_NAME), serport)
            ])
    return

@@ -69,7 +67,7 @@ class HeatmiserV3Thermostat(ClimateDevice):
        self._id = device
        self.dcb = None
        self.update()
-        self._target_temperature = int(self.dcb.get("roomset"))
+        self._target_temperature = int(self.dcb.get('roomset'))

    @property
    def name(self):
@@ -77,7 +75,7 @@ class HeatmiserV3Thermostat(ClimateDevice):
        return self._name

    @property
-    def unit_of_measurement(self):
+    def temperature_unit(self):
        """Return the unit of measurement which this thermostat uses."""
        return TEMP_CELSIUS

@@ -85,9 +83,9 @@ class HeatmiserV3Thermostat(ClimateDevice):
    def current_temperature(self):
        """Return the current temperature."""
        if self.dcb is not None:
-            low = self.dcb.get("floortemplow ")
-            high = self.dcb.get("floortemphigh")
-            temp = (high*256 + low)/10.0
+            low = self.dcb.get('floortemplow ')
+            high = self.dcb.get('floortemphigh')
+            temp = (high * 256 + low) / 10.0
            self._current_temperature = temp
        else:
            self._current_temperature = None
@@ -41,7 +41,7 @@ class HMThermostat(homematic.HMDevice, ClimateDevice):
    """Representation of a Homematic thermostat."""

    @property
-    def unit_of_measurement(self):
+    def temperature_unit(self):
        """Return the unit of measurement that is used."""
        return TEMP_CELSIUS

@@ -120,7 +120,7 @@ class RoundThermostat(ClimateDevice):
        return self._name

    @property
-    def unit_of_measurement(self):
+    def temperature_unit(self):
        """Return the unit of measurement."""
        return TEMP_CELSIUS

@@ -217,7 +217,7 @@ class HoneywellUSThermostat(ClimateDevice):
        return self._device.name

    @property
-    def unit_of_measurement(self):
+    def temperature_unit(self):
        """Return the unit of measurement."""
        return (TEMP_CELSIUS if self._device.temperature_unit == 'C'
                else TEMP_FAHRENHEIT)
@@ -63,7 +63,7 @@ class KNXThermostat(KNXMultiAddressDevice, ClimateDevice):
        return True

    @property
-    def unit_of_measurement(self):
+    def temperature_unit(self):
        """Return the unit of measurement."""
        return self._unit_of_measurement

@@ -47,7 +47,7 @@ class MySensorsHVAC(mysensors.MySensorsDeviceEntity, ClimateDevice):
        return self.gateway.optimistic

    @property
-    def unit_of_measurement(self):
+    def temperature_unit(self):
        """Return the unit of measurement."""
        return (TEMP_CELSIUS
                if self.gateway.metric else TEMP_FAHRENHEIT)
@@ -8,11 +8,11 @@ import logging
 import voluptuous as vol
 import homeassistant.components.nest as nest
 from homeassistant.components.climate import (
-    STATE_AUTO, STATE_COOL, STATE_HEAT, STATE_IDLE, ClimateDevice,
-    PLATFORM_SCHEMA, ATTR_TARGET_TEMP_HIGH, ATTR_TARGET_TEMP_LOW)
+    STATE_AUTO, STATE_COOL, STATE_HEAT, ClimateDevice,
+    PLATFORM_SCHEMA, ATTR_TARGET_TEMP_HIGH, ATTR_TARGET_TEMP_LOW,
+    ATTR_TEMPERATURE)
 from homeassistant.const import (
-    TEMP_CELSIUS, CONF_SCAN_INTERVAL, STATE_ON, TEMP_FAHRENHEIT)
-from homeassistant.util.temperature import convert as convert_temperature
+    TEMP_CELSIUS, CONF_SCAN_INTERVAL, STATE_ON, STATE_OFF, STATE_UNKNOWN)

 DEPENDENCIES = ['nest']
 _LOGGER = logging.getLogger(__name__)
@@ -30,7 +30,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
                 for structure, device in nest.devices()])


-# pylint: disable=abstract-method
+# pylint: disable=abstract-method,too-many-public-methods
 class NestThermostat(ClimateDevice):
    """Representation of a Nest thermostat."""

@@ -41,6 +41,19 @@ class NestThermostat(ClimateDevice):
        self.device = device
        self._fan_list = [STATE_ON, STATE_AUTO]

+        # Not all nest devices support cooling and heating remove unused
+        self._operation_list = [STATE_OFF]
+
+        # Add supported nest thermostat features
+        if self.device.can_heat:
+            self._operation_list.append(STATE_HEAT)
+
+        if self.device.can_cool:
+            self._operation_list.append(STATE_COOL)
+
+        if self.device.can_heat and self.device.can_cool:
+            self._operation_list.append(STATE_AUTO)
+
    @property
    def name(self):
        """Return the name of the nest, if any."""
@@ -55,22 +68,22 @@ class NestThermostat(ClimateDevice):
                return location.capitalize() + '(' + name + ')'

    @property
-    def unit_of_measurement(self):
+    def temperature_unit(self):
        """Return the unit of measurement."""
-        if self.device.measurment_scale == 'F':
-            return TEMP_FAHRENHEIT
-        elif self.device.measurement_scale == 'C':
-            return TEMP_CELSIUS
+        return TEMP_CELSIUS

    @property
    def device_state_attributes(self):
        """Return the device specific state attributes."""
-        # Move these to Thermostat Device and make them global
-        return {
-            "humidity": self.device.humidity,
-            "target_humidity": self.device.target_humidity,
-            "mode": self.device.mode
-        }
+        if self.device.has_humidifier or self.device.has_dehumidifier:
+            # Move these to Thermostat Device and make them global
+            return {
+                "humidity": self.device.humidity,
+                "target_humidity": self.device.target_humidity,
+            }
+        else:
+            # No way to control humidity not show setting
+            return {}

    @property
    def current_temperature(self):
@@ -78,14 +91,26 @@ class NestThermostat(ClimateDevice):
        return self.device.temperature

    @property
-    def operation(self):
+    def current_operation(self):
        """Return current operation ie. heat, cool, idle."""
-        if self.device.hvac_ac_state is True:
+        if self.device.mode == 'cool':
            return STATE_COOL
-        elif self.device.hvac_heater_state is True:
+        elif self.device.mode == 'heat':
            return STATE_HEAT
+        elif self.device.mode == 'range':
+            return STATE_AUTO
+        elif self.device.mode == 'off':
+            return STATE_OFF
        else:
-            return STATE_IDLE
+            return STATE_UNKNOWN
+
+    @property
+    def target_temperature(self):
+        """Return the temperature we try to reach."""
+        if self.device.mode != 'range' and not self.is_away_mode_on:
+            return self.device.target
+        else:
+            return None

    @property
    def target_temperature_low(self):
@@ -95,7 +120,8 @@ class NestThermostat(ClimateDevice):
            return self.device.away_temperature[0]
        if self.device.mode == 'range':
            return self.device.target[0]
-        return self.target_temperature
+        else:
+            return None

    @property
    def target_temperature_high(self):
@@ -105,7 +131,8 @@ class NestThermostat(ClimateDevice):
            return self.device.away_temperature[1]
        if self.device.mode == 'range':
            return self.device.target[1]
-        return self.target_temperature
+        else:
+            return None

    @property
    def is_away_mode_on(self):
@@ -114,20 +141,32 @@ class NestThermostat(ClimateDevice):

    def set_temperature(self, **kwargs):
        """Set new target temperature."""
-        if kwargs.get(ATTR_TARGET_TEMP_LOW) is not None and \
-           kwargs.get(ATTR_TARGET_TEMP_HIGH) is not None:
-            target_temp_high = convert_temperature(kwargs.get(
-                ATTR_TARGET_TEMP_HIGH), self._unit, TEMP_CELSIUS)
-            target_temp_low = convert_temperature(kwargs.get(
-                ATTR_TARGET_TEMP_LOW), self._unit, TEMP_CELSIUS)
+        target_temp_low = kwargs.get(ATTR_TARGET_TEMP_LOW)
+        target_temp_high = kwargs.get(ATTR_TARGET_TEMP_HIGH)
+        if target_temp_low is not None and target_temp_high is not None:

-        temp = (target_temp_low, target_temp_high)
+            if self.device.mode == 'range':
+                temp = (target_temp_low, target_temp_high)
+        else:
+            temp = kwargs.get(ATTR_TEMPERATURE)
        _LOGGER.debug("Nest set_temperature-output-value=%s", temp)
        self.device.target = temp

    def set_operation_mode(self, operation_mode):
        """Set operation mode."""
-        self.device.mode = operation_mode
+        if operation_mode == STATE_HEAT:
+            self.device.mode = 'heat'
+        elif operation_mode == STATE_COOL:
+            self.device.mode = 'cool'
+        elif operation_mode == STATE_AUTO:
+            self.device.mode = 'range'
+        elif operation_mode == STATE_OFF:
+            self.device.mode = 'off'
+
+    @property
+    def operation_list(self):
+        """List of available operation modes."""
+        return self._operation_list

    def turn_away_mode_on(self):
        """Turn away on."""
@@ -140,7 +179,12 @@ class NestThermostat(ClimateDevice):
    @property
    def current_fan_mode(self):
        """Return whether the fan is on."""
-        return STATE_ON if self.device.fan else STATE_AUTO
+        if self.device.has_fan:
+            # Return whether the fan is on
+            return STATE_ON if self.device.fan else STATE_AUTO
+        else:
+            # No Fan available so disable slider
+            return None

    @property
    def fan_list(self):
@@ -0,0 +1,178 @@
+"""
+Support for Netatmo Smart Thermostat.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/climate.netatmo/
+"""
+import logging
+from datetime import timedelta
+import voluptuous as vol
+
+from homeassistant.const import TEMP_CELSIUS, ATTR_TEMPERATURE
+from homeassistant.components.climate import (
+    STATE_HEAT, STATE_IDLE, ClimateDevice, PLATFORM_SCHEMA)
+from homeassistant.util import Throttle
+from homeassistant.loader import get_component
+import homeassistant.helpers.config_validation as cv
+
+DEPENDENCIES = ['netatmo']
+
+_LOGGER = logging.getLogger(__name__)
+
+CONF_RELAY = 'relay'
+CONF_THERMOSTAT = 'thermostat'
+
+DEFAULT_AWAY_TEMPERATURE = 14
+# # The default offeset is 2 hours (when you use the thermostat itself)
+DEFAULT_TIME_OFFSET = 7200
+# # Return cached results if last scan was less then this time ago
+# # NetAtmo Data is uploaded to server every hour
+MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=300)
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_RELAY): cv.string,
+    vol.Optional(CONF_THERMOSTAT, default=[]):
+        vol.All(cv.ensure_list, [cv.string]),
+})
+
+
+def setup_platform(hass, config, add_callback_devices, discovery_info=None):
+    """Setup the NetAtmo Thermostat."""
+    netatmo = get_component('netatmo')
+    device = config.get(CONF_RELAY)
+
+    import lnetatmo
+    try:
+        data = ThermostatData(netatmo.NETATMO_AUTH, device)
+        for module_name in data.get_module_names():
+            if CONF_THERMOSTAT in config:
+                if config[CONF_THERMOSTAT] != [] and \
+                   module_name not in config[CONF_THERMOSTAT]:
+                    continue
+            add_callback_devices([NetatmoThermostat(data, module_name)])
+    except lnetatmo.NoDevice:
+        return None
+
+
+# pylint: disable=abstract-method
+class NetatmoThermostat(ClimateDevice):
+    """Representation a Netatmo thermostat."""
+
+    def __init__(self, data, module_name, away_temp=None):
+        """Initialize the sensor."""
+        self._data = data
+        self._state = None
+        self._name = module_name
+        self._target_temperature = None
+        self._away = None
+        self.update()
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._name
+
+    @property
+    def state(self):
+        """Return the state of the device."""
+        return self._target_temperature
+
+    @property
+    def temperature_unit(self):
+        """Return the unit of measurement."""
+        return TEMP_CELSIUS
+
+    @property
+    def current_temperature(self):
+        """Return the current temperature."""
+        return self._data.current_temperature
+
+    @property
+    def target_temperature(self):
+        """Return the temperature we try to reach."""
+        return self._target_temperature
+
+    @property
+    def current_operation(self):
+        """Return the current state of the thermostat."""
+        state = self._data.thermostatdata.relay_cmd
+        if state == 0:
+            return STATE_IDLE
+        elif state == 100:
+            return STATE_HEAT
+
+    @property
+    def is_away_mode_on(self):
+        """Return true if away mode is on."""
+        return self._away
+
+    def turn_away_mode_on(self):
+        """Turn away on."""
+        mode = "away"
+        temp = None
+        self._data.thermostatdata.setthermpoint(mode, temp, endTimeOffset=None)
+        self._away = True
+        self.update_ha_state()
+
+    def turn_away_mode_off(self):
+        """Turn away off."""
+        mode = "program"
+        temp = None
+        self._data.thermostatdata.setthermpoint(mode, temp, endTimeOffset=None)
+        self._away = False
+        self.update_ha_state()
+
+    def set_temperature(self, endTimeOffset=DEFAULT_TIME_OFFSET, **kwargs):
+        """Set new target temperature for 2 hours."""
+        temperature = kwargs.get(ATTR_TEMPERATURE)
+        if temperature is None:
+            return
+        mode = "manual"
+        self._data.thermostatdata.setthermpoint(
+            mode, temperature, endTimeOffset)
+        self._target_temperature = temperature
+        self._away = False
+        self.update_ha_state()
+
+    @Throttle(MIN_TIME_BETWEEN_UPDATES)
+    def update(self):
+        """Get the latest data from NetAtmo API and updates the states."""
+        self._data.update()
+        self._target_temperature = self._data.thermostatdata.setpoint_temp
+        self._away = self._data.setpoint_mode == 'away'
+
+
+class ThermostatData(object):
+    """Get the latest data from Netatmo."""
+
+    def __init__(self, auth, device=None):
+        """Initialize the data object."""
+        self.auth = auth
+        self.thermostatdata = None
+        self.module_names = []
+        self.device = device
+        self.current_temperature = None
+        self.target_temperature = None
+        self.setpoint_mode = None
+        # self.operation =
+
+    def get_module_names(self):
+        """Return all module available on the API as a list."""
+        self.update()
+        if not self.device:
+            for device in self.thermostatdata.modules:
+                for module in self.thermostatdata.modules[device].values():
+                    self.module_names.append(module['module_name'])
+        else:
+            for module in self.thermostatdata.modules[self.device].values():
+                self.module_names.append(module['module_name'])
+        return self.module_names
+
+    @Throttle(MIN_TIME_BETWEEN_UPDATES)
+    def update(self):
+        """Call the NetAtmo API to update the data."""
+        import lnetatmo
+        self.thermostatdata = lnetatmo.ThermostatData(self.auth)
+        self.target_temperature = self.thermostatdata.setpoint_temp
+        self.setpoint_mode = self.thermostatdata.setpoint_mode
+        self.current_temperature = self.thermostatdata.temp
@@ -12,7 +12,7 @@ from homeassistant.const import (
    CONF_HOST, CONF_PASSWORD, CONF_USERNAME, TEMP_FAHRENHEIT, ATTR_TEMPERATURE)
 import homeassistant.helpers.config_validation as cv

-REQUIREMENTS = ['proliphix==0.3.1']
+REQUIREMENTS = ['proliphix==0.4.0']

 ATTR_FAN = 'fan'

@@ -69,7 +69,7 @@ class ProliphixThermostat(ClimateDevice):
        }

    @property
-    def unit_of_measurement(self):
+    def temperature_unit(self):
        """Return the unit of measurement."""
        return TEMP_FAHRENHEIT

@@ -81,7 +81,7 @@ class RadioThermostat(ClimateDevice):
        return self._name

    @property
-    def unit_of_measurement(self):
+    def temperature_unit(self):
        """Return the unit of measurement."""
        return TEMP_FAHRENHEIT

@@ -34,6 +34,18 @@ set_temperature:
      description: New target temperature for hvac
      example: 25

+    target_temp_high:
+      description: New target high tempereature for hvac
+      example: 26
+ 
+    target_temp_low:
+      description: New target low temperature for hvac
+      example: 20
+
+    operation_mode:
+      description: Operation mode to set temperature to. This defaults to current_operation mode if not set, or set incorrectly.
+      example: 'Heat'
+
 set_humidity:
  description: Set target humidity of climate device

@@ -93,7 +93,7 @@ class VeraThermostat(VeraDevice, ClimateDevice):
        self._state = self.vera_device.get_hvac_mode()

    @property
-    def unit_of_measurement(self):
+    def temperature_unit(self):
        """Return the unit of measurement."""
        return TEMP_FAHRENHEIT

@@ -8,9 +8,9 @@ https://home-assistant.io/components/climate.zwave/
 # pylint: disable=import-error
 import logging
 from homeassistant.components.climate import DOMAIN
-from homeassistant.components.climate import ClimateDevice
-from homeassistant.components.zwave import (
-    ATTR_NODE_ID, ATTR_VALUE_ID, ZWaveDeviceEntity)
+from homeassistant.components.climate import (
+    ClimateDevice, ATTR_OPERATION_MODE)
+from homeassistant.components.zwave import ZWaveDeviceEntity
 from homeassistant.components import zwave
 from homeassistant.const import (
    TEMP_CELSIUS, TEMP_FAHRENHEIT, ATTR_TEMPERATURE)
@@ -28,12 +28,6 @@ HORSTMANN = 0x0059
 HORSTMANN_HRT4_ZW = 0x3
 HORSTMANN_HRT4_ZW_THERMOSTAT = (HORSTMANN, HORSTMANN_HRT4_ZW)

-COMMAND_CLASS_SENSOR_MULTILEVEL = 0x31
-COMMAND_CLASS_THERMOSTAT_MODE = 0x40
-COMMAND_CLASS_THERMOSTAT_SETPOINT = 0x43
-COMMAND_CLASS_THERMOSTAT_FAN_MODE = 0x44
-COMMAND_CLASS_CONFIGURATION = 0x70
-
 WORKAROUND_ZXT_120 = 'zxt_120'
 WORKAROUND_HRT4_ZW = 'hrt4_zw'

@@ -67,19 +61,19 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
                      discovery_info, zwave.NETWORK)
        return
    temp_unit = hass.config.units.temperature_unit
-    node = zwave.NETWORK.nodes[discovery_info[ATTR_NODE_ID]]
-    value = node.values[discovery_info[ATTR_VALUE_ID]]
+    node = zwave.NETWORK.nodes[discovery_info[zwave.const.ATTR_NODE_ID]]
+    value = node.values[discovery_info[zwave.const.ATTR_VALUE_ID]]
    value.set_change_verified(False)
    add_devices([ZWaveClimate(value, temp_unit)])
    _LOGGER.debug("discovery_info=%s and zwave.NETWORK=%s",
                  discovery_info, zwave.NETWORK)


-# pylint: disable=too-many-arguments, abstract-method
+# pylint: disable=abstract-method
 class ZWaveClimate(ZWaveDeviceEntity, ClimateDevice):
    """Represents a ZWave Climate device."""

-    # pylint: disable=too-many-public-methods, too-many-instance-attributes
+    # pylint: disable=too-many-instance-attributes
    def __init__(self, value, temp_unit):
        """Initialize the zwave climate device."""
        from openzwave.network import ZWaveNetwork
@@ -130,7 +124,7 @@ class ZWaveClimate(ZWaveDeviceEntity, ClimateDevice):
        """Callback on data change for the registered node/value pair."""
        # Operation Mode
        for value in self._node.get_values(
-                class_id=COMMAND_CLASS_THERMOSTAT_MODE).values():
+                class_id=zwave.const.COMMAND_CLASS_THERMOSTAT_MODE).values():
            self._current_operation = value.data
            self._index_operation = SET_TEMP_TO_INDEX.get(
                self._current_operation)
@@ -139,14 +133,16 @@ class ZWaveClimate(ZWaveDeviceEntity, ClimateDevice):
            _LOGGER.debug("self._current_operation=%s",
                          self._current_operation)
        # Current Temp
-        for value in self._node.get_values(
-                class_id=COMMAND_CLASS_SENSOR_MULTILEVEL).values():
+        for value in (self._node.get_values(
+                class_id=zwave.const.COMMAND_CLASS_SENSOR_MULTILEVEL)
+                      .values()):
            if value.label == 'Temperature':
                self._current_temperature = int(value.data)
                self._unit = value.units
        # Fan Mode
-        for value in self._node.get_values(
-                class_id=COMMAND_CLASS_THERMOSTAT_FAN_MODE).values():
+        for value in (self._node.get_values(
+                class_id=zwave.const.COMMAND_CLASS_THERMOSTAT_FAN_MODE)
+                      .values()):
            self._current_fan_mode = value.data
            self._fan_list = list(value.data_items)
            _LOGGER.debug("self._fan_list=%s", self._fan_list)
@@ -154,17 +150,27 @@ class ZWaveClimate(ZWaveDeviceEntity, ClimateDevice):
                          self._current_fan_mode)
        # Swing mode
        if self._zxt_120 == 1:
-            for value in self._node.get_values(
-                    class_id=COMMAND_CLASS_CONFIGURATION).values():
-                if value.command_class == 112 and value.index == 33:
+            for value in (self._node.get_values(
+                    class_id=zwave.const.COMMAND_CLASS_CONFIGURATION)
+                          .values()):
+                if value.command_class == \
+                   zwave.const.COMMAND_CLASS_CONFIGURATION and \
+                   value.index == 33:
                    self._current_swing_mode = value.data
                    self._swing_list = list(value.data_items)
                    _LOGGER.debug("self._swing_list=%s", self._swing_list)
                    _LOGGER.debug("self._current_swing_mode=%s",
                                  self._current_swing_mode)
        # Set point
-        for value in self._node.get_values(
-                class_id=COMMAND_CLASS_THERMOSTAT_SETPOINT).values():
+        for value in (self._node.get_values(
+                class_id=zwave.const.COMMAND_CLASS_THERMOSTAT_SETPOINT)
+                      .values()):
+            if value.data == 0:
+                _LOGGER.debug("Setpoint is 0, setting default to "
+                              "current_temperature=%s",
+                              self._current_temperature)
+                self._target_temperature = int(self._current_temperature)
+                break
            if self.current_operation is not None and \
               self.current_operation != 'Off':
                if self._index_operation != value.index:
@@ -203,7 +209,7 @@ class ZWaveClimate(ZWaveDeviceEntity, ClimateDevice):
        return self._swing_list

    @property
-    def unit_of_measurement(self):
+    def temperature_unit(self):
        """Return the unit of measurement."""
        if self._unit == 'C':
            return TEMP_CELSIUS
@@ -232,16 +238,26 @@ class ZWaveClimate(ZWaveDeviceEntity, ClimateDevice):
        """Return the temperature we try to reach."""
        return self._target_temperature

-# pylint: disable=too-many-branches, too-many-statements
    def set_temperature(self, **kwargs):
        """Set new target temperature."""
        if kwargs.get(ATTR_TEMPERATURE) is not None:
            temperature = kwargs.get(ATTR_TEMPERATURE)
        else:
            return
+        operation_mode = kwargs.get(ATTR_OPERATION_MODE)
+        _LOGGER.debug("set_temperature operation_mode=%s", operation_mode)
+
+        for value in (self._node.get_values(
+                class_id=zwave.const.COMMAND_CLASS_THERMOSTAT_SETPOINT)
+                      .values()):
+            if operation_mode is not None:
+                setpoint_mode = SET_TEMP_TO_INDEX.get(operation_mode)
+                if value.index != setpoint_mode:
+                    continue
+                _LOGGER.debug("setpoint_mode=%s", setpoint_mode)
+                value.data = temperature
+                break

-        for value in self._node.get_values(
-                class_id=COMMAND_CLASS_THERMOSTAT_SETPOINT).values():
            if self.current_operation is not None:
                if self._hrt4_zw and self.current_operation == 'Off':
                    # HRT4-ZW can change setpoint when off.
@@ -279,17 +295,21 @@ class ZWaveClimate(ZWaveDeviceEntity, ClimateDevice):

    def set_fan_mode(self, fan):
        """Set new target fan mode."""
-        for value in self._node.get_values(
-                class_id=COMMAND_CLASS_THERMOSTAT_FAN_MODE).values():
-            if value.command_class == 68 and value.index == 0:
+        for value in (self._node.get_values(
+                class_id=zwave.const.COMMAND_CLASS_THERMOSTAT_FAN_MODE).
+                      values()):
+            if value.command_class == \
+               zwave.const.COMMAND_CLASS_THERMOSTAT_FAN_MODE and \
+               value.index == 0:
                value.data = bytes(fan, 'utf-8')
                break

    def set_operation_mode(self, operation_mode):
        """Set new target operation mode."""
        for value in self._node.get_values(
-                class_id=COMMAND_CLASS_THERMOSTAT_MODE).values():
-            if value.command_class == 64 and value.index == 0:
+                class_id=zwave.const.COMMAND_CLASS_THERMOSTAT_MODE).values():
+            if value.command_class == \
+               zwave.const.COMMAND_CLASS_THERMOSTAT_MODE and value.index == 0:
                value.data = bytes(operation_mode, 'utf-8')
                break

@@ -297,7 +317,9 @@ class ZWaveClimate(ZWaveDeviceEntity, ClimateDevice):
        """Set new target swing mode."""
        if self._zxt_120 == 1:
            for value in self._node.get_values(
-                    class_id=COMMAND_CLASS_CONFIGURATION).values():
-                if value.command_class == 112 and value.index == 33:
+                    class_id=zwave.const.COMMAND_CLASS_CONFIGURATION).values():
+                if value.command_class == \
+                   zwave.const.COMMAND_CLASS_CONFIGURATION and \
+                   value.index == 33:
                    value.data = bytes(swing_mode, 'utf-8')
                    break
@@ -29,6 +29,10 @@ SERVICE_PROCESS_SCHEMA = vol.Schema({
    vol.Required(ATTR_TEXT): vol.All(cv.string, vol.Lower),
 })

+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: vol.Schema({}),
+}, extra=vol.ALLOW_EXTRA)
+

 def setup(hass, config):
    """Register the process service."""
@@ -48,8 +52,8 @@ def setup(hass, config):

        name, command = match.groups()
        entities = {state.entity_id: state.name for state in hass.states.all()}
-        entity_ids = fuzzyExtract.extractOne(name, entities,
-                                             score_cutoff=65)[2]
+        entity_ids = fuzzyExtract.extractOne(
+            name, entities, score_cutoff=65)[2]

        if not entity_ids:
            logger.error(
@@ -70,6 +74,7 @@ def setup(hass, config):
            logger.error('Got unsupported command %s from text %s',
                         command, text)

-    hass.services.register(DOMAIN, SERVICE_PROCESS, process,
-                           schema=SERVICE_PROCESS_SCHEMA)
+    hass.services.register(
+        DOMAIN, SERVICE_PROCESS, process, schema=SERVICE_PROCESS_SCHEMA)
+
    return True
@@ -38,7 +38,8 @@ def setup_platform(hass, config, add_devices, discovery_info=None):

    for device_name, device_config in devices.items():
        value_template = device_config.get(CONF_VALUE_TEMPLATE)
-        value_template.hass = hass
+        if value_template is not None:
+            value_template.hass = hass

        covers.append(
            CommandCover(
@@ -0,0 +1,103 @@
+"""
+Support for MySensors covers.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/cover.mysensors/
+"""
+import logging
+
+from homeassistant.components import mysensors
+from homeassistant.components.cover import CoverDevice, ATTR_POSITION
+from homeassistant.const import STATE_ON, STATE_OFF
+
+_LOGGER = logging.getLogger(__name__)
+DEPENDENCIES = []
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup the mysensors platform for covers."""
+    if discovery_info is None:
+        return
+    for gateway in mysensors.GATEWAYS.values():
+        pres = gateway.const.Presentation
+        set_req = gateway.const.SetReq
+        map_sv_types = {
+            pres.S_COVER: [set_req.V_DIMMER, set_req.V_LIGHT],
+        }
+        if float(gateway.protocol_version) >= 1.5:
+            map_sv_types.update({
+                pres.S_COVER: [set_req.V_PERCENTAGE, set_req.V_STATUS],
+            })
+        devices = {}
+        gateway.platform_callbacks.append(mysensors.pf_callback_factory(
+            map_sv_types, devices, add_devices, MySensorsCover))
+
+
+class MySensorsCover(mysensors.MySensorsDeviceEntity, CoverDevice):
+    """Representation of the value of a MySensors Cover child node."""
+
+    @property
+    def assumed_state(self):
+        """Return True if unable to access real state of entity."""
+        return self.gateway.optimistic
+
+    @property
+    def is_closed(self):
+        """Return True if cover is closed."""
+        set_req = self.gateway.const.SetReq
+        if set_req.V_DIMMER in self._values:
+            return self._values.get(set_req.V_DIMMER) == 0
+        else:
+            return self._values.get(set_req.V_LIGHT) == STATE_OFF
+
+    @property
+    def current_cover_position(self):
+        """Return current position of cover.
+
+        None is unknown, 0 is closed, 100 is fully open.
+        """
+        set_req = self.gateway.const.SetReq
+        return self._values.get(set_req.V_DIMMER)
+
+    def open_cover(self, **kwargs):
+        """Move the cover up."""
+        set_req = self.gateway.const.SetReq
+        self.gateway.set_child_value(
+            self.node_id, self.child_id, set_req.V_UP, 1)
+        if self.gateway.optimistic:
+            # Optimistically assume that cover has changed state.
+            if set_req.V_DIMMER in self._values:
+                self._values[set_req.V_DIMMER] = 100
+            else:
+                self._values[set_req.V_LIGHT] = STATE_ON
+            self.update_ha_state()
+
+    def close_cover(self, **kwargs):
+        """Move the cover down."""
+        set_req = self.gateway.const.SetReq
+        self.gateway.set_child_value(
+            self.node_id, self.child_id, set_req.V_DOWN, 1)
+        if self.gateway.optimistic:
+            # Optimistically assume that cover has changed state.
+            if set_req.V_DIMMER in self._values:
+                self._values[set_req.V_DIMMER] = 0
+            else:
+                self._values[set_req.V_LIGHT] = STATE_OFF
+            self.update_ha_state()
+
+    def set_cover_position(self, **kwargs):
+        """Move the cover to a specific position."""
+        position = kwargs.get(ATTR_POSITION)
+        set_req = self.gateway.const.SetReq
+        self.gateway.set_child_value(
+            self.node_id, self.child_id, set_req.V_DIMMER, position)
+        if self.gateway.optimistic:
+            # Optimistically assume that cover has changed state.
+            self._values[set_req.V_DIMMER] = position
+            self.update_ha_state()
+
+    def stop_cover(self, **kwargs):
+        """Stop the device."""
+        set_req = self.gateway.const.SetReq
+        self.gateway.set_child_value(
+            self.node_id, self.child_id, set_req.V_STOP, 1)
@@ -12,9 +12,6 @@ from homeassistant.components.zwave import ZWaveDeviceEntity
 from homeassistant.components import zwave
 from homeassistant.components.cover import CoverDevice

-COMMAND_CLASS_SWITCH_MULTILEVEL = 0x26  # 38
-COMMAND_CLASS_SWITCH_BINARY = 0x25  # 37
-
 SOMFY = 0x47
 SOMFY_ZRTSI = 0x5a52
 SOMFY_ZRTSI_CONTROLLER = (SOMFY, SOMFY_ZRTSI)
@@ -32,17 +29,17 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    if discovery_info is None or zwave.NETWORK is None:
        return

-    node = zwave.NETWORK.nodes[discovery_info[zwave.ATTR_NODE_ID]]
-    value = node.values[discovery_info[zwave.ATTR_VALUE_ID]]
+    node = zwave.NETWORK.nodes[discovery_info[zwave.const.ATTR_NODE_ID]]
+    value = node.values[discovery_info[zwave.const.ATTR_VALUE_ID]]

-    if (value.command_class == zwave.COMMAND_CLASS_SWITCH_MULTILEVEL and
-            value.index == 0):
+    if node.has_command_class(zwave.const.COMMAND_CLASS_SWITCH_MULTILEVEL) \
+            and value.index == 0:
        value.set_change_verified(False)
        add_devices([ZwaveRollershutter(value)])
-    elif (value.command_class == zwave.COMMAND_CLASS_SWITCH_BINARY or
-          value.command_class == zwave.COMMAND_CLASS_BARRIER_OPERATOR):
-        if value.type != zwave.TYPE_BOOL and \
-           value.genre != zwave.GENRE_USER:
+    elif node.has_command_class(zwave.const.COMMAND_CLASS_SWITCH_BINARY) or \
+            node.has_command_class(zwave.const.COMMAND_CLASS_BARRIER_OPERATOR):
+        if value.type != zwave.const.TYPE_BOOL and \
+           value.genre != zwave.const.GENRE_USER:
            return
        value.set_change_verified(False)
        add_devices([ZwaveGarageDoor(value)])
@@ -59,6 +56,7 @@ class ZwaveRollershutter(zwave.ZWaveDeviceEntity, CoverDevice):
        from openzwave.network import ZWaveNetwork
        from pydispatch import dispatcher
        ZWaveDeviceEntity.__init__(self, value, DOMAIN)
+        # pylint: disable=no-member
        self._lozwmgr = libopenzwave.PyManager()
        self._lozwmgr.create()
        self._node = value.node
@@ -88,9 +86,10 @@ class ZwaveRollershutter(zwave.ZWaveDeviceEntity, CoverDevice):
        """Callback on data change for the registered node/value pair."""
        # Position value
        for value in self._node.get_values(
-                class_id=COMMAND_CLASS_SWITCH_MULTILEVEL).values():
-            if value.command_class == zwave.COMMAND_CLASS_SWITCH_MULTILEVEL \
-               and value.label == 'Level':
+                class_id=zwave.const.COMMAND_CLASS_SWITCH_MULTILEVEL).values():
+            if value.command_class == \
+               zwave.const.COMMAND_CLASS_SWITCH_MULTILEVEL and \
+               value.label == 'Level':
                self._current_position = value.data

    @property
@@ -118,22 +117,24 @@ class ZwaveRollershutter(zwave.ZWaveDeviceEntity, CoverDevice):
    def open_cover(self, **kwargs):
        """Move the roller shutter up."""
        for value in self._node.get_values(
-                class_id=COMMAND_CLASS_SWITCH_MULTILEVEL).values():
-            if value.command_class == zwave.COMMAND_CLASS_SWITCH_MULTILEVEL \
-               and value.label == 'Open' or \
-               value.command_class == zwave.COMMAND_CLASS_SWITCH_MULTILEVEL \
-               and value.label == 'Down':
+                class_id=zwave.const.COMMAND_CLASS_SWITCH_MULTILEVEL).values():
+            if value.command_class == \
+               zwave.const.COMMAND_CLASS_SWITCH_MULTILEVEL and value.label == \
+               'Open' or value.command_class == \
+               zwave.const.COMMAND_CLASS_SWITCH_MULTILEVEL and value.label == \
+               'Down':
                self._lozwmgr.pressButton(value.value_id)
                break

    def close_cover(self, **kwargs):
        """Move the roller shutter down."""
        for value in self._node.get_values(
-                class_id=COMMAND_CLASS_SWITCH_MULTILEVEL).values():
-            if value.command_class == zwave.COMMAND_CLASS_SWITCH_MULTILEVEL \
-               and value.label == 'Up' or \
-               value.command_class == zwave.COMMAND_CLASS_SWITCH_MULTILEVEL \
-               and value.label == 'Close':
+                class_id=zwave.const.COMMAND_CLASS_SWITCH_MULTILEVEL).values():
+            if value.command_class == \
+               zwave.const.COMMAND_CLASS_SWITCH_MULTILEVEL and value.label == \
+               'Up' or value.command_class == \
+               zwave.const.COMMAND_CLASS_SWITCH_MULTILEVEL and value.label == \
+               'Close':
                self._lozwmgr.pressButton(value.value_id)
                break

@@ -144,11 +145,12 @@ class ZwaveRollershutter(zwave.ZWaveDeviceEntity, CoverDevice):
    def stop_cover(self, **kwargs):
        """Stop the roller shutter."""
        for value in self._node.get_values(
-                class_id=COMMAND_CLASS_SWITCH_MULTILEVEL).values():
-            if value.command_class == zwave.COMMAND_CLASS_SWITCH_MULTILEVEL \
-               and value.label == 'Open' or \
-               value.command_class == zwave.COMMAND_CLASS_SWITCH_MULTILEVEL \
-               and value.label == 'Down':
+                class_id=zwave.const.COMMAND_CLASS_SWITCH_MULTILEVEL).values():
+            if value.command_class == \
+               zwave.const.COMMAND_CLASS_SWITCH_MULTILEVEL and value.label == \
+               'Open' or value.command_class == \
+               zwave.const.COMMAND_CLASS_SWITCH_MULTILEVEL and value.label == \
+               'Down':
                self._lozwmgr.releaseButton(value.value_id)
                break

@@ -67,31 +67,33 @@ def setup(hass, config):
    lights = sorted(hass.states.entity_ids('light'))
    switches = sorted(hass.states.entity_ids('switch'))
    media_players = sorted(hass.states.entity_ids('media_player'))
-    group.Group(hass, 'living room', [
+
+    group.Group.create_group(hass, 'living room', [
        lights[1], switches[0], 'input_select.living_room_preset',
        'rollershutter.living_room_window', media_players[1],
        'scene.romantic_lights'])
-    group.Group(hass, 'bedroom', [
+    group.Group.create_group(hass, 'bedroom', [
        lights[0], switches[1], media_players[0],
        'input_slider.noise_allowance'])
-    group.Group(hass, 'kitchen', [
+    group.Group.create_group(hass, 'kitchen', [
        lights[2], 'rollershutter.kitchen_window', 'lock.kitchen_door'])
-    group.Group(hass, 'doors', [
+    group.Group.create_group(hass, 'doors', [
        'lock.front_door', 'lock.kitchen_door',
        'garage_door.right_garage_door', 'garage_door.left_garage_door'])
-    group.Group(hass, 'automations', [
+    group.Group.create_group(hass, 'automations', [
        'input_select.who_cooks', 'input_boolean.notify', ])
-    group.Group(hass, 'people', [
+    group.Group.create_group(hass, 'people', [
        'device_tracker.demo_anne_therese', 'device_tracker.demo_home_boy',
        'device_tracker.demo_paulus'])
-    group.Group(hass, 'thermostats', [
+    group.Group.create_group(hass, 'thermostats', [
        'thermostat.nest', 'thermostat.thermostat'])
-    group.Group(hass, 'downstairs', [
+    group.Group.create_group(hass, 'downstairs', [
        'group.living_room', 'group.kitchen',
        'scene.romantic_lights', 'rollershutter.kitchen_window',
-        'rollershutter.living_room_window', 'group.doors', 'thermostat.nest',
+        'rollershutter.living_room_window', 'group.doors',
+        'thermostat.nest',
    ], view=True)
-    group.Group(hass, 'Upstairs', [
+    group.Group.create_group(hass, 'Upstairs', [
        'thermostat.thermostat', 'group.bedroom',
    ], view=True)

@@ -6,6 +6,7 @@ https://home-assistant.io/components/device_tracker/
 """
 # pylint: disable=too-many-instance-attributes, too-many-arguments
 # pylint: disable=too-many-locals
+import asyncio
 from datetime import timedelta
 import logging
 import os
@@ -13,6 +14,7 @@ import threading
 from typing import Any, Sequence, Callable

 import voluptuous as vol
+import yaml

 from homeassistant.bootstrap import (
    prepare_setup_platform, log_exception)
@@ -25,6 +27,7 @@ from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.typing import GPSType, ConfigType, HomeAssistantType
 import homeassistant.helpers.config_validation as cv
 import homeassistant.util as util
+from homeassistant.util.async import run_coroutine_threadsafe
 import homeassistant.util.dt as dt_util

 from homeassistant.helpers.event import track_utc_time_change
@@ -46,7 +49,7 @@ CONF_TRACK_NEW = 'track_new_devices'
 DEFAULT_TRACK_NEW = True

 CONF_CONSIDER_HOME = 'consider_home'
-DEFAULT_CONSIDER_HOME = 180  # seconds
+DEFAULT_CONSIDER_HOME = 180

 CONF_SCAN_INTERVAL = 'interval_seconds'
 DEFAULT_SCAN_INTERVAL = 12
@@ -66,13 +69,11 @@ ATTR_ATTRIBUTES = 'attributes'

 PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
    vol.Optional(CONF_SCAN_INTERVAL): cv.positive_int,  # seconds
-}, extra=vol.ALLOW_EXTRA)
-
-_CONFIG_SCHEMA = vol.Schema({DOMAIN: vol.All(cv.ensure_list, [
-    vol.Schema({
-        vol.Optional(CONF_TRACK_NEW): cv.boolean,
-        vol.Optional(CONF_CONSIDER_HOME): cv.positive_int  # seconds
-    }, extra=vol.ALLOW_EXTRA)])}, extra=vol.ALLOW_EXTRA)
+    vol.Optional(CONF_TRACK_NEW, default=DEFAULT_TRACK_NEW): cv.boolean,
+    vol.Optional(CONF_CONSIDER_HOME,
+                 default=timedelta(seconds=DEFAULT_CONSIDER_HOME)): vol.All(
+                     cv.time_period, cv.positive_timedelta)
+})

 DISCOVERY_PLATFORMS = {
    SERVICE_NETGEAR: 'netgear',
@@ -112,14 +113,14 @@ def setup(hass: HomeAssistantType, config: ConfigType):
    yaml_path = hass.config.path(YAML_DEVICES)

    try:
-        conf = _CONFIG_SCHEMA(config).get(DOMAIN, [])
+        conf = config.get(DOMAIN, [])
    except vol.Invalid as ex:
        log_exception(ex, DOMAIN, config)
        return False
    else:
        conf = conf[0] if len(conf) > 0 else {}
-        consider_home = timedelta(
-            seconds=conf.get(CONF_CONSIDER_HOME, DEFAULT_CONSIDER_HOME))
+        consider_home = conf.get(CONF_CONSIDER_HOME,
+                                 timedelta(seconds=DEFAULT_CONSIDER_HOME))
        track_new = conf.get(CONF_TRACK_NEW, DEFAULT_TRACK_NEW)

    devices = load_config(yaml_path, hass, consider_home)
@@ -250,9 +251,18 @@ class DeviceTracker(object):

    def setup_group(self):
        """Initialize group for all tracked devices."""
+        run_coroutine_threadsafe(
+            self.async_setup_group(), self.hass.loop).result()
+
+    @asyncio.coroutine
+    def async_setup_group(self):
+        """Initialize group for all tracked devices.
+
+        This method must be run in the event loop.
+        """
        entity_ids = (dev.entity_id for dev in self.devices.values()
                      if dev.track)
-        self.group = group.Group(
+        self.group = yield from group.Group.async_create_group(
            self.hass, GROUP_NAME_ALL_DEVICES, entity_ids, False)

    def update_stale(self, now: dt_util.dt.datetime):
@@ -282,7 +292,7 @@ class Device(Entity):
    def __init__(self, hass: HomeAssistantType, consider_home: timedelta,
                 track: bool, dev_id: str, mac: str, name: str=None,
                 picture: str=None, gravatar: str=None,
-                 away_hide: bool=False) -> None:
+                 hide_if_away: bool=False) -> None:
        """Initialize a device."""
        self.hass = hass
        self.entity_id = ENTITY_ID_FORMAT.format(dev_id)
@@ -307,7 +317,7 @@ class Device(Entity):
        else:
            self.config_picture = picture

-        self.away_hide = away_hide
+        self.away_hide = hide_if_away

    @property
    def name(self):
@@ -398,15 +408,34 @@ class Device(Entity):

 def load_config(path: str, hass: HomeAssistantType, consider_home: timedelta):
    """Load devices from YAML configuration file."""
+    dev_schema = vol.Schema({
+        vol.Required('name'): cv.string,
+        vol.Optional('track', default=False): cv.boolean,
+        vol.Optional('mac', default=None): vol.Any(None, vol.All(cv.string,
+                                                                 vol.Upper)),
+        vol.Optional(CONF_AWAY_HIDE, default=DEFAULT_AWAY_HIDE): cv.boolean,
+        vol.Optional('gravatar', default=None): vol.Any(None, cv.string),
+        vol.Optional('picture', default=None): vol.Any(None, cv.string),
+        vol.Optional(CONF_CONSIDER_HOME, default=consider_home): vol.All(
+            cv.time_period, cv.positive_timedelta)
+    })
    try:
-        return [
-            Device(hass, consider_home, device.get('track', False),
-                   str(dev_id).lower(), None if device.get('mac') is None
-                   else str(device.get('mac')).upper(),
-                   device.get('name'), device.get('picture'),
-                   device.get('gravatar'),
-                   device.get(CONF_AWAY_HIDE, DEFAULT_AWAY_HIDE))
-            for dev_id, device in load_yaml_config_file(path).items()]
+        result = []
+        try:
+            devices = load_yaml_config_file(path)
+        except HomeAssistantError as err:
+            _LOGGER.error('Unable to load %s: %s', path, str(err))
+            return []
+
+        for dev_id, device in devices.items():
+            try:
+                device = dev_schema(device)
+                device['dev_id'] = cv.slugify(dev_id)
+            except vol.Invalid as exp:
+                log_exception(exp, dev_id, devices)
+            else:
+                result.append(Device(hass, **device))
+        return result
    except (HomeAssistantError, FileNotFoundError):
        # When YAML file could not be loaded/did not contain a dict
        return []
@@ -440,14 +469,15 @@ def update_config(path: str, dev_id: str, device: Device):
    """Add device to YAML configuration file."""
    with open(path, 'a') as out:
        out.write('\n')
-        out.write('{}:\n'.format(device.dev_id))

-        for key, value in (('name', device.name), ('mac', device.mac),
-                           ('picture', device.config_picture),
-                           ('track', 'yes' if device.track else 'no'),
-                           (CONF_AWAY_HIDE,
-                            'yes' if device.away_hide else 'no')):
-            out.write('  {}: {}\n'.format(key, '' if value is None else value))
+        device = {device.dev_id: {
+            'name': device.name,
+            'mac': device.mac,
+            'picture': device.config_picture,
+            'track': device.track,
+            CONF_AWAY_HIDE: device.away_hide
+        }}
+        yaml.dump(device, out, default_flow_style=False)


 def get_gravatar_for_email(email: str):
@@ -0,0 +1,82 @@
+"""
+Support for French FAI Bouygues Bbox routers.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.bbox/
+"""
+from collections import namedtuple
+import logging
+from datetime import timedelta
+import homeassistant.util.dt as dt_util
+from homeassistant.components.device_tracker import DOMAIN
+from homeassistant.util import Throttle
+
+# Return cached results if last scan was less then this time ago
+MIN_TIME_BETWEEN_SCANS = timedelta(seconds=60)
+
+_LOGGER = logging.getLogger(__name__)
+REQUIREMENTS = ['pybbox==0.0.5-alpha']
+
+
+def get_scanner(hass, config):
+    """Validate the configuration and return a Bbox scanner."""
+    scanner = BboxDeviceScanner(config[DOMAIN])
+
+    return scanner if scanner.success_init else None
+
+
+Device = namedtuple('Device', ['mac', 'name', 'ip', 'last_update'])
+
+
+class BboxDeviceScanner(object):
+    """This class scans for devices connected to the bbox."""
+
+    def __init__(self, config):
+        """Initialize the scanner."""
+        self.last_results = []  # type: List[Device]
+
+        self.success_init = self._update_info()
+        _LOGGER.info('Bbox scanner initialized')
+
+    def scan_devices(self):
+        """Scan for new devices and return a list with found device IDs."""
+        self._update_info()
+
+        return [device.mac for device in self.last_results]
+
+    def get_device_name(self, mac):
+        """Return the name of the given device or None if we don't know."""
+        filter_named = [device.name for device in self.last_results if
+                        device.mac == mac]
+
+        if filter_named:
+            return filter_named[0]
+        else:
+            return None
+
+    @Throttle(MIN_TIME_BETWEEN_SCANS)
+    def _update_info(self):
+        """Check the bbox for devices.
+
+        Returns boolean if scanning successful.
+        """
+        _LOGGER.info('Scanning')
+
+        import pybbox
+
+        box = pybbox.Bbox()
+        result = box.get_all_connected_devices()
+
+        now = dt_util.now()
+        last_results = []
+        for device in result:
+            if device['active'] != 1:
+                continue
+            last_results.append(
+                Device(device['macaddress'], device['hostname'],
+                       device['ipaddress'], now))
+
+        self.last_results = last_results
+
+        _LOGGER.info('Bbox scan successful')
+        return True
@@ -79,13 +79,15 @@ class FritzBoxScanner(object):
        self._update_info()
        active_hosts = []
        for known_host in self.last_results:
-            if known_host['status'] == '1':
+            if known_host['status'] == '1' and known_host.get('mac'):
                active_hosts.append(known_host['mac'])
        return active_hosts

    def get_device_name(self, mac):
        """Return the name of the given device or None if is not known."""
-        ret = self.fritz_box.get_specific_host_entry(mac)['NewHostName']
+        ret = self.fritz_box.get_specific_host_entry(mac).get(
+            'NewHostName'
+        )
        if ret == {}:
            return None
        return ret
@@ -11,13 +11,14 @@ import voluptuous as vol
 import homeassistant.components.mqtt as mqtt
 from homeassistant.const import CONF_DEVICES
 from homeassistant.components.mqtt import CONF_QOS
+from homeassistant.components.device_tracker import PLATFORM_SCHEMA
 import homeassistant.helpers.config_validation as cv

 DEPENDENCIES = ['mqtt']

 _LOGGER = logging.getLogger(__name__)

-PLATFORM_SCHEMA = mqtt.MQTT_BASE_PLATFORM_SCHEMA.extend({
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(mqtt.SCHEMA_BASE).extend({
    vol.Required(CONF_DEVICES): {cv.string: mqtt.valid_subscribe_topic},
 })

@@ -30,7 +30,7 @@ CONF_EXCLUDE = 'exclude'
 REQUIREMENTS = ['python-nmap==0.6.1']

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Required(CONF_HOSTS): cv.string,
+    vol.Required(CONF_HOSTS): cv.ensure_list,
    vol.Required(CONF_HOME_INTERVAL, default=0): cv.positive_int,
    vol.Optional(CONF_EXCLUDE, default=[]):
        vol.All(cv.ensure_list, vol.Length(min=1))
@@ -120,7 +120,8 @@ class NmapDeviceScanner(object):
            options += ' --exclude {}'.format(','.join(exclude_hosts))

        try:
-            result = scanner.scan(hosts=self.hosts, arguments=options)
+            result = scanner.scan(hosts=' '.join(self.hosts),
+                                  arguments=options)
        except PortScannerError:
            return False

@@ -7,6 +7,7 @@ https://home-assistant.io/components/device_tracker.owntracks/
 import json
 import logging
 import threading
+import base64
 from collections import defaultdict

 import voluptuous as vol
@@ -18,53 +19,121 @@ from homeassistant.util import convert, slugify
 from homeassistant.components import zone as zone_comp
 from homeassistant.components.device_tracker import PLATFORM_SCHEMA

-DEPENDENCIES = ['mqtt']
-
-REGIONS_ENTERED = defaultdict(list)
-MOBILE_BEACONS_ACTIVE = defaultdict(list)
-
-BEACON_DEV_ID = 'beacon'
-
-LOCATION_TOPIC = 'owntracks/+/+'
-EVENT_TOPIC = 'owntracks/+/+/event'
-WAYPOINT_TOPIC = 'owntracks/{}/{}/waypoint'
+REQUIREMENTS = ['libnacl==1.5.0']

 _LOGGER = logging.getLogger(__name__)

-LOCK = threading.Lock()
+BEACON_DEV_ID = 'beacon'

 CONF_MAX_GPS_ACCURACY = 'max_gps_accuracy'
+CONF_SECRET = 'secret'
 CONF_WAYPOINT_IMPORT = 'waypoints'
 CONF_WAYPOINT_WHITELIST = 'waypoint_whitelist'

+DEPENDENCIES = ['mqtt']
+
+EVENT_TOPIC = 'owntracks/+/+/event'
+
+LOCATION_TOPIC = 'owntracks/+/+'
+LOCK = threading.Lock()
+
+MOBILE_BEACONS_ACTIVE = defaultdict(list)
+
+REGIONS_ENTERED = defaultdict(list)
+
 VALIDATE_LOCATION = 'location'
 VALIDATE_TRANSITION = 'transition'
 VALIDATE_WAYPOINTS = 'waypoints'

 WAYPOINT_LAT_KEY = 'lat'
 WAYPOINT_LON_KEY = 'lon'
+WAYPOINT_TOPIC = 'owntracks/{}/{}/waypoint'

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Optional(CONF_MAX_GPS_ACCURACY): vol.Coerce(float),
    vol.Optional(CONF_WAYPOINT_IMPORT, default=True): cv.boolean,
-    vol.Optional(CONF_WAYPOINT_WHITELIST): vol.All(cv.ensure_list, [cv.string])
+    vol.Optional(CONF_WAYPOINT_WHITELIST): vol.All(
+        cv.ensure_list, [cv.string]),
+    vol.Optional(CONF_SECRET): vol.Any(
+        vol.Schema({vol.Optional(cv.string): cv.string}),
+        cv.string)
 })


+def get_cipher():
+    """Return decryption function and length of key."""
+    from libnacl import crypto_secretbox_KEYBYTES as KEYLEN
+    from libnacl.secret import SecretBox
+
+    def decrypt(ciphertext, key):
+        """Decrypt ciphertext using key."""
+        return SecretBox(key).decrypt(ciphertext)
+    return (KEYLEN, decrypt)
+
+
 def setup_scanner(hass, config, see):
-    """Setup an OwnTracks tracker."""
+    """Set up an OwnTracks tracker."""
    max_gps_accuracy = config.get(CONF_MAX_GPS_ACCURACY)
    waypoint_import = config.get(CONF_WAYPOINT_IMPORT)
    waypoint_whitelist = config.get(CONF_WAYPOINT_WHITELIST)
+    secret = config.get(CONF_SECRET)
+
+    def decrypt_payload(topic, ciphertext):
+        """Decrypt encrypted payload."""
+        try:
+            keylen, decrypt = get_cipher()
+        except OSError:
+            _LOGGER.warning('Ignoring encrypted payload '
+                            'because libsodium not installed.')
+            return None
+
+        if isinstance(secret, dict):
+            key = secret.get(topic)
+        else:
+            key = secret
+
+        if key is None:
+            _LOGGER.warning('Ignoring encrypted payload '
+                            'because no decryption key known '
+                            'for topic %s.', topic)
+            return None
+
+        key = key.encode("utf-8")
+        key = key[:keylen]
+        key = key.ljust(keylen, b'\0')
+
+        try:
+            ciphertext = base64.b64decode(ciphertext)
+            message = decrypt(ciphertext, key)
+            message = message.decode("utf-8")
+            _LOGGER.debug("Decrypted payload: %s", message)
+            return message
+        except ValueError:
+            _LOGGER.warning('Ignoring encrypted payload '
+                            'because unable to decrypt using key '
+                            'for topic %s.', topic)
+            return None
+
+    def validate_payload(topic, payload, data_type):
+        """Validate the OwnTracks payload."""
+        # pylint: disable=too-many-return-statements

-    def validate_payload(payload, data_type):
-        """Validate OwnTracks payload."""
        try:
            data = json.loads(payload)
        except ValueError:
            # If invalid JSON
            _LOGGER.error('Unable to parse payload as JSON: %s', payload)
            return None
+
+        if isinstance(data, dict) and \
+           data.get('_type') == 'encrypted' and \
+           'data' in data:
+            plaintext_payload = decrypt_payload(topic, data['data'])
+            if plaintext_payload is None:
+                return None
+            else:
+                return validate_payload(topic, plaintext_payload, data_type)
+
        if not isinstance(data, dict) or data.get('_type') != data_type:
            _LOGGER.debug('Skipping %s update for following data '
                          'because of missing or malformatted data: %s',
@@ -90,7 +159,7 @@ def setup_scanner(hass, config, see):
        """MQTT message received."""
        # Docs on available data:
        # http://owntracks.org/booklet/tech/json/#_typelocation
-        data = validate_payload(payload, VALIDATE_LOCATION)
+        data = validate_payload(topic, payload, VALIDATE_LOCATION)
        if not data:
            return

@@ -111,7 +180,7 @@ def setup_scanner(hass, config, see):
        """MQTT event (geofences) received."""
        # Docs on available data:
        # http://owntracks.org/booklet/tech/json/#_typetransition
-        data = validate_payload(payload, VALIDATE_TRANSITION)
+        data = validate_payload(topic, payload, VALIDATE_TRANSITION)
        if not data:
            return

@@ -206,7 +275,7 @@ def setup_scanner(hass, config, see):
        """List of waypoints published by a user."""
        # Docs on available data:
        # http://owntracks.org/booklet/tech/json/#_typewaypoints
-        data = validate_payload(payload, VALIDATE_WAYPOINTS)
+        data = validate_payload(topic, payload, VALIDATE_WAYPOINTS)
        if not data:
            return

@@ -23,11 +23,17 @@ _LOGGER = logging.getLogger(__name__)
 REQUIREMENTS = ['pysnmp==4.3.2']

 CONF_COMMUNITY = "community"
+CONF_AUTHKEY = "authkey"
+CONF_PRIVKEY = "privkey"
 CONF_BASEOID = "baseoid"

+DEFAULT_COMMUNITY = "public"
+
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Required(CONF_HOST): cv.string,
-    vol.Required(CONF_COMMUNITY): cv.string,
+    vol.Optional(CONF_COMMUNITY, default=DEFAULT_COMMUNITY): cv.string,
+    vol.Inclusive(CONF_AUTHKEY, "keys"): cv.string,
+    vol.Inclusive(CONF_PRIVKEY, "keys"): cv.string,
    vol.Required(CONF_BASEOID): cv.string
 })

@@ -43,13 +49,24 @@ def get_scanner(hass, config):
 class SnmpScanner(object):
    """Queries any SNMP capable Access Point for connected devices."""

+    # pylint: disable=too-many-instance-attributes
    def __init__(self, config):
        """Initialize the scanner."""
        from pysnmp.entity.rfc3413.oneliner import cmdgen
+        from pysnmp.entity import config as cfg
        self.snmp = cmdgen.CommandGenerator()

        self.host = cmdgen.UdpTransportTarget((config[CONF_HOST], 161))
-        self.community = cmdgen.CommunityData(config[CONF_COMMUNITY])
+        if CONF_AUTHKEY not in config or CONF_PRIVKEY not in config:
+            self.auth = cmdgen.CommunityData(config[CONF_COMMUNITY])
+        else:
+            self.auth = cmdgen.UsmUserData(
+                config[CONF_COMMUNITY],
+                config[CONF_AUTHKEY],
+                config[CONF_PRIVKEY],
+                authProtocol=cfg.usmHMACSHAAuthProtocol,
+                privProtocol=cfg.usmAesCfb128Protocol
+            )
        self.baseoid = cmdgen.MibVariable(config[CONF_BASEOID])

        self.lock = threading.Lock()
@@ -95,7 +112,7 @@ class SnmpScanner(object):
        devices = []

        errindication, errstatus, errindex, restable = self.snmp.nextCmd(
-            self.community, self.host, self.baseoid)
+            self.auth, self.host, self.baseoid)

        if errindication:
            _LOGGER.error("SNMPLIB error: %s", errindication)
@@ -0,0 +1,101 @@
+"""
+Support for Volvo On Call.
+
+http://www.volvocars.com/intl/own/owner-info/volvo-on-call
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.volvooncall/
+"""
+import logging
+from datetime import timedelta
+from urllib.parse import urljoin
+import voluptuous as vol
+import requests
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers.event import track_point_in_utc_time
+from homeassistant.util.dt import utcnow
+from homeassistant.util import slugify
+from homeassistant.const import (
+    CONF_PASSWORD,
+    CONF_SCAN_INTERVAL,
+    CONF_USERNAME)
+from homeassistant.components.device_tracker import (
+    DEFAULT_SCAN_INTERVAL,
+    PLATFORM_SCHEMA)
+
+MIN_TIME_BETWEEN_SCANS = timedelta(minutes=1)
+
+_LOGGER = logging.getLogger(__name__)
+
+SERVICE_URL = 'https://vocapi.wirelesscar.net/customerapi/rest/v3.0/'
+HEADERS = {"X-Device-Id": "Device",
+           "X-OS-Type": "Android",
+           "X-Originator-Type": "App"}
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_USERNAME): cv.string,
+    vol.Required(CONF_PASSWORD): cv.string,
+})
+
+
+def setup_scanner(hass, config, see):
+    """Validate the configuration and return a scanner."""
+    session = requests.Session()
+    session.headers.update(HEADERS)
+    session.auth = (config.get(CONF_USERNAME),
+                    config.get(CONF_PASSWORD))
+
+    interval = max(MIN_TIME_BETWEEN_SCANS.seconds,
+                   config.get(CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL))
+
+    def query(ref, rel=SERVICE_URL):
+        """Perform a query to the online service."""
+        url = urljoin(rel, ref)
+        _LOGGER.debug("Request for %s", url)
+        res = session.get(url, timeout=15)
+        res.raise_for_status()
+        _LOGGER.debug("Received %s", res.json())
+        return res.json()
+
+    def update(now):
+        """Update status from the online service."""
+        try:
+            _LOGGER.debug("Updating")
+            status = query("status", vehicle_url)
+            position = query("position", vehicle_url)
+            see(dev_id=dev_id,
+                host_name=host_name,
+                gps=(position["position"]["latitude"],
+                     position["position"]["longitude"]),
+                attributes=dict(
+                    tank_volume=attributes["fuelTankVolume"],
+                    washer_fluid=status["washerFluidLevel"],
+                    brake_fluid=status["brakeFluid"],
+                    service_warning=status["serviceWarningStatus"],
+                    fuel=status["fuelAmount"],
+                    odometer=status["odometer"],
+                    range=status["distanceToEmpty"]))
+        except requests.exceptions.RequestException as error:
+            _LOGGER.error("Could not query server: %s", error)
+        finally:
+            track_point_in_utc_time(hass, update,
+                                    now + timedelta(seconds=interval))
+
+    try:
+        _LOGGER.info('Logging in to service')
+        user = query("customeraccounts")
+        rel = query(user["accountVehicleRelations"][0])
+        vehicle_url = rel["vehicle"] + '/'
+        attributes = query("attributes", vehicle_url)
+
+        dev_id = "volvo_" + slugify(attributes["registrationNumber"])
+        host_name = "%s %s/%s" % (attributes["registrationNumber"],
+                                  attributes["vehicleType"],
+                                  attributes["modelYear"])
+        update(utcnow())
+        return True
+    except requests.exceptions.RequestException as error:
+        _LOGGER.error("Could not log in to service. "
+                      "Please check configuration: "
+                      "%s", error)
+        return False
@@ -0,0 +1,86 @@
+"""
+Support for Digital Ocean.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/digital_ocean/
+"""
+import logging
+from datetime import timedelta
+
+import voluptuous as vol
+
+from homeassistant.const import CONF_ACCESS_TOKEN
+from homeassistant.util import Throttle
+import homeassistant.helpers.config_validation as cv
+
+REQUIREMENTS = ['python-digitalocean==1.10.0']
+
+_LOGGER = logging.getLogger(__name__)
+
+ATTR_CREATED_AT = 'created_at'
+ATTR_DROPLET_ID = 'droplet_id'
+ATTR_DROPLET_NAME = 'droplet_name'
+ATTR_FEATURES = 'features'
+ATTR_IPV4_ADDRESS = 'ipv4_address'
+ATTR_IPV6_ADDRESS = 'ipv6_address'
+ATTR_MEMORY = 'memory'
+ATTR_REGION = 'region'
+ATTR_VCPUS = 'vcpus'
+
+CONF_DROPLETS = 'droplets'
+
+DIGITAL_OCEAN = None
+DIGITAL_OCEAN_PLATFORMS = ['switch', 'binary_sensor']
+DOMAIN = 'digital_ocean'
+
+MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=60)
+
+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: vol.Schema({
+        vol.Required(CONF_ACCESS_TOKEN): cv.string,
+    }),
+}, extra=vol.ALLOW_EXTRA)
+
+
+# pylint: disable=unused-argument,too-few-public-methods
+def setup(hass, config):
+    """Set up the Digital Ocean component."""
+    conf = config[DOMAIN]
+    access_token = conf.get(CONF_ACCESS_TOKEN)
+
+    global DIGITAL_OCEAN
+    DIGITAL_OCEAN = DigitalOcean(access_token)
+
+    if not DIGITAL_OCEAN.manager.get_account():
+        _LOGGER.error("No Digital Ocean account found for the given API Token")
+        return False
+
+    return True
+
+
+class DigitalOcean(object):
+    """Handle all communication with the Digital Ocean API."""
+
+    def __init__(self, access_token):
+        """Initialize the Digital Ocean connection."""
+        import digitalocean
+
+        self._access_token = access_token
+        self.data = None
+        self.manager = digitalocean.Manager(token=self._access_token)
+
+    def get_droplet_id(self, droplet_name):
+        """Get the status of a Digital Ocean droplet."""
+        droplet_id = None
+
+        all_droplets = self.manager.get_all_droplets()
+        for droplet in all_droplets:
+            if droplet_name == droplet.name:
+                droplet_id = droplet.id
+
+        return droplet_id
+
+    @Throttle(MIN_TIME_BETWEEN_UPDATES)
+    def update(self):
+        """Use the data from Digital Ocean API."""
+        self.data = self.manager.get_all_droplets()
@@ -9,18 +9,22 @@ loaded before the EVENT_PLATFORM_DISCOVERED is fired.
 import logging
 import threading

+import voluptuous as vol
+
 from homeassistant.const import EVENT_HOMEASSISTANT_START
 from homeassistant.helpers.discovery import load_platform, discover

-REQUIREMENTS = ['netdisco==0.7.1']
+REQUIREMENTS = ['netdisco==0.7.2']

 DOMAIN = 'discovery'

 SCAN_INTERVAL = 300  # seconds
 SERVICE_NETGEAR = 'netgear_router'
 SERVICE_WEMO = 'belkin_wemo'
+SERVICE_HASS_IOS_APP = 'hass_ios'

 SERVICE_HANDLERS = {
+    SERVICE_HASS_IOS_APP: ('ios', None),
    SERVICE_NETGEAR: ('device_tracker', None),
    SERVICE_WEMO: ('wemo', None),
    'philips_hue': ('light', 'hue'),
@@ -33,6 +37,10 @@ SERVICE_HANDLERS = {
    'directv': ('media_player', 'directv'),
 }

+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: vol.Schema({}),
+}, extra=vol.ALLOW_EXTRA)
+

 def setup(hass, config):
    """Start a discovery service."""
@@ -0,0 +1,95 @@
+"""
+A component which allows you to send data to Emoncms.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/emoncms_history/
+"""
+import logging
+from datetime import timedelta
+
+import voluptuous as vol
+import requests
+
+from homeassistant.const import (
+    CONF_API_KEY, CONF_WHITELIST,
+    CONF_URL, STATE_UNKNOWN,
+    STATE_UNAVAILABLE,
+    CONF_SCAN_INTERVAL)
+import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers import state as state_helper
+from homeassistant.helpers.event import track_point_in_time
+from homeassistant.util import dt as dt_util
+
+_LOGGER = logging.getLogger(__name__)
+
+DOMAIN = "emoncms_history"
+CONF_INPUTNODE = "inputnode"
+
+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: vol.Schema({
+        vol.Required(CONF_API_KEY): cv.string,
+        vol.Required(CONF_URL): cv.string,
+        vol.Required(CONF_INPUTNODE): cv.positive_int,
+        vol.Required(CONF_WHITELIST): cv.entity_ids,
+        vol.Optional(CONF_SCAN_INTERVAL, default=30): cv.positive_int,
+    }),
+}, extra=vol.ALLOW_EXTRA)
+
+
+def setup(hass, config):
+    """Setup the emoncms_history component."""
+    conf = config[DOMAIN]
+    whitelist = conf.get(CONF_WHITELIST)
+
+    def send_data(url, apikey, node, payload):
+        """Send payload data to emoncms."""
+        try:
+            fullurl = "{}/input/post.json".format(url)
+            req = requests.post(fullurl,
+                                params={"node": node},
+                                data={"apikey": apikey,
+                                      "data": payload},
+                                allow_redirects=True,
+                                timeout=5)
+
+        except requests.exceptions.RequestException:
+            _LOGGER.error("Error saving data '%s' to '%s'",
+                          payload, fullurl)
+
+        else:
+            if req.status_code != 200:
+                _LOGGER.error("Error saving data '%s' to '%s'" +
+                              "(http status code = %d)", payload,
+                              fullurl, req.status_code)
+
+    def update_emoncms(time):
+        """Send whitelisted entities states reguarly to emoncms."""
+        payload_dict = {}
+
+        for entity_id in whitelist:
+            state = hass.states.get(entity_id)
+
+            if state is None or state.state in (
+                    STATE_UNKNOWN, "", STATE_UNAVAILABLE):
+                continue
+
+            try:
+                payload_dict[entity_id] = state_helper.state_as_number(
+                    state)
+            except ValueError:
+                continue
+
+        if len(payload_dict) > 0:
+            payload = "{%s}" % ",".join("{}:{}".format(key, val)
+                                        for key, val in
+                                        payload_dict.items())
+
+            send_data(conf.get(CONF_URL), conf.get(CONF_API_KEY),
+                      str(conf.get(CONF_INPUTNODE)), payload)
+
+        track_point_in_time(hass, update_emoncms, time +
+                            timedelta(seconds=conf.get(
+                                CONF_SCAN_INTERVAL)))
+
+    update_emoncms(dt_util.utcnow())
+    return True
@@ -25,6 +25,8 @@ from homeassistant.components.light import (
 from homeassistant.components.http import (
    HomeAssistantView, HomeAssistantWSGI
 )
+# pylint: disable=unused-import
+from homeassistant.components.http import REQUIREMENTS   # noqa
 import homeassistant.helpers.config_validation as cv

 DOMAIN = 'emulated_hue'
@@ -75,7 +77,7 @@ def setup(hass, yaml_config):
        ssl_certificate=None,
        ssl_key=None,
        cors_origins=[],
-        approved_ips=[]
+        trusted_networks=[]
    )

    server.register_view(DescriptionXmlView(hass, config))
@@ -184,13 +184,13 @@ def setup(hass, base_config):
        load_platform(hass, 'alarm_control_panel', 'envisalink',
                      {CONF_PARTITIONS: _partitions,
                       CONF_CODE: _code,
-                       CONF_PANIC: _panic_type}, config)
+                       CONF_PANIC: _panic_type}, base_config)
        load_platform(hass, 'sensor', 'envisalink',
                      {CONF_PARTITIONS: _partitions,
-                       CONF_CODE: _code}, config)
+                       CONF_CODE: _code}, base_config)
    if _zones:
        load_platform(hass, 'binary_sensor', 'envisalink',
-                      {CONF_ZONES: _zones}, config)
+                      {CONF_ZONES: _zones}, base_config)

    return True

@@ -211,8 +211,14 @@ class IndexView(HomeAssistantView):

        panel_url = PANELS[panel]['url'] if panel != 'states' else ''

-        # auto login if no password was set
-        no_auth = 'false' if self.hass.config.api.api_password else 'true'
+        no_auth = 'true'
+        if self.hass.config.api.api_password:
+            # require password if set
+            no_auth = 'false'
+            if self.hass.wsgi.is_trusted_ip(
+                    self.hass.wsgi.get_real_ip(request)):
+                # bypass for trusted networks
+                no_auth = 'true'

        icons_url = '/static/mdi-{}.html'.format(FINGERPRINTS['mdi.html'])
        template = self.templates.get_template('index.html')
@@ -1,16 +1,17 @@
 """DO NOT MODIFY. Auto-generated by script/fingerprint_frontend."""

 FINGERPRINTS = {
-    "core.js": "78862c0984279b6876f594ffde45177c",
-    "frontend.html": "c1753e1ce530f978036742477c96d2fd",
-    "mdi.html": "6bd013a8252e19b3c1f1de52994cfbe4",
-    "panels/ha-panel-dev-event.html": "c4a5f70eece9f92616a65e8d26be803e",
-    "panels/ha-panel-dev-info.html": "34e2df1af32e60fffcafe7e008a92169",
-    "panels/ha-panel-dev-service.html": "07e83c6b7f79d78a59258f6dba477b54",
-    "panels/ha-panel-dev-state.html": "fd8eb946856b1346a87a51d0c86854ff",
-    "panels/ha-panel-dev-template.html": "7cff8a2ef3f44fdaf357a0d41696bf6d",
+    "core.js": "5ed5e063d66eb252b5b288738c9c2d16",
+    "frontend.html": "0a4c2c6e86a0a78c2ff3e03842de609d",
+    "mdi.html": "46a76f877ac9848899b8ed382427c16f",
+    "micromarkdown-js.html": "93b5ec4016f0bba585521cf4d18dec1a",
+    "panels/ha-panel-dev-event.html": "550bf85345c454274a40d15b2795a002",
+    "panels/ha-panel-dev-info.html": "ec613406ce7e20d93754233d55625c8a",
+    "panels/ha-panel-dev-service.html": "d33657c964041d3ebf114e90a922a15e",
+    "panels/ha-panel-dev-state.html": "65e5f791cc467561719bf591f1386054",
+    "panels/ha-panel-dev-template.html": "d23943fa0370f168714da407c90091a2",
    "panels/ha-panel-history.html": "efe1bcdd7733b09e55f4f965d171c295",
    "panels/ha-panel-iframe.html": "d920f0aa3c903680f2f8795e2255daab",
    "panels/ha-panel-logbook.html": "66108d82763359a218c9695f0553de40",
-    "panels/ha-panel-map.html": "af7d04aff7dd5479c5a0016bc8d4dd7d"
+    "panels/ha-panel-map.html": "49ab2d6f180f8bdea7cffaa66b8a5d3e"
 }
@@ -1,2 +1,2 @@
 <html><head><meta charset="UTF-8"></head><body><dom-module id="ha-panel-dev-info"><template><style include="iron-positioning ha-style">:host{background-color:#fff;-ms-user-select:initial;-webkit-user-select:initial;-moz-user-select:initial}.content{padding:24px}.about{text-align:center;line-height:2em}.version{@apply(--paper-font-headline)}.develop{@apply(--paper-font-subhead)}.about a{color:var(--dark-primary-color)}.error-log-intro{margin-top:16px;border-top:1px solid var(--light-primary-color);padding-top:16px}paper-icon-button{float:right}.error-log{@apply(--paper-font-code1)
-        clear: both;white-space:pre-wrap}</style><app-header-layout has-scrolling-region=""><app-header fixed=""><app-toolbar><ha-menu-button narrow="[[narrow]]" show-menu="[[showMenu]]"></ha-menu-button><div main-title="">About</div></app-toolbar></app-header><div class="content fit"><div class="about"><p class="version"><a href="https://home-assistant.io"><img src="/static/icons/favicon-192x192.png" height="192"></a><br>Home Assistant<br>[[hassVersion]]</p><p class="develop"><a href="https://home-assistant.io/developers/credits/" target="_blank">Developed by a bunch of awesome people.</a></p><p>Published under the MIT license<br>Source: <a href="https://github.com/balloob/home-assistant" target="_blank">server</a> — <a href="https://github.com/balloob/home-assistant-polymer" target="_blank">frontend-ui</a> — <a href="https://github.com/balloob/home-assistant-js" target="_blank">frontend-core</a></p><p>Built using <a href="https://www.python.org">Python 3</a>, <a href="https://www.polymer-project.org" target="_blank">Polymer [[polymerVersion]]</a>, <a href="https://optimizely.github.io/nuclear-js/" target="_blank">NuclearJS [[nuclearVersion]]</a><br>Icons by <a href="https://www.google.com/design/icons/" target="_blank">Google</a> and <a href="https://MaterialDesignIcons.com" target="_blank">MaterialDesignIcons.com</a>.</p></div><p class="error-log-intro">The following errors have been logged this session:<paper-icon-button icon="mdi:refresh" on-tap="refreshErrorLog"></paper-icon-button></p><div class="error-log">[[errorLog]]</div></div></app-header-layout></template></dom-module><script>Polymer({is:"ha-panel-dev-info",behaviors:[window.hassBehavior],properties:{hass:{type:Object},narrow:{type:Boolean,value:!1},showMenu:{type:Boolean,value:!1},hassVersion:{type:String,bindNuclear:function(r){return r.configGetters.serverVersion}},polymerVersion:{type:String,value:Polymer.version},nuclearVersion:{type:String,value:"1.3.0"},errorLog:{type:String,value:""}},attached:function(){this.refreshErrorLog()},refreshErrorLog:function(r){r&&r.preventDefault(),this.errorLog="Loading error log…",this.hass.errorLogActions.fetchErrorLog().then(function(r){this.errorLog=r||"No errors have been reported."}.bind(this))}})</script></body></html>
+        clear: both;white-space:pre-wrap}</style><app-header-layout has-scrolling-region=""><app-header fixed=""><app-toolbar><ha-menu-button narrow="[[narrow]]" show-menu="[[showMenu]]"></ha-menu-button><div main-title="">About</div></app-toolbar></app-header><div class="content fit"><div class="about"><p class="version"><a href="https://home-assistant.io"><img src="/static/icons/favicon-192x192.png" height="192"></a><br>Home Assistant<br>[[hassVersion]]</p><p>Path to configuration.yaml: [[hassConfigDir]]</p><p class="develop"><a href="https://home-assistant.io/developers/credits/" target="_blank">Developed by a bunch of awesome people.</a></p><p>Published under the MIT license<br>Source: <a href="https://github.com/home-assistant/home-assistant" target="_blank">server</a> — <a href="https://github.com/home-assistant/home-assistant-polymer" target="_blank">frontend-ui</a> — <a href="https://github.com/home-assistant/home-assistant-js" target="_blank">frontend-core</a></p><p>Built using <a href="https://www.python.org">Python 3</a>, <a href="https://www.polymer-project.org" target="_blank">Polymer [[polymerVersion]]</a>, <a href="https://optimizely.github.io/nuclear-js/" target="_blank">NuclearJS [[nuclearVersion]]</a><br>Icons by <a href="https://www.google.com/design/icons/" target="_blank">Google</a> and <a href="https://MaterialDesignIcons.com" target="_blank">MaterialDesignIcons.com</a>.</p></div><p class="error-log-intro">The following errors have been logged this session:<paper-icon-button icon="mdi:refresh" on-tap="refreshErrorLog"></paper-icon-button></p><div class="error-log">[[errorLog]]</div></div></app-header-layout></template></dom-module><script>Polymer({is:"ha-panel-dev-info",behaviors:[window.hassBehavior],properties:{hass:{type:Object},narrow:{type:Boolean,value:!1},showMenu:{type:Boolean,value:!1},hassVersion:{type:String,bindNuclear:function(r){return r.configGetters.serverVersion}},hassConfigDir:{type:String,bindNuclear:function(r){return r.configGetters.configDir}},polymerVersion:{type:String,value:Polymer.version},nuclearVersion:{type:String,value:"1.3.0"},errorLog:{type:String,value:""}},attached:function(){this.refreshErrorLog()},refreshErrorLog:function(r){r&&r.preventDefault(),this.errorLog="Loading error log…",this.hass.errorLogActions.fetchErrorLog().then(function(r){this.errorLog=r||"No errors have been reported."}.bind(this))}})</script></body></html>
@@ -22,15 +22,15 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    if discovery_info is None or zwave.NETWORK is None:
        return

-    node = zwave.NETWORK.nodes[discovery_info[zwave.ATTR_NODE_ID]]
-    value = node.values[discovery_info[zwave.ATTR_VALUE_ID]]
+    node = zwave.NETWORK.nodes[discovery_info[zwave.const.ATTR_NODE_ID]]
+    value = node.values[discovery_info[zwave.const.ATTR_VALUE_ID]]

-    if value.command_class != zwave.COMMAND_CLASS_SWITCH_BINARY and \
-       value.command_class != zwave.COMMAND_CLASS_BARRIER_OPERATOR:
+    if value.command_class != zwave.const.COMMAND_CLASS_SWITCH_BINARY and \
+       value.command_class != zwave.const.COMMAND_CLASS_BARRIER_OPERATOR:
        return
-    if value.type != zwave.TYPE_BOOL:
+    if value.type != zwave.const.TYPE_BOOL:
        return
-    if value.genre != zwave.GENRE_USER:
+    if value.genre != zwave.const.GENRE_USER:
        return

    value.set_change_verified(False)
@@ -4,9 +4,9 @@ Provides functionality to group entities.
 For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/group/
 """
+import asyncio
 import logging
 import os
-import threading

 import voluptuous as vol

@@ -15,10 +15,13 @@ from homeassistant.const import (
    ATTR_ENTITY_ID, CONF_ICON, CONF_NAME, STATE_CLOSED, STATE_HOME,
    STATE_NOT_HOME, STATE_OFF, STATE_ON, STATE_OPEN, STATE_LOCKED,
    STATE_UNLOCKED, STATE_UNKNOWN, ATTR_ASSUMED_STATE)
-from homeassistant.helpers.entity import Entity, generate_entity_id
+from homeassistant.core import callback
+from homeassistant.helpers.entity import Entity, async_generate_entity_id
 from homeassistant.helpers.entity_component import EntityComponent
-from homeassistant.helpers.event import track_state_change
+from homeassistant.helpers.event import async_track_state_change
 import homeassistant.helpers.config_validation as cv
+from homeassistant.util.async import (
+    run_callback_threadsafe, run_coroutine_threadsafe)

 DOMAIN = 'group'

@@ -87,7 +90,10 @@ def reload(hass):


 def expand_entity_ids(hass, entity_ids):
-    """Return entity_ids with group entity ids replaced by their members."""
+    """Return entity_ids with group entity ids replaced by their members.
+
+    Async friendly.
+    """
    found_ids = []

    for entity_id in entity_ids:
@@ -118,7 +124,10 @@ def expand_entity_ids(hass, entity_ids):


 def get_entity_ids(hass, entity_id, domain_filter=None):
-    """Get members of this group."""
+    """Get members of this group.
+
+    Async friendly.
+    """
    group = hass.states.get(entity_id)

    if not group or ATTR_ENTITY_ID not in group.attributes:
@@ -139,20 +148,19 @@ def setup(hass, config):
    """Setup all groups found definded in the configuration."""
    component = EntityComponent(_LOGGER, DOMAIN, hass)

-    success = _process_config(hass, config, component)
-
-    if not success:
-        return False
+    run_coroutine_threadsafe(
+        _async_process_config(hass, config, component), hass.loop).result()

    descriptions = conf_util.load_yaml_config_file(
        os.path.join(os.path.dirname(__file__), 'services.yaml'))

+    @asyncio.coroutine
    def reload_service_handler(service_call):
        """Remove all groups and load new ones from config."""
-        conf = component.prepare_reload()
+        conf = yield from component.async_prepare_reload()
        if conf is None:
            return
-        _process_config(hass, conf, component)
+        hass.loop.create_task(_async_process_config(hass, conf, component))

    hass.services.register(DOMAIN, SERVICE_RELOAD, reload_service_handler,
                           descriptions[DOMAIN][SERVICE_RELOAD],
@@ -161,48 +169,82 @@ def setup(hass, config):
    return True


-def _process_config(hass, config, component):
+@asyncio.coroutine
+def _async_process_config(hass, config, component):
    """Process group configuration."""
+    groups = []
    for object_id, conf in config.get(DOMAIN, {}).items():
        name = conf.get(CONF_NAME, object_id)
        entity_ids = conf.get(CONF_ENTITIES) or []
        icon = conf.get(CONF_ICON)
        view = conf.get(CONF_VIEW)

-        group = Group(hass, name, entity_ids, icon=icon, view=view,
-                      object_id=object_id)
-        component.add_entities((group,))
+        # This order is important as groups get a number based on creation
+        # order.
+        group = yield from Group.async_create_group(
+            hass, name, entity_ids, icon=icon, view=view, object_id=object_id)
+        groups.append(group)

-    return True
+    yield from component.async_add_entities(groups)


 class Group(Entity):
    """Track a group of entity ids."""

    # pylint: disable=too-many-instance-attributes, too-many-arguments
-    def __init__(self, hass, name, entity_ids=None, user_defined=True,
-                 icon=None, view=False, object_id=None):
-        """Initialize a group."""
+    def __init__(self, hass, name, order=None, user_defined=True, icon=None,
+                 view=False):
+        """Initialize a group.
+
+        This Object has factory function for creation.
+        """
        self.hass = hass
        self._name = name
        self._state = STATE_UNKNOWN
-        self._order = len(hass.states.entity_ids(DOMAIN))
        self._user_defined = user_defined
+        self._order = order
        self._icon = icon
        self._view = view
-        self.entity_id = generate_entity_id(
-            ENTITY_ID_FORMAT, object_id or name, hass=hass)
        self.tracking = []
        self.group_on = None
        self.group_off = None
        self._assumed_state = False
-        self._lock = threading.Lock()
-        self._unsub_state_changed = None
+        self._async_unsub_state_changed = None

+    @staticmethod
+    # pylint: disable=too-many-arguments
+    def create_group(hass, name, entity_ids=None, user_defined=True,
+                     icon=None, view=False, object_id=None):
+        """Initialize a group."""
+        return run_coroutine_threadsafe(
+            Group.async_create_group(hass, name, entity_ids, user_defined,
+                                     icon, view, object_id),
+            hass.loop).result()
+
+    @staticmethod
+    @asyncio.coroutine
+    # pylint: disable=too-many-arguments
+    def async_create_group(hass, name, entity_ids=None, user_defined=True,
+                           icon=None, view=False, object_id=None):
+        """Initialize a group.
+
+        This method must be run in the event loop.
+        """
+        group = Group(
+            hass, name,
+            order=len(hass.states.async_entity_ids(DOMAIN)),
+            user_defined=user_defined, icon=icon, view=view)
+
+        group.entity_id = async_generate_entity_id(
+            ENTITY_ID_FORMAT, object_id or name, hass=hass)
+
+        # run other async stuff
        if entity_ids is not None:
-            self.update_tracked_entity_ids(entity_ids)
+            yield from group.async_update_tracked_entity_ids(entity_ids)
        else:
-            self.update_ha_state(True)
+            yield from group.async_update_ha_state(True)
+
+        return group

    @property
    def should_poll(self):
@@ -249,40 +291,74 @@ class Group(Entity):

    def update_tracked_entity_ids(self, entity_ids):
        """Update the member entity IDs."""
-        self.stop()
+        run_coroutine_threadsafe(
+            self.async_update_tracked_entity_ids(entity_ids), self.hass.loop
+        ).result()
+
+    @asyncio.coroutine
+    def async_update_tracked_entity_ids(self, entity_ids):
+        """Update the member entity IDs.
+
+        This method must be run in the event loop.
+        """
+        yield from self.async_stop()
        self.tracking = tuple(ent_id.lower() for ent_id in entity_ids)
        self.group_on, self.group_off = None, None

-        self.update_ha_state(True)
-
-        self.start()
+        yield from self.async_update_ha_state(True)
+        self.async_start()

    def start(self):
        """Start tracking members."""
-        self._unsub_state_changed = track_state_change(
-            self.hass, self.tracking, self._state_changed_listener)
+        run_callback_threadsafe(self.hass.loop, self.async_start).result()
+
+    def async_start(self):
+        """Start tracking members.
+
+        This method must be run in the event loop.
+        """
+        self._async_unsub_state_changed = async_track_state_change(
+            self.hass, self.tracking, self._state_changed_listener
+        )

    def stop(self):
        """Unregister the group from Home Assistant."""
-        self.remove()
+        run_coroutine_threadsafe(self.async_stop(), self.hass.loop).result()

-    def update(self):
+    @asyncio.coroutine
+    def async_stop(self):
+        """Unregister the group from Home Assistant.
+
+        This method must be run in the event loop.
+        """
+        yield from self.async_remove()
+
+    @asyncio.coroutine
+    def async_update(self):
        """Query all members and determine current group state."""
        self._state = STATE_UNKNOWN
-        self._update_group_state()
+        self._async_update_group_state()

-    def remove(self):
-        """Remove group from HASS."""
-        super().remove()
+    @asyncio.coroutine
+    def async_remove(self):
+        """Remove group from HASS.

-        if self._unsub_state_changed:
-            self._unsub_state_changed()
-            self._unsub_state_changed = None
+        This method must be run in the event loop.
+        """
+        yield from super().async_remove()

+        if self._async_unsub_state_changed:
+            self._async_unsub_state_changed()
+            self._async_unsub_state_changed = None
+
+    @callback
    def _state_changed_listener(self, entity_id, old_state, new_state):
-        """Respond to a member state changing."""
-        self._update_group_state(new_state)
-        self.update_ha_state()
+        """Respond to a member state changing.
+
+        This method must be run in the event loop.
+        """
+        self._async_update_group_state(new_state)
+        self.hass.loop.create_task(self.async_update_ha_state())

    @property
    def _tracking_states(self):
@@ -297,62 +373,64 @@ class Group(Entity):

        return states

-    def _update_group_state(self, tr_state=None):
+    @callback
+    def _async_update_group_state(self, tr_state=None):
        """Update group state.

        Optionally you can provide the only state changed since last update
        allowing this method to take shortcuts.
+
+        This method must be run in the event loop.
        """
        # pylint: disable=too-many-branches
        # To store current states of group entities. Might not be needed.
-        with self._lock:
-            states = None
-            gr_state = self._state
-            gr_on = self.group_on
-            gr_off = self.group_off
+        states = None
+        gr_state = self._state
+        gr_on = self.group_on
+        gr_off = self.group_off

-            # We have not determined type of group yet
-            if gr_on is None:
-                if tr_state is None:
-                    states = self._tracking_states
+        # We have not determined type of group yet
+        if gr_on is None:
+            if tr_state is None:
+                states = self._tracking_states

-                    for state in states:
-                        gr_on, gr_off = \
-                            _get_group_on_off(state.state)
-                        if gr_on is not None:
-                            break
-                else:
-                    gr_on, gr_off = _get_group_on_off(tr_state.state)
+                for state in states:
+                    gr_on, gr_off = \
+                        _get_group_on_off(state.state)
+                    if gr_on is not None:
+                        break
+            else:
+                gr_on, gr_off = _get_group_on_off(tr_state.state)

-                if gr_on is not None:
-                    self.group_on, self.group_off = gr_on, gr_off
+            if gr_on is not None:
+                self.group_on, self.group_off = gr_on, gr_off

-            # We cannot determine state of the group
-            if gr_on is None:
-                return
+        # We cannot determine state of the group
+        if gr_on is None:
+            return

-            if tr_state is None or ((gr_state == gr_on and
-                                     tr_state.state == gr_off) or
-                                    tr_state.state not in (gr_on, gr_off)):
-                if states is None:
-                    states = self._tracking_states
+        if tr_state is None or ((gr_state == gr_on and
+                                 tr_state.state == gr_off) or
+                                tr_state.state not in (gr_on, gr_off)):
+            if states is None:
+                states = self._tracking_states

-                if any(state.state == gr_on for state in states):
-                    self._state = gr_on
-                else:
-                    self._state = gr_off
+            if any(state.state == gr_on for state in states):
+                self._state = gr_on
+            else:
+                self._state = gr_off

-            elif tr_state.state in (gr_on, gr_off):
-                self._state = tr_state.state
+        elif tr_state.state in (gr_on, gr_off):
+            self._state = tr_state.state

-            if tr_state is None or self._assumed_state and \
-               not tr_state.attributes.get(ATTR_ASSUMED_STATE):
-                if states is None:
-                    states = self._tracking_states
+        if tr_state is None or self._assumed_state and \
+           not tr_state.attributes.get(ATTR_ASSUMED_STATE):
+            if states is None:
+                states = self._tracking_states

-                self._assumed_state = any(
-                    state.attributes.get(ATTR_ASSUMED_STATE) for state
-                    in states)
+            self._assumed_state = any(
+                state.attributes.get(ATTR_ASSUMED_STATE) for state
+                in states)

-            elif tr_state.attributes.get(ATTR_ASSUMED_STATE):
-                self._assumed_state = True
+        elif tr_state.attributes.get(ATTR_ASSUMED_STATE):
+            self._assumed_state = True
@@ -7,16 +7,39 @@ https://home-assistant.io/components/history/
 from collections import defaultdict
 from datetime import timedelta
 from itertools import groupby
+import voluptuous as vol

+import homeassistant.helpers.config_validation as cv
 import homeassistant.util.dt as dt_util
 from homeassistant.components import recorder, script
 from homeassistant.components.frontend import register_built_in_panel
 from homeassistant.components.http import HomeAssistantView
+from homeassistant.const import ATTR_HIDDEN

 DOMAIN = 'history'
 DEPENDENCIES = ['recorder', 'http']

-SIGNIFICANT_DOMAINS = ('thermostat',)
+CONF_EXCLUDE = 'exclude'
+CONF_INCLUDE = 'include'
+CONF_ENTITIES = 'entities'
+CONF_DOMAINS = 'domains'
+
+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: vol.Schema({
+        CONF_EXCLUDE: vol.Schema({
+            vol.Optional(CONF_ENTITIES, default=[]): cv.entity_ids,
+            vol.Optional(CONF_DOMAINS, default=[]):
+                vol.All(cv.ensure_list, [cv.string])
+        }),
+        CONF_INCLUDE: vol.Schema({
+            vol.Optional(CONF_ENTITIES, default=[]): cv.entity_ids,
+            vol.Optional(CONF_DOMAINS, default=[]):
+                vol.All(cv.ensure_list, [cv.string])
+        })
+    }),
+}, extra=vol.ALLOW_EXTRA)
+
+SIGNIFICANT_DOMAINS = ('thermostat', 'climate')
 IGNORE_DOMAINS = ('zone', 'scene',)


@@ -32,7 +55,8 @@ def last_5_states(entity_id):
        ).order_by(states.state_id.desc()).limit(5))


-def get_significant_states(start_time, end_time=None, entity_id=None):
+def get_significant_states(start_time, end_time=None, entity_id=None,
+                           filters=None):
    """
    Return states changes during UTC period start_time - end_time.

@@ -40,25 +64,25 @@ def get_significant_states(start_time, end_time=None, entity_id=None):
    as well as all states from certain domains (for instance
    thermostat so that we get current temperature in our graphs).
    """
+    entity_ids = (entity_id.lower(), ) if entity_id is not None else None
    states = recorder.get_model('States')
    query = recorder.query('States').filter(
        (states.domain.in_(SIGNIFICANT_DOMAINS) |
         (states.last_changed == states.last_updated)) &
-        ((~states.domain.in_(IGNORE_DOMAINS)) &
-         (states.last_updated > start_time)))
+        (states.last_updated > start_time))
+    if filters:
+        query = filters.apply(query, entity_ids)

    if end_time is not None:
        query = query.filter(states.last_updated < end_time)

-    if entity_id is not None:
-        query = query.filter_by(entity_id=entity_id.lower())
-
    states = (
        state for state in recorder.execute(
            query.order_by(states.entity_id, states.last_updated))
-        if _is_significant(state))
+        if (_is_significant(state) and
+            not state.attributes.get(ATTR_HIDDEN, False)))

-    return states_to_json(states, start_time, entity_id)
+    return states_to_json(states, start_time, entity_id, filters)


 def state_changes_during_period(start_time, end_time=None, entity_id=None):
@@ -80,7 +104,7 @@ def state_changes_during_period(start_time, end_time=None, entity_id=None):
    return states_to_json(states, start_time, entity_id)


-def get_states(utc_point_in_time, entity_ids=None, run=None):
+def get_states(utc_point_in_time, entity_ids=None, run=None, filters=None):
    """Return the states at a specific point in time."""
    if run is None:
        run = recorder.run_information(utc_point_in_time)
@@ -96,12 +120,11 @@ def get_states(utc_point_in_time, entity_ids=None, run=None):
        func.max(states.state_id).label('max_state_id')
    ).filter(
        (states.created >= run.start) &
-        (states.created < utc_point_in_time)
-    )
-
-    if entity_ids is not None:
-        most_recent_state_ids = most_recent_state_ids.filter(
-            states.entity_id.in_(entity_ids))
+        (states.created < utc_point_in_time) &
+        (~states.domain.in_(IGNORE_DOMAINS)))
+    if filters:
+        most_recent_state_ids = filters.apply(most_recent_state_ids,
+                                              entity_ids)

    most_recent_state_ids = most_recent_state_ids.group_by(
        states.entity_id).subquery()
@@ -109,10 +132,12 @@ def get_states(utc_point_in_time, entity_ids=None, run=None):
    query = recorder.query('States').join(most_recent_state_ids, and_(
        states.state_id == most_recent_state_ids.c.max_state_id))

-    return recorder.execute(query)
+    for state in recorder.execute(query):
+        if not state.attributes.get(ATTR_HIDDEN, False):
+            yield state


-def states_to_json(states, start_time, entity_id):
+def states_to_json(states, start_time, entity_id, filters=None):
    """Convert SQL results into JSON friendly data structure.

    This takes our state list and turns it into a JSON friendly data
@@ -127,7 +152,7 @@ def states_to_json(states, start_time, entity_id):
    entity_ids = [entity_id] if entity_id is not None else None

    # Get the states at the start time
-    for state in get_states(start_time, entity_ids):
+    for state in get_states(start_time, entity_ids, filters=filters):
        state.last_changed = start_time
        state.last_updated = start_time
        result[state.entity_id].append(state)
@@ -140,16 +165,25 @@ def states_to_json(states, start_time, entity_id):

 def get_state(utc_point_in_time, entity_id, run=None):
    """Return a state at a specific point in time."""
-    states = get_states(utc_point_in_time, (entity_id,), run)
-
+    states = list(get_states(utc_point_in_time, (entity_id,), run))
    return states[0] if states else None


 # pylint: disable=unused-argument
 def setup(hass, config):
    """Setup the history hooks."""
-    hass.wsgi.register_view(Last5StatesView)
-    hass.wsgi.register_view(HistoryPeriodView)
+    filters = Filters()
+    exclude = config[DOMAIN].get(CONF_EXCLUDE)
+    if exclude:
+        filters.excluded_entities = exclude[CONF_ENTITIES]
+        filters.excluded_domains = exclude[CONF_DOMAINS]
+    include = config[DOMAIN].get(CONF_INCLUDE)
+    if include:
+        filters.included_entities = include[CONF_ENTITIES]
+        filters.included_domains = include[CONF_DOMAINS]
+
+    hass.wsgi.register_view(Last5StatesView(hass))
+    hass.wsgi.register_view(HistoryPeriodView(hass, filters))
    register_built_in_panel(hass, 'history', 'History', 'mdi:poll-box')

    return True
@@ -161,6 +195,10 @@ class Last5StatesView(HomeAssistantView):
    url = '/api/history/entity/<entity:entity_id>/recent_states'
    name = 'api:history:entity-recent-states'

+    def __init__(self, hass):
+        """Initilalize the history last 5 states view."""
+        super().__init__(hass)
+
    def get(self, request, entity_id):
        """Retrieve last 5 states of entity."""
        return self.json(last_5_states(entity_id))
@@ -173,6 +211,11 @@ class HistoryPeriodView(HomeAssistantView):
    name = 'api:history:view-period'
    extra_urls = ['/api/history/period/<datetime:datetime>']

+    def __init__(self, hass, filters):
+        """Initilalize the history period view."""
+        super().__init__(hass)
+        self.filters = filters
+
    def get(self, request, datetime=None):
        """Return history over a period of time."""
        one_day = timedelta(days=1)
@@ -185,8 +228,68 @@ class HistoryPeriodView(HomeAssistantView):
        end_time = start_time + one_day
        entity_id = request.args.get('filter_entity_id')

-        return self.json(
-            get_significant_states(start_time, end_time, entity_id).values())
+        return self.json(get_significant_states(
+            start_time, end_time, entity_id, self.filters).values())
+
+
+# pylint: disable=too-few-public-methods
+class Filters(object):
+    """Container for the configured include and exclude filters."""
+
+    def __init__(self):
+        """Initialise the include and exclude filters."""
+        self.excluded_entities = []
+        self.excluded_domains = []
+        self.included_entities = []
+        self.included_domains = []
+
+    def apply(self, query, entity_ids=None):
+        """Apply the include/exclude filter on domains and entities on query.
+
+        Following rules apply:
+        * only the include section is configured - just query the specified
+          entities or domains.
+        * only the exclude section is configured - filter the specified
+          entities and domains from all the entities in the system.
+        * if include and exclude is defined - select the entities specified in
+          the include and filter out the ones from the exclude list.
+        """
+        states = recorder.get_model('States')
+        # specific entities requested - do not in/exclude anything
+        if entity_ids is not None:
+            return query.filter(states.entity_id.in_(entity_ids))
+        query = query.filter(~states.domain.in_(IGNORE_DOMAINS))
+
+        filter_query = None
+        # filter if only excluded domain is configured
+        if self.excluded_domains and not self.included_domains:
+            filter_query = ~states.domain.in_(self.excluded_domains)
+            if self.included_entities:
+                filter_query &= states.entity_id.in_(self.included_entities)
+        # filter if only included domain is configured
+        elif not self.excluded_domains and self.included_domains:
+            filter_query = states.domain.in_(self.included_domains)
+            if self.included_entities:
+                filter_query |= states.entity_id.in_(self.included_entities)
+        # filter if included and excluded domain is configured
+        elif self.excluded_domains and self.included_domains:
+            filter_query = ~states.domain.in_(self.excluded_domains)
+            if self.included_entities:
+                filter_query &= (states.domain.in_(self.included_domains) |
+                                 states.entity_id.in_(self.included_entities))
+            else:
+                filter_query &= (states.domain.in_(self.included_domains) & ~
+                                 states.domain.in_(self.excluded_domains))
+        # no domain filter just included entities
+        elif not self.excluded_domains and not self.included_domains and \
+                self.included_entities:
+            filter_query = states.entity_id.in_(self.included_entities)
+        if filter_query is not None:
+            query = query.filter(filter_query)
+        # finally apply excluded entities filter if configured
+        if self.excluded_entities:
+            query = query.filter(~states.entity_id.in_(self.excluded_entities))
+        return query


 def _is_significant(state):
@@ -23,7 +23,7 @@ from homeassistant.config import load_yaml_config_file
 from homeassistant.util import Throttle

 DOMAIN = 'homematic'
-REQUIREMENTS = ["pyhomematic==0.1.14"]
+REQUIREMENTS = ["pyhomematic==0.1.16"]

 HOMEMATIC = None
 HOMEMATIC_LINK_DELAY = 0.5
@@ -52,17 +52,22 @@ SERVICE_VIRTUALKEY = 'virtualkey'
 SERVICE_SET_VALUE = 'set_value'

 HM_DEVICE_TYPES = {
-    DISCOVER_SWITCHES: ['Switch', 'SwitchPowermeter'],
-    DISCOVER_LIGHTS: ['Dimmer'],
-    DISCOVER_SENSORS: ['SwitchPowermeter', 'Motion', 'MotionV2',
-                       'RemoteMotion', 'ThermostatWall', 'AreaThermostat',
-                       'RotaryHandleSensor', 'WaterSensor', 'PowermeterGas',
-                       'LuxSensor', 'WeatherSensor', 'WeatherStation'],
-    DISCOVER_CLIMATE: ['Thermostat', 'ThermostatWall', 'MAXThermostat'],
-    DISCOVER_BINARY_SENSORS: ['ShutterContact', 'Smoke', 'SmokeV2', 'Motion',
-                              'MotionV2', 'RemoteMotion', 'WeatherSensor',
-                              'TiltSensor'],
-    DISCOVER_COVER: ['Blind']
+    DISCOVER_SWITCHES: [
+        'Switch', 'SwitchPowermeter', 'IOSwitch', 'IPSwitch',
+        'IPSwitchPowermeter', 'KeyMatic'],
+    DISCOVER_LIGHTS: ['Dimmer', 'KeyDimmer'],
+    DISCOVER_SENSORS: [
+        'SwitchPowermeter', 'Motion', 'MotionV2', 'RemoteMotion',
+        'ThermostatWall', 'AreaThermostat', 'RotaryHandleSensor',
+        'WaterSensor', 'PowermeterGas', 'LuxSensor', 'WeatherSensor',
+        'WeatherStation', 'ThermostatWall2', 'TemperatureDiffSensor',
+        'TemperatureSensor', 'CO2Sensor'],
+    DISCOVER_CLIMATE: [
+        'Thermostat', 'ThermostatWall', 'MAXThermostat', 'ThermostatWall2'],
+    DISCOVER_BINARY_SENSORS: [
+        'ShutterContact', 'Smoke', 'SmokeV2', 'Motion', 'MotionV2',
+        'RemoteMotion', 'WeatherSensor', 'TiltSensor', 'IPShutterContact'],
+    DISCOVER_COVER: ['Blind', 'KeyBlind']
 }

 HM_IGNORE_DISCOVERY_NODE = [
@@ -87,11 +92,12 @@ HM_PRESS_EVENTS = [
    'PRESS_SHORT',
    'PRESS_LONG',
    'PRESS_CONT',
-    'PRESS_LONG_RELEASE'
+    'PRESS_LONG_RELEASE',
+    'PRESS',
 ]

 HM_IMPULSE_EVENTS = [
-    'SEQUENCE_OK'
+    'SEQUENCE_OK',
 ]

 _LOGGER = logging.getLogger(__name__)
@@ -111,6 +117,15 @@ CONF_RESOLVENAMES = 'resolvenames'
 CONF_DELAY = 'delay'
 CONF_VARIABLES = 'variables'

+DEFAULT_LOCAL_IP = "0.0.0.0"
+DEFAULT_LOCAL_PORT = 0
+DEFAULT_RESOLVENAMES = False
+DEFAULT_REMOTE_PORT = 2001
+DEFAULT_USERNAME = "Admin"
+DEFAULT_PASSWORD = ""
+DEFAULT_VARIABLES = False
+DEFAULT_DELAY = 0.5
+

 DEVICE_SCHEMA = vol.Schema({
    vol.Required(CONF_PLATFORM): "homematic",
@@ -122,16 +137,16 @@ DEVICE_SCHEMA = vol.Schema({

 CONFIG_SCHEMA = vol.Schema({
    DOMAIN: vol.Schema({
-        vol.Required(CONF_LOCAL_IP): cv.string,
-        vol.Optional(CONF_LOCAL_PORT, default=8943): cv.port,
        vol.Required(CONF_REMOTE_IP): cv.string,
-        vol.Optional(CONF_REMOTE_PORT, default=2001): cv.port,
-        vol.Optional(CONF_RESOLVENAMES, default=False):
+        vol.Optional(CONF_LOCAL_IP, default=DEFAULT_LOCAL_IP): cv.string,
+        vol.Optional(CONF_LOCAL_PORT, default=DEFAULT_LOCAL_PORT): cv.port,
+        vol.Optional(CONF_REMOTE_PORT, default=DEFAULT_REMOTE_PORT): cv.port,
+        vol.Optional(CONF_RESOLVENAMES, default=DEFAULT_RESOLVENAMES):
            vol.In(CONF_RESOLVENAMES_OPTIONS),
-        vol.Optional(CONF_USERNAME, default="Admin"): cv.string,
-        vol.Optional(CONF_PASSWORD, default=""): cv.string,
-        vol.Optional(CONF_DELAY, default=0.5): vol.Coerce(float),
-        vol.Optional(CONF_VARIABLES, default=False): cv.boolean,
+        vol.Optional(CONF_USERNAME, default=DEFAULT_USERNAME): cv.string,
+        vol.Optional(CONF_PASSWORD, default=DEFAULT_PASSWORD): cv.string,
+        vol.Optional(CONF_DELAY, default=DEFAULT_DELAY): vol.Coerce(float),
+        vol.Optional(CONF_VARIABLES, default=DEFAULT_VARIABLES): cv.boolean,
    }),
 }, extra=vol.ALLOW_EXTRA)

@@ -323,99 +338,62 @@ def _get_devices(device_type, keys):
            metadata.update(device.SENSORNODE)
        elif device_type == DISCOVER_BINARY_SENSORS:
            metadata.update(device.BINARYNODE)
+        else:
+            metadata.update({None: device.ELEMENT})

-        params = _create_params_list(device, metadata, device_type)
-        if params:
+        if metadata:
            # Generate options for 1...n elements with 1...n params
-            for channel in range(1, device.ELEMENT + 1):
-                _LOGGER.debug("Handling %s:%i", key, channel)
-                if channel in params:
-                    for param in params[channel]:
-                        name = _create_ha_name(
-                            name=device.NAME,
-                            channel=channel,
-                            param=param
-                        )
-                        device_dict = {
-                            CONF_PLATFORM: "homematic",
-                            ATTR_ADDRESS: key,
-                            ATTR_NAME: name,
-                            ATTR_CHANNEL: channel
-                        }
-                        if param is not None:
-                            device_dict.update({ATTR_PARAM: param})
+            for param, channels in metadata.items():
+                if param in HM_IGNORE_DISCOVERY_NODE:
+                    continue

-                        # Add new device
-                        try:
-                            DEVICE_SCHEMA(device_dict)
-                            device_arr.append(device_dict)
-                        except vol.MultipleInvalid as err:
-                            _LOGGER.error("Invalid device config: %s",
-                                          str(err))
-                else:
-                    _LOGGER.debug("Channel %i not in params", channel)
+                # add devices
+                _LOGGER.debug("Handling %s: %s", param, channels)
+                for channel in channels:
+                    name = _create_ha_name(
+                        name=device.NAME,
+                        channel=channel,
+                        param=param,
+                        count=len(channels)
+                    )
+                    device_dict = {
+                        CONF_PLATFORM: "homematic",
+                        ATTR_ADDRESS: key,
+                        ATTR_NAME: name,
+                        ATTR_CHANNEL: channel
+                    }
+                    if param is not None:
+                        device_dict[ATTR_PARAM] = param
+
+                    # Add new device
+                    try:
+                        DEVICE_SCHEMA(device_dict)
+                        device_arr.append(device_dict)
+                    except vol.MultipleInvalid as err:
+                        _LOGGER.error("Invalid device config: %s",
+                                      str(err))
        else:
            _LOGGER.debug("Got no params for %s", key)
    _LOGGER.debug("%s autodiscovery: %s", device_type, str(device_arr))
    return device_arr


-def _create_params_list(hmdevice, metadata, device_type):
-    """Create a list from HMDevice with all possible parameters in config."""
-    params = {}
-    merge = False
-
-    # use merge?
-    if device_type in (DISCOVER_SENSORS, DISCOVER_BINARY_SENSORS):
-        merge = True
-
-    # Search in sensor and binary metadata per elements
-    for channel in range(1, hmdevice.ELEMENT + 1):
-        param_chan = []
-        for node, meta_chan in metadata.items():
-            try:
-                # Is this attribute ignored?
-                if node in HM_IGNORE_DISCOVERY_NODE:
-                    continue
-                if meta_chan == 'c' or meta_chan is None:
-                    # Only channel linked data
-                    param_chan.append(node)
-                elif channel == 1:
-                    # First channel can have other data channel
-                    param_chan.append(node)
-            except (TypeError, ValueError):
-                _LOGGER.error("Exception generating %s (%s)",
-                              hmdevice.ADDRESS, str(metadata))
-
-        # default parameter is merge is off
-        if len(param_chan) == 0 and not merge:
-            param_chan.append(None)
-
-        # Add to channel
-        if len(param_chan) > 0:
-            params.update({channel: param_chan})
-
-    _LOGGER.debug("Create param list for %s with: %s", hmdevice.ADDRESS,
-                  str(params))
-    return params
-
-
-def _create_ha_name(name, channel, param):
+def _create_ha_name(name, channel, param, count):
    """Generate a unique object name."""
    # HMDevice is a simple device
-    if channel == 1 and param is None:
+    if count == 1 and param is None:
        return name

    # Has multiple elements/channels
-    if channel > 1 and param is None:
+    if count > 1 and param is None:
        return "{} {}".format(name, channel)

    # With multiple param first elements
-    if channel == 1 and param is not None:
+    if count == 1 and param is not None:
        return "{} {}".format(name, param)

    # Multiple param on object with multiple elements
-    if channel > 1 and param is not None:
+    if count > 1 and param is not None:
        return "{} {} {}".format(name, channel, param)


@@ -484,12 +462,12 @@ def _hm_service_virtualkey(call):
    hmdevice = HOMEMATIC.devices.get(address)

    # if param exists for this device
-    if param not in hmdevice.ACTIONNODE:
+    if hmdevice is None or param not in hmdevice.ACTIONNODE:
        _LOGGER.error("%s not datapoint in hm device %s", param, address)
        return

    # channel exists?
-    if channel > hmdevice.ELEMENT:
+    if channel in hmdevice.ACTIONNODE[param]:
        _LOGGER.error("%i is not a channel in hm device %s", channel, address)
        return

@@ -623,12 +601,6 @@ class HMDevice(Entity):
        if self._state:
            self._state = self._state.upper()

-        # Generate name
-        if not self._name:
-            self._name = _create_ha_name(name=self._address,
-                                         channel=self._channel,
-                                         param=self._state)
-
    @property
    def should_poll(self):
        """Return false. Homematic states are pushed by the XML RPC Server."""
@@ -743,19 +715,22 @@ class HMDevice(Entity):
                         self._hmdevice.ATTRIBUTENODE,
                         self._hmdevice.WRITENODE, self._hmdevice.EVENTNODE,
                         self._hmdevice.ACTIONNODE):
-            for node, channel in metadata.items():
+            for node, channels in metadata.items():
                # Data is needed for this instance
                if node in self._data:
                    # chan is current channel
-                    if channel == 'c' or channel is None:
+                    if len(channels) == 1:
+                        channel = channels[0]
+                    else:
                        channel = self._channel
+
                    # Prepare for subscription
                    try:
                        if int(channel) >= 0:
                            channels_to_sub.update({int(channel): True})
                    except (ValueError, TypeError):
-                        _LOGGER("Invalid channel in metadata from %s",
-                                self._name)
+                        _LOGGER.error("Invalid channel in metadata from %s",
+                                      self._name)

        # Set callbacks
        for channel in channels_to_sub:
@@ -11,32 +11,36 @@ import mimetypes
 import threading
 import re
 import ssl
+from ipaddress import ip_address, ip_network
+
 import voluptuous as vol

 import homeassistant.remote as rem
 from homeassistant import util
 from homeassistant.const import (
    SERVER_PORT, HTTP_HEADER_HA_AUTH, HTTP_HEADER_CACHE_CONTROL,
-    HTTP_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
+    HTTP_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN, CONTENT_TYPE_JSON,
    HTTP_HEADER_ACCESS_CONTROL_ALLOW_HEADERS, ALLOWED_CORS_HEADERS,
    EVENT_HOMEASSISTANT_STOP, EVENT_HOMEASSISTANT_START)
 from homeassistant.core import split_entity_id
 import homeassistant.util.dt as dt_util
 import homeassistant.helpers.config_validation as cv
+from homeassistant.components import persistent_notification

 DOMAIN = 'http'
-REQUIREMENTS = ('cherrypy==8.1.0', 'static3==0.7.0', 'Werkzeug==0.11.11')
+REQUIREMENTS = ('cherrypy==8.1.2', 'static3==0.7.0', 'Werkzeug==0.11.11')

 CONF_API_PASSWORD = 'api_password'
-CONF_APPROVED_IPS = 'approved_ips'
 CONF_SERVER_HOST = 'server_host'
 CONF_SERVER_PORT = 'server_port'
 CONF_DEVELOPMENT = 'development'
 CONF_SSL_CERTIFICATE = 'ssl_certificate'
 CONF_SSL_KEY = 'ssl_key'
 CONF_CORS_ORIGINS = 'cors_allowed_origins'
+CONF_TRUSTED_NETWORKS = 'trusted_networks'

 DATA_API_PASSWORD = 'api_password'
+NOTIFICATION_ID_LOGIN = 'http-login'

 # TLS configuation follows the best-practice guidelines specified here:
 # https://wiki.mozilla.org/Security/Server_Side_TLS
@@ -73,7 +77,8 @@ CONFIG_SCHEMA = vol.Schema({
        vol.Optional(CONF_SSL_CERTIFICATE): cv.isfile,
        vol.Optional(CONF_SSL_KEY): cv.isfile,
        vol.Optional(CONF_CORS_ORIGINS): vol.All(cv.ensure_list, [cv.string]),
-        vol.Optional(CONF_APPROVED_IPS): vol.All(cv.ensure_list, [cv.string])
+        vol.Optional(CONF_TRUSTED_NETWORKS):
+            vol.All(cv.ensure_list, [ip_network])
    }),
 }, extra=vol.ALLOW_EXTRA)

@@ -106,11 +111,13 @@ def setup(hass, config):
    api_password = util.convert(conf.get(CONF_API_PASSWORD), str)
    server_host = conf.get(CONF_SERVER_HOST, '0.0.0.0')
    server_port = conf.get(CONF_SERVER_PORT, SERVER_PORT)
-    development = str(conf.get(CONF_DEVELOPMENT, "")) == "1"
+    development = str(conf.get(CONF_DEVELOPMENT, '')) == '1'
    ssl_certificate = conf.get(CONF_SSL_CERTIFICATE)
    ssl_key = conf.get(CONF_SSL_KEY)
    cors_origins = conf.get(CONF_CORS_ORIGINS, [])
-    approved_ips = conf.get(CONF_APPROVED_IPS, [])
+    trusted_networks = [
+        ip_network(trusted_network)
+        for trusted_network in conf.get(CONF_TRUSTED_NETWORKS, [])]

    server = HomeAssistantWSGI(
        hass,
@@ -121,7 +128,7 @@ def setup(hass, config):
        ssl_certificate=ssl_certificate,
        ssl_key=ssl_key,
        cors_origins=cors_origins,
-        approved_ips=approved_ips
+        trusted_networks=trusted_networks
    )

    def start_wsgi_server(event):
@@ -254,7 +261,7 @@ class HomeAssistantWSGI(object):

    def __init__(self, hass, development, api_password, ssl_certificate,
                 ssl_key, server_host, server_port, cors_origins,
-                 approved_ips):
+                 trusted_networks):
        """Initilalize the WSGI Home Assistant server."""
        from werkzeug.wrappers import Response

@@ -273,7 +280,7 @@ class HomeAssistantWSGI(object):
        self.server_host = server_host
        self.server_port = server_port
        self.cors_origins = cors_origins
-        self.approved_ips = approved_ips
+        self.trusted_networks = trusted_networks
        self.event_forwarder = None
        self.server = None

@@ -365,8 +372,8 @@ class HomeAssistantWSGI(object):
            context.load_cert_chain(self.ssl_certificate, self.ssl_key)
            self.server.ssl_adapter = ContextSSLAdapter(context)

-        threading.Thread(target=self.server.start, daemon=True,
-                         name='WSGI-server').start()
+        threading.Thread(
+            target=self.server.start, daemon=True, name='WSGI-server').start()

    def stop(self):
        """Stop the wsgi server."""
@@ -391,10 +398,10 @@ class HomeAssistantWSGI(object):
                resp = ex.get_response(request.environ)
                if request.accept_mimetypes.accept_json:
                    resp.data = json.dumps({
-                        "result": "error",
-                        "message": str(ex),
+                        'result': 'error',
+                        'message': str(ex),
                    })
-                    resp.mimetype = "application/json"
+                    resp.mimetype = CONTENT_TYPE_JSON
                return resp

    def base_app(self, environ, start_response):
@@ -403,11 +410,11 @@ class HomeAssistantWSGI(object):
        response = self.dispatch_request(request)

        if self.cors_origins:
-            cors_check = (environ.get("HTTP_ORIGIN") in self.cors_origins)
+            cors_check = (environ.get('HTTP_ORIGIN') in self.cors_origins)
            cors_headers = ", ".join(ALLOWED_CORS_HEADERS)
            if cors_check:
                response.headers[HTTP_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN] = \
-                    environ.get("HTTP_ORIGIN")
+                    environ.get('HTTP_ORIGIN')
                response.headers[HTTP_HEADER_ACCESS_CONTROL_ALLOW_HEADERS] = \
                    cors_headers

@@ -425,9 +432,22 @@ class HomeAssistantWSGI(object):
        # Strip out any cachebusting MD5 fingerprints
        fingerprinted = _FINGERPRINT.match(environ.get('PATH_INFO', ''))
        if fingerprinted:
-            environ['PATH_INFO'] = "{}.{}".format(*fingerprinted.groups())
+            environ['PATH_INFO'] = '{}.{}'.format(*fingerprinted.groups())
        return app(environ, start_response)

+    @staticmethod
+    def get_real_ip(request):
+        """Return the clients correct ip address, even in proxied setups."""
+        if request.access_route:
+            return request.access_route[-1]
+        else:
+            return request.remote_addr
+
+    def is_trusted_ip(self, remote_addr):
+        """Match an ip address against trusted CIDR networks."""
+        return any(ip_address(remote_addr) in trusted_network
+                   for trusted_network in self.hass.wsgi.trusted_networks)
+

 class HomeAssistantView(object):
    """Base view for all views."""
@@ -468,13 +488,15 @@ class HomeAssistantView(object):
        except AttributeError:
            raise MethodNotAllowed

+        remote_addr = HomeAssistantWSGI.get_real_ip(request)
+
        # Auth code verbose on purpose
        authenticated = False

        if self.hass.wsgi.api_password is None:
            authenticated = True

-        elif request.remote_addr in self.hass.wsgi.approved_ips:
+        elif self.hass.wsgi.is_trusted_ip(remote_addr):
            authenticated = True

        elif hmac.compare_digest(request.headers.get(HTTP_HEADER_HA_AUTH, ''),
@@ -488,13 +510,17 @@ class HomeAssistantView(object):

        if self.requires_auth and not authenticated:
            _LOGGER.warning('Login attempt or request with an invalid '
-                            'password from %s', request.remote_addr)
+                            'password from %s', remote_addr)
+            persistent_notification.create(
+                self.hass,
+                'Invalid password used from {}'.format(remote_addr),
+                'Login attempt failed', NOTIFICATION_ID_LOGIN)
            raise Unauthorized()

        request.authenticated = authenticated

        _LOGGER.info('Serving %s to %s (auth: %s)',
-                     request.path, request.remote_addr, authenticated)
+                     request.path, remote_addr, authenticated)

        result = handler(request, **values)

@@ -512,12 +538,9 @@ class HomeAssistantView(object):
    def json(self, result, status_code=200):
        """Return a JSON response."""
        msg = json.dumps(
-            result,
-            sort_keys=True,
-            cls=rem.JSONEncoder
-        ).encode('UTF-8')
-        return self.Response(msg, mimetype="application/json",
-                             status=status_code)
+            result, sort_keys=True, cls=rem.JSONEncoder).encode('UTF-8')
+        return self.Response(
+            msg, mimetype=CONTENT_TYPE_JSON, status=status_code)

    def json_message(self, error, status_code=200):
        """Return a JSON message response."""
--- a/Show More
+++ b/Show More