Merge pull request #10630 from home-assistant/release-0-58

0.58
Implement entity and domain exclude/include for Alexa (#10647 )
2017-11-17 22:27:35 -08:00 · 2017-11-17 22:00:11 -08:00 · 2017-11-17 22:00:11 -08:00 · 2017-11-17 22:00:10 -08:00 · 2017-11-17 22:00:10 -08:00 · 2017-11-17 22:00:10 -08:00
580 changed files with 17815 additions and 10484 deletions
@@ -71,6 +71,9 @@ omit =
    homeassistant/components/envisalink.py
    homeassistant/components/*/envisalink.py

+    homeassistant/components/gc100.py
+    homeassistant/components/*/gc100.py
+
    homeassistant/components/google.py
    homeassistant/components/*/google.py

@@ -107,6 +110,9 @@ omit =
    homeassistant/components/lametric.py
    homeassistant/components/*/lametric.py

+    homeassistant/components/linode.py
+    homeassistant/components/*/linode.py
+
    homeassistant/components/lutron.py
    homeassistant/components/*/lutron.py

@@ -272,8 +278,10 @@ omit =
    homeassistant/components/camera/mjpeg.py
    homeassistant/components/camera/rpi_camera.py
    homeassistant/components/camera/onvif.py
+    homeassistant/components/camera/ring.py
    homeassistant/components/camera/synology.py
    homeassistant/components/camera/yi.py
+    homeassistant/components/climate/ephember.py
    homeassistant/components/climate/eq3btsmart.py
    homeassistant/components/climate/flexit.py
    homeassistant/components/climate/heatmiser.py
@@ -301,6 +309,7 @@ omit =
    homeassistant/components/device_tracker/cisco_ios.py
    homeassistant/components/device_tracker/fritz.py
    homeassistant/components/device_tracker/gpslogger.py
+    homeassistant/components/device_tracker/hitron_coda.py
    homeassistant/components/device_tracker/huawei_router.py
    homeassistant/components/device_tracker/icloud.py
    homeassistant/components/device_tracker/keenetic_ndms2.py
@@ -317,6 +326,7 @@ omit =
    homeassistant/components/device_tracker/thomson.py
    homeassistant/components/device_tracker/tomato.py
    homeassistant/components/device_tracker/tado.py
+    homeassistant/components/device_tracker/tile.py
    homeassistant/components/device_tracker/tplink.py
    homeassistant/components/device_tracker/trackr.py
    homeassistant/components/device_tracker/ubus.py
@@ -324,6 +334,7 @@ omit =
    homeassistant/components/emoncms_history.py
    homeassistant/components/emulated_hue/upnp.py
    homeassistant/components/fan/mqtt.py
+    homeassistant/components/fan/xiaomi_miio.py
    homeassistant/components/feedreader.py
    homeassistant/components/foursquare.py
    homeassistant/components/ifttt.py
@@ -411,6 +422,7 @@ omit =
    homeassistant/components/notify/aws_sns.py
    homeassistant/components/notify/aws_sqs.py
    homeassistant/components/notify/ciscospark.py
+    homeassistant/components/notify/clickatell.py
    homeassistant/components/notify/clicksend.py
    homeassistant/components/notify/clicksend_tts.py
    homeassistant/components/notify/discord.py
@@ -444,8 +456,10 @@ omit =
    homeassistant/components/notify/telstra.py
    homeassistant/components/notify/twitter.py
    homeassistant/components/notify/xmpp.py
+    homeassistant/components/notify/yessssms.py
    homeassistant/components/nuimo_controller.py
    homeassistant/components/prometheus.py
+    homeassistant/components/remember_the_milk/__init__.py
    homeassistant/components/remote/harmony.py
    homeassistant/components/remote/itach.py
    homeassistant/components/scene/hunterdouglas_powerview.py
@@ -462,7 +476,6 @@ omit =
    homeassistant/components/sensor/broadlink.py
    homeassistant/components/sensor/buienradar.py
    homeassistant/components/sensor/citybikes.py
-    homeassistant/components/sensor/coinmarketcap.py
    homeassistant/components/sensor/cert_expiry.py
    homeassistant/components/sensor/comed_hourly_pricing.py
    homeassistant/components/sensor/cpuspeed.py
@@ -470,6 +483,7 @@ omit =
    homeassistant/components/sensor/cups.py
    homeassistant/components/sensor/currencylayer.py
    homeassistant/components/sensor/darksky.py
+    homeassistant/components/sensor/deluge.py
    homeassistant/components/sensor/deutsche_bahn.py
    homeassistant/components/sensor/dht.py
    homeassistant/components/sensor/dnsip.py
@@ -497,17 +511,19 @@ omit =
    homeassistant/components/sensor/gpsd.py
    homeassistant/components/sensor/gtfs.py
    homeassistant/components/sensor/haveibeenpwned.py
-    homeassistant/components/sensor/hddtemp.py
    homeassistant/components/sensor/hp_ilo.py
    homeassistant/components/sensor/htu21d.py
    homeassistant/components/sensor/hydroquebec.py
    homeassistant/components/sensor/imap.py
    homeassistant/components/sensor/imap_email_content.py
    homeassistant/components/sensor/influxdb.py
+    homeassistant/components/sensor/irish_rail_transport.py
    homeassistant/components/sensor/kwb.py
+    homeassistant/components/sensor/lacrosse.py
    homeassistant/components/sensor/lastfm.py
    homeassistant/components/sensor/linux_battery.py
    homeassistant/components/sensor/loopenergy.py
+    homeassistant/components/sensor/luftdaten.py
    homeassistant/components/sensor/lyft.py
    homeassistant/components/sensor/metoffice.py
    homeassistant/components/sensor/miflora.py
@@ -515,6 +531,7 @@ omit =
    homeassistant/components/sensor/mopar.py
    homeassistant/components/sensor/mqtt_room.py
    homeassistant/components/sensor/mvglive.py
+    homeassistant/components/sensor/nederlandse_spoorwegen.py
    homeassistant/components/sensor/netdata.py
    homeassistant/components/sensor/neurio_energy.py
    homeassistant/components/sensor/nut.py
@@ -531,6 +548,7 @@ omit =
    homeassistant/components/sensor/pocketcasts.py
    homeassistant/components/sensor/pushbullet.py
    homeassistant/components/sensor/pvoutput.py
+    homeassistant/components/sensor/pyload.py
    homeassistant/components/sensor/qnap.py
    homeassistant/components/sensor/radarr.py
    homeassistant/components/sensor/ripple.py
@@ -551,6 +569,7 @@ omit =
    homeassistant/components/sensor/swiss_public_transport.py
    homeassistant/components/sensor/synologydsm.py
    homeassistant/components/sensor/systemmonitor.py
+    homeassistant/components/sensor/sytadin.py
    homeassistant/components/sensor/tank_utility.py
    homeassistant/components/sensor/ted5000.py
    homeassistant/components/sensor/temper.py
@@ -564,7 +583,9 @@ omit =
    homeassistant/components/sensor/upnp.py
    homeassistant/components/sensor/ups.py
    homeassistant/components/sensor/vasttrafik.py
+    homeassistant/components/sensor/viaggiatreno.py
    homeassistant/components/sensor/waqi.py
+    homeassistant/components/sensor/whois.py
    homeassistant/components/sensor/worldtidesinfo.py
    homeassistant/components/sensor/worxlandroid.py
    homeassistant/components/sensor/xbox_live.py
@@ -576,6 +597,7 @@ omit =
    homeassistant/components/switch/anel_pwrctrl.py
    homeassistant/components/switch/arest.py
    homeassistant/components/switch/broadlink.py
+    homeassistant/components/switch/deluge.py
    homeassistant/components/switch/digitalloggers.py
    homeassistant/components/switch/dlink.py
    homeassistant/components/switch/edimax.py
@@ -588,17 +610,19 @@ omit =
    homeassistant/components/switch/orvibo.py
    homeassistant/components/switch/pilight.py
    homeassistant/components/switch/pulseaudio_loopback.py
+    homeassistant/components/switch/rainbird.py
    homeassistant/components/switch/rainmachine.py
    homeassistant/components/switch/rest.py
    homeassistant/components/switch/rpi_rf.py
+    homeassistant/components/switch/snmp.py
    homeassistant/components/switch/tplink.py
    homeassistant/components/switch/telnet.py
    homeassistant/components/switch/transmission.py
-    homeassistant/components/switch/wake_on_lan.py
    homeassistant/components/switch/xiaomi_miio.py
    homeassistant/components/telegram_bot/*
    homeassistant/components/thingspeak.py
    homeassistant/components/tts/amazon_polly.py
+    homeassistant/components/tts/microsoft.py
    homeassistant/components/tts/picotts.py
    homeassistant/components/vacuum/roomba.py
    homeassistant/components/weather/bom.py
@@ -1,3 +0,0 @@
-[submodule "homeassistant/components/frontend/www_static/home-assistant-polymer"]
-	path = homeassistant/components/frontend/www_static/home-assistant-polymer
-	url = https://github.com/home-assistant/home-assistant-polymer.git
@@ -41,6 +41,7 @@ homeassistant/components/*/zwave.py @home-assistant/z-wave
 # Indiviudal components
 homeassistant/components/alarm_control_panel/egardia.py @jeroenterheerdt
 homeassistant/components/camera/yi.py @bachya
+homeassistant/components/climate/ephember.py @ttroy50
 homeassistant/components/climate/eq3btsmart.py @rytilahti
 homeassistant/components/climate/sensibo.py @andrey-git
 homeassistant/components/cover/template.py @PhracturedBlue
@@ -50,17 +51,25 @@ homeassistant/components/light/tplink.py @rytilahti
 homeassistant/components/light/yeelight.py @rytilahti
 homeassistant/components/media_player/kodi.py @armills
 homeassistant/components/media_player/monoprice.py @etsinko
+homeassistant/components/media_player/yamaha_musiccast.py @jalmeroth
 homeassistant/components/sensor/airvisual.py @bachya
+homeassistant/components/sensor/irish_rail_transport.py @ttroy50
 homeassistant/components/sensor/miflora.py @danielhiversen
+homeassistant/components/sensor/sytadin.py @gautric
 homeassistant/components/sensor/tibber.py @danielhiversen
 homeassistant/components/sensor/waqi.py @andrey-git
 homeassistant/components/switch/rainmachine.py @bachya
 homeassistant/components/switch/tplink.py @rytilahti
+homeassistant/components/xiaomi_aqara.py @danielhiversen @syssi

-homeassistant/components/*/axis.py @Kane610
 homeassistant/components/*/broadlink.py @danielhiversen
 homeassistant/components/*/rfxtrx.py @danielhiversen
+homeassistant/components/velux.py @Julius2342
+homeassistant/components/*/velux.py @Julius2342
+homeassistant/components/knx.py @Julius2342
+homeassistant/components/*/knx.py @Julius2342
 homeassistant/components/tesla.py @zabuldon
 homeassistant/components/*/tesla.py @zabuldon
-homeassistant/components/*/xiaomi_aqara.py @danielhiversen
-homeassistant/components/*/xiaomi_miio.py @rytilahti
+homeassistant/components/*/tradfri.py @ggravlingen
+homeassistant/components/*/xiaomi_aqara.py @danielhiversen @syssi
+homeassistant/components/*/xiaomi_miio.py @rytilahti @syssi
@@ -3,7 +3,7 @@
 # This way, the development image and the production image are kept in sync.

 FROM python:3.6
-MAINTAINER Paulus Schoutsen <Paulus@PaulusSchoutsen.nl>
+LABEL maintainer="Paulus Schoutsen <Paulus@PaulusSchoutsen.nl>"

 # Uncomment any of the following lines to disable the installation.
 #ENV INSTALL_TELLSTICK no
@@ -1,5 +1,4 @@
 include README.rst
 include LICENSE.md
 graft homeassistant
-prune homeassistant/components/frontend/www_static/home-assistant-polymer
 recursive-exclude * *.py[co]
@@ -19,15 +19,13 @@
 #
 import sys
 import os
-from os.path import relpath
 import inspect
-from homeassistant.const import (__version__, __short_version__, PROJECT_NAME,
-                                 PROJECT_LONG_DESCRIPTION,
-                                 PROJECT_COPYRIGHT, PROJECT_AUTHOR,
-                                 PROJECT_GITHUB_USERNAME,
-                                 PROJECT_GITHUB_REPOSITORY,
-                                 GITHUB_PATH, GITHUB_URL)

+from homeassistant.const import __version__, __short_version__
+from setup import (
+    PROJECT_NAME, PROJECT_LONG_DESCRIPTION, PROJECT_COPYRIGHT, PROJECT_AUTHOR,
+    PROJECT_GITHUB_USERNAME, PROJECT_GITHUB_REPOSITORY, GITHUB_PATH,
+    GITHUB_URL)

 sys.path.insert(0, os.path.abspath('_ext'))
 sys.path.insert(0, os.path.abspath('../homeassistant'))
@@ -87,9 +85,7 @@ edit_on_github_src_path = 'docs/source/'


 def linkcode_resolve(domain, info):
-    """
-    Determine the URL corresponding to Python object
-    """
+    """Determine the URL corresponding to Python object."""
    if domain != 'py':
        return None
    modname = info['module']
@@ -30,8 +30,8 @@ ERROR_LOG_FILENAME = 'home-assistant.log'
 DATA_LOGGING = 'logging'

 FIRST_INIT_COMPONENT = set((
-    'recorder', 'mqtt', 'mqtt_eventstream', 'logger', 'introduction',
-    'frontend', 'history'))
+    'system_log', 'recorder', 'mqtt', 'mqtt_eventstream', 'logger',
+    'introduction', 'frontend', 'history'))


 def from_config_dict(config: Dict[str, Any],
@@ -88,7 +88,7 @@ def async_from_config_dict(config: Dict[str, Any],
    if sys.version_info[:2] < (3, 5):
        _LOGGER.warning(
            'Python 3.4 support has been deprecated and will be removed in '
-            'the begining of 2018. Please upgrade Python or your operating '
+            'the beginning of 2018. Please upgrade Python or your operating '
            'system. More info: https://home-assistant.io/blog/2017/10/06/'
            'deprecating-python-3.4-support/'
        )
@@ -21,7 +21,7 @@ from homeassistant.helpers import discovery
 from homeassistant.helpers.entity import Entity
 from requests.exceptions import HTTPError, ConnectTimeout

-REQUIREMENTS = ['abodepy==0.12.1']
+REQUIREMENTS = ['abodepy==0.12.2']

 _LOGGER = logging.getLogger(__name__)

@@ -1,65 +1,61 @@
-alarm_disarm:
-  description: Send the alarm the command for disarm
+# Describes the format for available alarm control panel services

+alarm_disarm:
+  description: Send the alarm the command for disarm.
  fields:
    entity_id:
-      description: Name of alarm control panel to disarm
+      description: Name of alarm control panel to disarm.
      example: 'alarm_control_panel.downstairs'
    code:
-      description: An optional code to disarm the alarm control panel with
+      description: An optional code to disarm the alarm control panel with.
      example: 1234

 alarm_arm_home:
-  description: Send the alarm the command for arm home
-
+  description: Send the alarm the command for arm home.
  fields:
    entity_id:
-      description: Name of alarm control panel to arm home
+      description: Name of alarm control panel to arm home.
      example: 'alarm_control_panel.downstairs'
    code:
-      description: An optional code to arm home the alarm control panel with
+      description: An optional code to arm home the alarm control panel with.
      example: 1234

 alarm_arm_away:
-  description: Send the alarm the command for arm away
-
+  description: Send the alarm the command for arm away.
  fields:
    entity_id:
-      description: Name of alarm control panel to arm away
+      description: Name of alarm control panel to arm away.
      example: 'alarm_control_panel.downstairs'
    code:
-      description: An optional code to arm away the alarm control panel with
+      description: An optional code to arm away the alarm control panel with.
      example: 1234

 alarm_arm_night:
-  description: Send the alarm the command for arm night
-
+  description: Send the alarm the command for arm night.
  fields:
    entity_id:
-      description: Name of alarm control panel to arm night
+      description: Name of alarm control panel to arm night.
      example: 'alarm_control_panel.downstairs'
    code:
-      description: An optional code to arm night the alarm control panel with
+      description: An optional code to arm night the alarm control panel with.
      example: 1234

 alarm_trigger:
-  description: Send the alarm the command for trigger
-
+  description: Send the alarm the command for trigger.
  fields:
    entity_id:
-      description: Name of alarm control panel to trigger
+      description: Name of alarm control panel to trigger.
      example: 'alarm_control_panel.downstairs'
    code:
-      description: An optional code to trigger the alarm control panel with
+      description: An optional code to trigger the alarm control panel with.
      example: 1234

 envisalink_alarm_keypress:
-  description: Send custom keypresses to the alarm
-
+  description: Send custom keypresses to the alarm.
  fields:
    entity_id:
-      description: Name of the alarm control panel to trigger
+      description: Name of the alarm control panel to trigger.
      example: 'alarm_control_panel.downstairs'
    keypress:
-      description: 'String to send to the alarm panel (1-6 characters)'
+      description: 'String to send to the alarm panel (1-6 characters).'
      example: '*71'
@@ -34,10 +34,8 @@ def async_setup_platform(hass, config, async_add_devices,
            discovery_info[ATTR_DISCOVER_AREAS] is None):
        return

-    devices = [SpcAlarm(hass=hass,
-                        area_id=area['id'],
-                        name=area['name'],
-                        state=_get_alarm_state(area['mode']))
+    api = hass.data[DATA_API]
+    devices = [SpcAlarm(api, area)
               for area in discovery_info[ATTR_DISCOVER_AREAS]]

    async_add_devices(devices)
@@ -46,21 +44,29 @@ def async_setup_platform(hass, config, async_add_devices,
 class SpcAlarm(alarm.AlarmControlPanel):
    """Represents the SPC alarm panel."""

-    def __init__(self, hass, area_id, name, state):
+    def __init__(self, api, area):
        """Initialize the SPC alarm panel."""
-        self._hass = hass
-        self._area_id = area_id
-        self._name = name
-        self._state = state
-        self._api = hass.data[DATA_API]
-
-        hass.data[DATA_REGISTRY].register_alarm_device(area_id, self)
+        self._area_id = area['id']
+        self._name = area['name']
+        self._state = _get_alarm_state(area['mode'])
+        if self._state == STATE_ALARM_DISARMED:
+            self._changed_by = area.get('last_unset_user_name', 'unknown')
+        else:
+            self._changed_by = area.get('last_set_user_name', 'unknown')
+        self._api = api

    @asyncio.coroutine
-    def async_update_from_spc(self, state):
+    def async_added_to_hass(self):
+        """Calbback for init handlers."""
+        self.hass.data[DATA_REGISTRY].register_alarm_device(
+            self._area_id, self)
+
+    @asyncio.coroutine
+    def async_update_from_spc(self, state, extra):
        """Update the alarm panel with a new state."""
        self._state = state
-        yield from self.async_update_ha_state()
+        self._changed_by = extra.get('changed_by', 'unknown')
+        self.async_schedule_update_ha_state()

    @property
    def should_poll(self):
@@ -72,6 +78,11 @@ class SpcAlarm(alarm.AlarmControlPanel):
        """Return the name of the device."""
        return self._name

+    @property
+    def changed_by(self):
+        """Return the user the last change was triggered by."""
+        return self._changed_by
+
    @property
    def state(self):
        """Return the state of the device."""
@@ -16,7 +16,7 @@ from homeassistant.const import (
    STATE_ALARM_ARMED_HOME, STATE_ALARM_ARMED_NIGHT, STATE_ALARM_DISARMED,
    STATE_ALARM_ARMING, STATE_ALARM_DISARMING, STATE_UNKNOWN, CONF_NAME)

-REQUIREMENTS = ['total_connect_client==0.11']
+REQUIREMENTS = ['total_connect_client==0.13']

 _LOGGER = logging.getLogger(__name__)

@@ -15,4 +15,6 @@ ATTR_STREAM_URL = 'streamUrl'
 ATTR_MAIN_TEXT = 'mainText'
 ATTR_REDIRECTION_URL = 'redirectionURL'

+SYN_RESOLUTION_MATCH = 'ER_SUCCESS_MATCH'
+
 DATE_FORMAT = '%Y-%m-%dT%H:%M:%S.0Z'
@@ -3,6 +3,7 @@ Support for Alexa skill service end point.

 For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/alexa/
+
 """
 import asyncio
 import enum
@@ -13,7 +14,7 @@ from homeassistant.const import HTTP_BAD_REQUEST
 from homeassistant.helpers import intent
 from homeassistant.components import http

-from .const import DOMAIN
+from .const import DOMAIN, SYN_RESOLUTION_MATCH

 INTENTS_API_ENDPOINT = '/api/alexa'

@@ -123,6 +124,43 @@ class AlexaIntentsView(http.HomeAssistantView):
        return self.json(alexa_response)


+def resolve_slot_synonyms(key, request):
+    """Check slot request for synonym resolutions."""
+    # Default to the spoken slot value if more than one or none are found. For
+    # reference to the request object structure, see the Alexa docs:
+    # https://tinyurl.com/ybvm7jhs
+    resolved_value = request['value']
+
+    if ('resolutions' in request and
+            'resolutionsPerAuthority' in request['resolutions'] and
+            len(request['resolutions']['resolutionsPerAuthority']) >= 1):
+
+        # Extract all of the possible values from each authority with a
+        # successful match
+        possible_values = []
+
+        for entry in request['resolutions']['resolutionsPerAuthority']:
+            if entry['status']['code'] != SYN_RESOLUTION_MATCH:
+                continue
+
+            possible_values.extend([item['value']['name']
+                                    for item
+                                    in entry['values']])
+
+        # If there is only one match use the resolved value, otherwise the
+        # resolution cannot be determined, so use the spoken slot value
+        if len(possible_values) == 1:
+            resolved_value = possible_values[0]
+        else:
+            _LOGGER.debug(
+                'Found multiple synonym resolutions for slot value: {%s: %s}',
+                key,
+                request['value']
+            )
+
+    return resolved_value
+
+
 class AlexaResponse(object):
    """Help generating the response for Alexa."""

@@ -135,12 +173,17 @@ class AlexaResponse(object):
        self.session_attributes = {}
        self.should_end_session = True
        self.variables = {}
+
        # Intent is None if request was a LaunchRequest or SessionEndedRequest
        if intent_info is not None:
            for key, value in intent_info.get('slots', {}).items():
-                if 'value' in value:
-                    underscored_key = key.replace('.', '_')
-                    self.variables[underscored_key] = value['value']
+                # Only include slots with values
+                if 'value' not in value:
+                    continue
+
+                _key = key.replace('.', '_')
+
+                self.variables[_key] = resolve_slot_synonyms(key, value)

    def add_card(self, card_type, title, content):
        """Add a card to the response."""
@@ -1,35 +1,83 @@
 """Support for alexa Smart Home Skill API."""
 import asyncio
+from collections import namedtuple
 import logging
+import math
 from uuid import uuid4

+import homeassistant.core as ha
 from homeassistant.const import (
-    ATTR_SUPPORTED_FEATURES, ATTR_ENTITY_ID, SERVICE_TURN_ON, SERVICE_TURN_OFF)
-from homeassistant.components import switch, light
+    ATTR_ENTITY_ID, ATTR_SUPPORTED_FEATURES, SERVICE_LOCK,
+    SERVICE_MEDIA_NEXT_TRACK, SERVICE_MEDIA_PAUSE, SERVICE_MEDIA_PLAY,
+    SERVICE_MEDIA_PREVIOUS_TRACK, SERVICE_MEDIA_STOP,
+    SERVICE_SET_COVER_POSITION, SERVICE_TURN_OFF, SERVICE_TURN_ON,
+    SERVICE_UNLOCK, SERVICE_VOLUME_SET)
+from homeassistant.components import (
+    alert, automation, cover, fan, group, input_boolean, light, lock,
+    media_player, scene, script, switch)
+import homeassistant.util.color as color_util
 from homeassistant.util.decorator import Registry

 HANDLERS = Registry()
 _LOGGER = logging.getLogger(__name__)

 API_DIRECTIVE = 'directive'
+API_ENDPOINT = 'endpoint'
 API_EVENT = 'event'
 API_HEADER = 'header'
 API_PAYLOAD = 'payload'
-API_ENDPOINT = 'endpoint'
+
+ATTR_ALEXA_DESCRIPTION = 'alexa_description'
+ATTR_ALEXA_DISPLAY_CATEGORIES = 'alexa_display_categories'
+ATTR_ALEXA_HIDDEN = 'alexa_hidden'
+ATTR_ALEXA_NAME = 'alexa_name'


 MAPPING_COMPONENT = {
-    switch.DOMAIN: ['SWITCH', ('Alexa.PowerController',), None],
-    light.DOMAIN: [
-        'LIGHT', ('Alexa.PowerController',), {
-            light.SUPPORT_BRIGHTNESS: 'Alexa.BrightnessController'
+    alert.DOMAIN: ['OTHER', ('Alexa.PowerController',), None],
+    automation.DOMAIN: ['OTHER', ('Alexa.PowerController',), None],
+    cover.DOMAIN: [
+        'DOOR', ('Alexa.PowerController',), {
+            cover.SUPPORT_SET_POSITION: 'Alexa.PercentageController',
        }
    ],
+    fan.DOMAIN: [
+        'OTHER', ('Alexa.PowerController',), {
+            fan.SUPPORT_SET_SPEED: 'Alexa.PercentageController',
+        }
+    ],
+    group.DOMAIN: ['OTHER', ('Alexa.PowerController',), None],
+    input_boolean.DOMAIN: ['OTHER', ('Alexa.PowerController',), None],
+    light.DOMAIN: [
+        'LIGHT', ('Alexa.PowerController',), {
+            light.SUPPORT_BRIGHTNESS: 'Alexa.BrightnessController',
+            light.SUPPORT_RGB_COLOR: 'Alexa.ColorController',
+            light.SUPPORT_XY_COLOR: 'Alexa.ColorController',
+            light.SUPPORT_COLOR_TEMP: 'Alexa.ColorTemperatureController',
+        }
+    ],
+    lock.DOMAIN: ['SMARTLOCK', ('Alexa.LockController',), None],
+    media_player.DOMAIN: [
+        'TV', ('Alexa.PowerController',), {
+            media_player.SUPPORT_VOLUME_SET: 'Alexa.Speaker',
+            media_player.SUPPORT_PLAY: 'Alexa.PlaybackController',
+            media_player.SUPPORT_PAUSE: 'Alexa.PlaybackController',
+            media_player.SUPPORT_STOP: 'Alexa.PlaybackController',
+            media_player.SUPPORT_NEXT_TRACK: 'Alexa.PlaybackController',
+            media_player.SUPPORT_PREVIOUS_TRACK: 'Alexa.PlaybackController',
+        }
+    ],
+    scene.DOMAIN: ['ACTIVITY_TRIGGER', ('Alexa.SceneController',), None],
+    script.DOMAIN: ['OTHER', ('Alexa.PowerController',), None],
+    switch.DOMAIN: ['SWITCH', ('Alexa.PowerController',), None],
 }


+Config = namedtuple('AlexaConfig', 'filter')
+
+
@asyncio.coroutine
-def async_handle_message(hass, message):
+def async_handle_message(hass, config, message):
    """Handle incoming API messages."""
    assert message[API_DIRECTIVE][API_HEADER]['payloadVersion'] == '3'

@@ -45,7 +93,7 @@ def async_handle_message(hass, message):
            "Unsupported API request %s/%s", namespace, name)
        return api_error(message)

-    return (yield from funct_ref(hass, message))
+    return (yield from funct_ref(hass, config, message))


 def api_message(request, name='Response', namespace='Alexa', payload=None):
@@ -94,7 +142,7 @@ def api_error(request, error_type='INTERNAL_ERROR', error_message=""):

@HANDLERS.register(('Alexa.Discovery', 'Discover'))
@asyncio.coroutine
-def async_api_discovery(hass, request):
+def async_api_discovery(hass, config, request):
    """Create a API formatted discovery response.

    Async friendly.
@@ -102,18 +150,40 @@ def async_api_discovery(hass, request):
    discovery_endpoints = []

    for entity in hass.states.async_all():
+        if not config.filter(entity.entity_id):
+            _LOGGER.debug("Not exposing %s because filtered by config",
+                          entity.entity_id)
+            continue
+
+        if entity.attributes.get(ATTR_ALEXA_HIDDEN, False):
+            _LOGGER.debug("Not exposing %s because alexa_hidden is true",
+                          entity.entity_id)
+            continue
+
        class_data = MAPPING_COMPONENT.get(entity.domain)

        if not class_data:
            continue

+        friendly_name = entity.attributes.get(ATTR_ALEXA_NAME, entity.name)
+        description = entity.attributes.get(ATTR_ALEXA_DESCRIPTION,
+                                            entity.entity_id)
+
+        # Required description as per Amazon Scene docs
+        if entity.domain == scene.DOMAIN:
+            scene_fmt = '%s (Scene connected via Home Assistant)'
+            description = scene_fmt.format(description)
+
+        cat_key = ATTR_ALEXA_DISPLAY_CATEGORIES
+        display_categories = entity.attributes.get(cat_key, class_data[0])
+
        endpoint = {
-            'displayCategories': [class_data[0]],
+            'displayCategories': [display_categories],
            'additionalApplianceDetails': {},
            'endpointId': entity.entity_id.replace('.', '#'),
-            'friendlyName': entity.name,
-            'description': '',
-            'manufacturerName': 'Unknown',
+            'friendlyName': friendly_name,
+            'description': description,
+            'manufacturerName': 'Home Assistant',
        }
        actions = set()

@@ -148,7 +218,7 @@ def async_api_discovery(hass, request):
 def extract_entity(funct):
    """Decorator for extract entity object from request."""
    @asyncio.coroutine
-    def async_api_entity_wrapper(hass, request):
+    def async_api_entity_wrapper(hass, config, request):
        """Process a turn on request."""
        entity_id = request[API_ENDPOINT]['endpointId'].replace('#', '.')

@@ -159,7 +229,7 @@ def extract_entity(funct):
                          request[API_HEADER]['name'], entity_id)
            return api_error(request, error_type='NO_SUCH_ENDPOINT')

-        return (yield from funct(hass, request, entity))
+        return (yield from funct(hass, config, request, entity))

    return async_api_entity_wrapper

@@ -167,9 +237,13 @@ def extract_entity(funct):
@HANDLERS.register(('Alexa.PowerController', 'TurnOn'))
@extract_entity
@asyncio.coroutine
-def async_api_turn_on(hass, request, entity):
+def async_api_turn_on(hass, config, request, entity):
    """Process a turn on request."""
-    yield from hass.services.async_call(entity.domain, SERVICE_TURN_ON, {
+    domain = entity.domain
+    if entity.domain == group.DOMAIN:
+        domain = ha.DOMAIN
+
+    yield from hass.services.async_call(domain, SERVICE_TURN_ON, {
        ATTR_ENTITY_ID: entity.entity_id
    }, blocking=True)

@@ -179,9 +253,13 @@ def async_api_turn_on(hass, request, entity):
@HANDLERS.register(('Alexa.PowerController', 'TurnOff'))
@extract_entity
@asyncio.coroutine
-def async_api_turn_off(hass, request, entity):
+def async_api_turn_off(hass, config, request, entity):
    """Process a turn off request."""
-    yield from hass.services.async_call(entity.domain, SERVICE_TURN_OFF, {
+    domain = entity.domain
+    if entity.domain == group.DOMAIN:
+        domain = ha.DOMAIN
+
+    yield from hass.services.async_call(domain, SERVICE_TURN_OFF, {
        ATTR_ENTITY_ID: entity.entity_id
    }, blocking=True)

@@ -191,13 +269,375 @@ def async_api_turn_off(hass, request, entity):
@HANDLERS.register(('Alexa.BrightnessController', 'SetBrightness'))
@extract_entity
@asyncio.coroutine
-def async_api_set_brightness(hass, request, entity):
+def async_api_set_brightness(hass, config, request, entity):
    """Process a set brightness request."""
-    brightness = request[API_PAYLOAD]['brightness']
+    brightness = int(request[API_PAYLOAD]['brightness'])

    yield from hass.services.async_call(entity.domain, SERVICE_TURN_ON, {
        ATTR_ENTITY_ID: entity.entity_id,
-        light.ATTR_BRIGHTNESS: brightness,
+        light.ATTR_BRIGHTNESS_PCT: brightness,
    }, blocking=True)

    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.BrightnessController', 'AdjustBrightness'))
+@extract_entity
+@asyncio.coroutine
+def async_api_adjust_brightness(hass, config, request, entity):
+    """Process a adjust brightness request."""
+    brightness_delta = int(request[API_PAYLOAD]['brightnessDelta'])
+
+    # read current state
+    try:
+        current = math.floor(
+            int(entity.attributes.get(light.ATTR_BRIGHTNESS)) / 255 * 100)
+    except ZeroDivisionError:
+        current = 0
+
+    # set brightness
+    brightness = max(0, brightness_delta + current)
+    yield from hass.services.async_call(entity.domain, SERVICE_TURN_ON, {
+        ATTR_ENTITY_ID: entity.entity_id,
+        light.ATTR_BRIGHTNESS_PCT: brightness,
+    }, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.ColorController', 'SetColor'))
+@extract_entity
+@asyncio.coroutine
+def async_api_set_color(hass, config, request, entity):
+    """Process a set color request."""
+    supported = entity.attributes.get(ATTR_SUPPORTED_FEATURES)
+    rgb = color_util.color_hsb_to_RGB(
+        float(request[API_PAYLOAD]['color']['hue']),
+        float(request[API_PAYLOAD]['color']['saturation']),
+        float(request[API_PAYLOAD]['color']['brightness'])
+    )
+
+    if supported & light.SUPPORT_RGB_COLOR > 0:
+        yield from hass.services.async_call(entity.domain, SERVICE_TURN_ON, {
+            ATTR_ENTITY_ID: entity.entity_id,
+            light.ATTR_RGB_COLOR: rgb,
+        }, blocking=True)
+    else:
+        xyz = color_util.color_RGB_to_xy(*rgb)
+        yield from hass.services.async_call(entity.domain, SERVICE_TURN_ON, {
+            ATTR_ENTITY_ID: entity.entity_id,
+            light.ATTR_XY_COLOR: (xyz[0], xyz[1]),
+            light.ATTR_BRIGHTNESS: xyz[2],
+        }, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.ColorTemperatureController', 'SetColorTemperature'))
+@extract_entity
+@asyncio.coroutine
+def async_api_set_color_temperature(hass, config, request, entity):
+    """Process a set color temperature request."""
+    kelvin = int(request[API_PAYLOAD]['colorTemperatureInKelvin'])
+
+    yield from hass.services.async_call(entity.domain, SERVICE_TURN_ON, {
+        ATTR_ENTITY_ID: entity.entity_id,
+        light.ATTR_KELVIN: kelvin,
+    }, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(
+    ('Alexa.ColorTemperatureController', 'DecreaseColorTemperature'))
+@extract_entity
+@asyncio.coroutine
+def async_api_decrease_color_temp(hass, config, request, entity):
+    """Process a decrease color temperature request."""
+    current = int(entity.attributes.get(light.ATTR_COLOR_TEMP))
+    max_mireds = int(entity.attributes.get(light.ATTR_MAX_MIREDS))
+
+    value = min(max_mireds, current + 50)
+    yield from hass.services.async_call(entity.domain, SERVICE_TURN_ON, {
+        ATTR_ENTITY_ID: entity.entity_id,
+        light.ATTR_COLOR_TEMP: value,
+    }, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(
+    ('Alexa.ColorTemperatureController', 'IncreaseColorTemperature'))
+@extract_entity
+@asyncio.coroutine
+def async_api_increase_color_temp(hass, config, request, entity):
+    """Process a increase color temperature request."""
+    current = int(entity.attributes.get(light.ATTR_COLOR_TEMP))
+    min_mireds = int(entity.attributes.get(light.ATTR_MIN_MIREDS))
+
+    value = max(min_mireds, current - 50)
+    yield from hass.services.async_call(entity.domain, SERVICE_TURN_ON, {
+        ATTR_ENTITY_ID: entity.entity_id,
+        light.ATTR_COLOR_TEMP: value,
+    }, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.SceneController', 'Activate'))
+@extract_entity
+@asyncio.coroutine
+def async_api_activate(hass, config, request, entity):
+    """Process a activate request."""
+    yield from hass.services.async_call(entity.domain, SERVICE_TURN_ON, {
+        ATTR_ENTITY_ID: entity.entity_id
+    }, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.PercentageController', 'SetPercentage'))
+@extract_entity
+@asyncio.coroutine
+def async_api_set_percentage(hass, config, request, entity):
+    """Process a set percentage request."""
+    percentage = int(request[API_PAYLOAD]['percentage'])
+    service = None
+    data = {ATTR_ENTITY_ID: entity.entity_id}
+
+    if entity.domain == fan.DOMAIN:
+        service = fan.SERVICE_SET_SPEED
+        speed = "off"
+
+        if percentage <= 33:
+            speed = "low"
+        elif percentage <= 66:
+            speed = "medium"
+        elif percentage <= 100:
+            speed = "high"
+        data[fan.ATTR_SPEED] = speed
+
+    elif entity.domain == cover.DOMAIN:
+        service = SERVICE_SET_COVER_POSITION
+        data[cover.ATTR_POSITION] = percentage
+
+    yield from hass.services.async_call(entity.domain, service,
+                                        data, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.PercentageController', 'AdjustPercentage'))
+@extract_entity
+@asyncio.coroutine
+def async_api_adjust_percentage(hass, config, request, entity):
+    """Process a adjust percentage request."""
+    percentage_delta = int(request[API_PAYLOAD]['percentageDelta'])
+    service = None
+    data = {ATTR_ENTITY_ID: entity.entity_id}
+
+    if entity.domain == fan.DOMAIN:
+        service = fan.SERVICE_SET_SPEED
+        speed = entity.attributes.get(fan.ATTR_SPEED)
+
+        if speed == "off":
+            current = 0
+        elif speed == "low":
+            current = 33
+        elif speed == "medium":
+            current = 66
+        elif speed == "high":
+            current = 100
+
+        # set percentage
+        percentage = max(0, percentage_delta + current)
+        speed = "off"
+
+        if percentage <= 33:
+            speed = "low"
+        elif percentage <= 66:
+            speed = "medium"
+        elif percentage <= 100:
+            speed = "high"
+
+        data[fan.ATTR_SPEED] = speed
+
+    elif entity.domain == cover.DOMAIN:
+        service = SERVICE_SET_COVER_POSITION
+
+        current = entity.attributes.get(cover.ATTR_POSITION)
+
+        data[cover.ATTR_POSITION] = max(0, percentage_delta + current)
+
+    yield from hass.services.async_call(entity.domain, service,
+                                        data, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.LockController', 'Lock'))
+@extract_entity
+@asyncio.coroutine
+def async_api_lock(hass, config, request, entity):
+    """Process a lock request."""
+    yield from hass.services.async_call(entity.domain, SERVICE_LOCK, {
+        ATTR_ENTITY_ID: entity.entity_id
+    }, blocking=True)
+
+    return api_message(request)
+
+
+# Not supported by Alexa yet
+@HANDLERS.register(('Alexa.LockController', 'Unlock'))
+@extract_entity
+@asyncio.coroutine
+def async_api_unlock(hass, config, request, entity):
+    """Process a unlock request."""
+    yield from hass.services.async_call(entity.domain, SERVICE_UNLOCK, {
+        ATTR_ENTITY_ID: entity.entity_id
+    }, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.Speaker', 'SetVolume'))
+@extract_entity
+@asyncio.coroutine
+def async_api_set_volume(hass, config, request, entity):
+    """Process a set volume request."""
+    volume = round(float(request[API_PAYLOAD]['volume'] / 100), 2)
+
+    data = {
+        ATTR_ENTITY_ID: entity.entity_id,
+        media_player.ATTR_MEDIA_VOLUME_LEVEL: volume,
+    }
+
+    yield from hass.services.async_call(entity.domain, SERVICE_VOLUME_SET,
+                                        data, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.Speaker', 'AdjustVolume'))
+@extract_entity
+@asyncio.coroutine
+def async_api_adjust_volume(hass, config, request, entity):
+    """Process a adjust volume request."""
+    volume_delta = int(request[API_PAYLOAD]['volume'])
+
+    current_level = entity.attributes.get(media_player.ATTR_MEDIA_VOLUME_LEVEL)
+
+    # read current state
+    try:
+        current = math.floor(int(current_level * 100))
+    except ZeroDivisionError:
+        current = 0
+
+    volume = float(max(0, volume_delta + current) / 100)
+
+    data = {
+        ATTR_ENTITY_ID: entity.entity_id,
+        media_player.ATTR_MEDIA_VOLUME_LEVEL: volume,
+    }
+
+    yield from hass.services.async_call(entity.domain,
+                                        media_player.SERVICE_VOLUME_SET,
+                                        data, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.Speaker', 'SetMute'))
+@extract_entity
+@asyncio.coroutine
+def async_api_set_mute(hass, config, request, entity):
+    """Process a set mute request."""
+    mute = bool(request[API_PAYLOAD]['mute'])
+
+    data = {
+        ATTR_ENTITY_ID: entity.entity_id,
+        media_player.ATTR_MEDIA_VOLUME_MUTED: mute,
+    }
+
+    yield from hass.services.async_call(entity.domain,
+                                        media_player.SERVICE_VOLUME_MUTE,
+                                        data, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.PlaybackController', 'Play'))
+@extract_entity
+@asyncio.coroutine
+def async_api_play(hass, config, request, entity):
+    """Process a play request."""
+    data = {
+        ATTR_ENTITY_ID: entity.entity_id
+    }
+
+    yield from hass.services.async_call(entity.domain, SERVICE_MEDIA_PLAY,
+                                        data, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.PlaybackController', 'Pause'))
+@extract_entity
+@asyncio.coroutine
+def async_api_pause(hass, config, request, entity):
+    """Process a pause request."""
+    data = {
+        ATTR_ENTITY_ID: entity.entity_id
+    }
+
+    yield from hass.services.async_call(entity.domain, SERVICE_MEDIA_PAUSE,
+                                        data, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.PlaybackController', 'Stop'))
+@extract_entity
+@asyncio.coroutine
+def async_api_stop(hass, config, request, entity):
+    """Process a stop request."""
+    data = {
+        ATTR_ENTITY_ID: entity.entity_id
+    }
+
+    yield from hass.services.async_call(entity.domain, SERVICE_MEDIA_STOP,
+                                        data, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.PlaybackController', 'Next'))
+@extract_entity
+@asyncio.coroutine
+def async_api_next(hass, config, request, entity):
+    """Process a next request."""
+    data = {
+        ATTR_ENTITY_ID: entity.entity_id
+    }
+
+    yield from hass.services.async_call(entity.domain,
+                                        SERVICE_MEDIA_NEXT_TRACK,
+                                        data, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.PlaybackController', 'Previous'))
+@extract_entity
+@asyncio.coroutine
+def async_api_previous(hass, config, request, entity):
+    """Process a previous request."""
+    data = {
+        ATTR_ENTITY_ID: entity.entity_id
+    }
+
+    yield from hass.services.async_call(entity.domain,
+                                        SERVICE_MEDIA_PREVIOUS_TRACK,
+                                        data, blocking=True)
+
+    return api_message(request)
@@ -262,7 +262,11 @@ class APIEventView(HomeAssistantView):
    def post(self, request, event_type):
        """Fire events."""
        body = yield from request.text()
-        event_data = json.loads(body) if body else None
+        try:
+            event_data = json.loads(body) if body else None
+        except ValueError:
+            return self.json_message('Event data should be valid JSON',
+                                     HTTP_BAD_REQUEST)

        if event_data is not None and not isinstance(event_data, dict):
            return self.json_message('Event data should be a JSON object',
@@ -309,7 +313,11 @@ class APIDomainServicesView(HomeAssistantView):
        """
        hass = request.app['hass']
        body = yield from request.text()
-        data = json.loads(body) if body else None
+        try:
+            data = json.loads(body) if body else None
+        except ValueError:
+            return self.json_message('Data should be valid JSON',
+                                     HTTP_BAD_REQUEST)

        with AsyncTrackStates(hass) as changed_states:
            yield from hass.services.async_call(domain, service, data, True)
@@ -18,7 +18,7 @@ from homeassistant.helpers import discovery
 from homeassistant.components.discovery import SERVICE_APPLE_TV
 import homeassistant.helpers.config_validation as cv

-REQUIREMENTS = ['pyatv==0.3.5']
+REQUIREMENTS = ['pyatv==0.3.8']

 _LOGGER = logging.getLogger(__name__)

@@ -12,7 +12,7 @@ from requests.exceptions import HTTPError, ConnectTimeout
 from homeassistant.helpers import config_validation as cv
 from homeassistant.const import CONF_USERNAME, CONF_PASSWORD

-REQUIREMENTS = ['pyarlo==0.0.7']
+REQUIREMENTS = ['pyarlo==0.1.0']

 _LOGGER = logging.getLogger(__name__)

@@ -21,7 +21,7 @@ _LOGGER = logging.getLogger(__name__)
 TRIGGER_SCHEMA = vol.Schema({
    vol.Required(CONF_PLATFORM): 'event',
    vol.Required(CONF_EVENT_TYPE): cv.string,
-    vol.Optional(CONF_EVENT_DATA, default={}): dict,
+    vol.Optional(CONF_EVENT_DATA): dict,
 })


@@ -37,6 +37,8 @@ def async_trigger(hass, config, action):
    def handle_event(event):
        """Listen for events and calls the action when data matches."""
        if event_data_schema:
+            # Check that the event data matches the configured
+            # schema if one was provided
            try:
                event_data_schema(event.data)
            except vol.Invalid:
@@ -38,13 +38,14 @@ def async_trigger(hass, config, action):
    time_delta = config.get(CONF_FOR)
    value_template = config.get(CONF_VALUE_TEMPLATE)
    async_remove_track_same = None
+    already_triggered = False

    if value_template is not None:
        value_template.hass = hass

    @callback
    def check_numeric_state(entity, from_s, to_s):
-        """Return True if they should trigger."""
+        """Return True if criteria are now met."""
        if to_s is None:
            return False

@@ -56,51 +57,39 @@ def async_trigger(hass, config, action):
                'above': above,
            }
        }
-
-        # If new one doesn't match, nothing to do
-        if not condition.async_numeric_state(
-                hass, to_s, below, above, value_template, variables):
-            return False
-
-        return True
+        return condition.async_numeric_state(
+            hass, to_s, below, above, value_template, variables)

    @callback
    def state_automation_listener(entity, from_s, to_s):
        """Listen for state changes and calls action."""
-        nonlocal async_remove_track_same
-
-        if not check_numeric_state(entity, from_s, to_s):
-            return
-
-        variables = {
-            'trigger': {
-                'platform': 'numeric_state',
-                'entity_id': entity,
-                'below': below,
-                'above': above,
-                'from_state': from_s,
-                'to_state': to_s,
-            }
-        }
-
-        # 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.async_numeric_state(
-                hass, from_s, below, above, value_template, variables):
-            return
+        nonlocal already_triggered, async_remove_track_same

        @callback
        def call_action():
            """Call action with right context."""
-            hass.async_run_job(action, variables)
+            hass.async_run_job(action, {
+                'trigger': {
+                    'platform': 'numeric_state',
+                    'entity_id': entity,
+                    'below': below,
+                    'above': above,
+                    'from_state': from_s,
+                    'to_state': to_s,
+                }
+            })

-        if not time_delta:
-            call_action()
-            return
+        matching = check_numeric_state(entity, from_s, to_s)

-        async_remove_track_same = async_track_same_state(
-            hass, time_delta, call_action, entity_ids=entity_id,
-            async_check_same_func=check_numeric_state)
+        if matching and not already_triggered:
+            if time_delta:
+                async_remove_track_same = async_track_same_state(
+                    hass, time_delta, call_action, entity_ids=entity_id,
+                    async_check_same_func=check_numeric_state)
+            else:
+                call_action()
+
+        already_triggered = matching

    unsub = async_track_state_change(
        hass, entity_id, state_automation_listener)
@@ -1,6 +1,7 @@
+# Describes the format for available automation services
+
 turn_on:
  description: Enable an automation.
-
  fields:
    entity_id:
      description: Name of the automation to turn on.
@@ -8,7 +9,6 @@ turn_on:

 turn_off:
  description: Disable an automation.
-
  fields:
    entity_id:
      description: Name of the automation to turn off.
@@ -16,7 +16,6 @@ turn_off:

 toggle:
  description: Toggle an automation.
-
  fields:
    entity_id:
      description: Name of the automation to toggle on/off.
@@ -24,7 +23,6 @@ toggle:

 trigger:
  description: Trigger the action of an automation.
-
  fields:
    entity_id:
      description: Name of the automation to trigger.
@@ -11,19 +11,20 @@ import os

 import voluptuous as vol

+from homeassistant.components.discovery import SERVICE_AXIS
 from homeassistant.config import load_yaml_config_file
 from homeassistant.const import (ATTR_LOCATION, ATTR_TRIPPED,
-                                 CONF_HOST, CONF_INCLUDE, CONF_NAME,
-                                 CONF_PASSWORD, CONF_PORT, CONF_TRIGGER_TIME,
-                                 CONF_USERNAME, EVENT_HOMEASSISTANT_STOP)
-from homeassistant.components.discovery import SERVICE_AXIS
+                                 CONF_EVENT, CONF_HOST, CONF_INCLUDE,
+                                 CONF_NAME, CONF_PASSWORD, CONF_PORT,
+                                 CONF_TRIGGER_TIME, CONF_USERNAME,
+                                 EVENT_HOMEASSISTANT_STOP)
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers import discovery
-from homeassistant.helpers.dispatcher import async_dispatcher_send
+from homeassistant.helpers.dispatcher import dispatcher_send
 from homeassistant.helpers.entity import Entity


-REQUIREMENTS = ['axis==12']
+REQUIREMENTS = ['axis==14']

 _LOGGER = logging.getLogger(__name__)

@@ -87,10 +88,13 @@ def request_configuration(hass, config, name, host, serialnumber):
            configurator.notify_errors(request_id,
                                       "Functionality mandatory.")
            return False
+
        callback_data[CONF_INCLUDE] = callback_data[CONF_INCLUDE].split()
        callback_data[CONF_HOST] = host
+
        if CONF_NAME not in callback_data:
            callback_data[CONF_NAME] = name
+
        try:
            device_config = DEVICE_SCHEMA(callback_data)
        except vol.Invalid:
@@ -101,7 +105,6 @@ def request_configuration(hass, config, name, host, serialnumber):
        if setup_device(hass, config, device_config):
            config_file = _read_config(hass)
            config_file[serialnumber] = dict(device_config)
-            del config_file[serialnumber]['hass']
            _write_config(hass, config_file)
            configurator.request_done(request_id)
        else:
@@ -146,10 +149,10 @@ def request_configuration(hass, config, name, host, serialnumber):
 def setup(hass, config):
    """Common setup for Axis devices."""
    def _shutdown(call):  # pylint: disable=unused-argument
-        """Stop the metadatastream on shutdown."""
+        """Stop the event stream on shutdown."""
        for serialnumber, device in AXIS_DEVICES.items():
-            _LOGGER.info("Stopping metadatastream for %s.", serialnumber)
-            device.stop_metadatastream()
+            _LOGGER.info("Stopping event stream for %s.", serialnumber)
+            device.stop()

    hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, _shutdown)

@@ -162,7 +165,7 @@ def setup(hass, config):
        if serialnumber not in AXIS_DEVICES:
            config_file = _read_config(hass)
            if serialnumber in config_file:
-                # Device config saved to file
+                # Device config previously saved to file
                try:
                    device_config = DEVICE_SCHEMA(config_file[serialnumber])
                    device_config[CONF_HOST] = host
@@ -178,10 +181,8 @@ def setup(hass, config):
        else:
            # Device already registered, but on a different IP
            device = AXIS_DEVICES[serialnumber]
-            device.url = host
-            async_dispatcher_send(hass,
-                                  DOMAIN + '_' + device.name + '_new_ip',
-                                  host)
+            device.config.host = host
+            dispatcher_send(hass, DOMAIN + '_' + device.name + '_new_ip', host)

    # Register discovery service
    discovery.listen(hass, SERVICE_AXIS, axis_device_discovered)
@@ -202,10 +203,11 @@ def setup(hass, config):
        """Service to send a message."""
        for _, device in AXIS_DEVICES.items():
            if device.name == call.data[CONF_NAME]:
-                response = device.do_request(call.data[SERVICE_CGI],
-                                             call.data[SERVICE_ACTION],
-                                             call.data[SERVICE_PARAM])
-                hass.bus.async_fire(SERVICE_VAPIX_CALL_RESPONSE, response)
+                response = device.vapix.do_request(
+                    call.data[SERVICE_CGI],
+                    call.data[SERVICE_ACTION],
+                    call.data[SERVICE_PARAM])
+                hass.bus.fire(SERVICE_VAPIX_CALL_RESPONSE, response)
                return True
        _LOGGER.info("Couldn\'t find device %s", call.data[CONF_NAME])
        return False
@@ -216,7 +218,6 @@ def setup(hass, config):
                           vapix_service,
                           descriptions[DOMAIN][SERVICE_VAPIX_CALL],
                           schema=SERVICE_SCHEMA)
-
    return True


@@ -224,9 +225,28 @@ def setup_device(hass, config, device_config):
    """Set up device."""
    from axis import AxisDevice

-    device_config['hass'] = hass
-    device = AxisDevice(device_config)  # Initialize device
-    enable_metadatastream = False
+    def signal_callback(action, event):
+        """Callback to configure events when initialized on event stream."""
+        if action == 'add':
+            event_config = {
+                CONF_EVENT: event,
+                CONF_NAME: device_config[CONF_NAME],
+                ATTR_LOCATION: device_config[ATTR_LOCATION],
+                CONF_TRIGGER_TIME: device_config[CONF_TRIGGER_TIME]
+            }
+            component = event.event_platform
+            discovery.load_platform(hass,
+                                    component,
+                                    DOMAIN,
+                                    event_config,
+                                    config)
+
+    event_types = list(filter(lambda x: x in device_config[CONF_INCLUDE],
+                              EVENT_TYPES))
+    device_config['events'] = event_types
+    device_config['signal'] = signal_callback
+    device = AxisDevice(hass.loop, **device_config)
+    device.name = device_config[CONF_NAME]

    if device.serial_number is None:
        # If there is no serial number a connection could not be made
@@ -234,16 +254,10 @@ def setup_device(hass, config, device_config):
        return False

    for component in device_config[CONF_INCLUDE]:
-        if component in EVENT_TYPES:
-            # Sensors are created by device calling event_initialized
-            # when receiving initialize messages on metadatastream
-            device.add_event_topic(convert(component, 'type', 'subscribe'))
-            if not enable_metadatastream:
-                enable_metadatastream = True
-        else:
+        if component == 'camera':
            camera_config = {
-                CONF_HOST: device_config[CONF_HOST],
                CONF_NAME: device_config[CONF_NAME],
+                CONF_HOST: device_config[CONF_HOST],
                CONF_PORT: device_config[CONF_PORT],
                CONF_USERNAME: device_config[CONF_USERNAME],
                CONF_PASSWORD: device_config[CONF_PASSWORD]
@@ -254,17 +268,9 @@ def setup_device(hass, config, device_config):
                                    camera_config,
                                    config)

-    if enable_metadatastream:
-        device.initialize_new_event = event_initialized
-        if not device.initiate_metadatastream():
-            hass.components.persistent_notification.create(
-                'Dependency missing for sensors, '
-                'please check documentation',
-                title=DOMAIN,
-                notification_id='axis_notification')
-
    AXIS_DEVICES[device.serial_number] = device
-
+    if event_types:
+        hass.add_job(device.start)
    return True


@@ -287,25 +293,16 @@ def _write_config(hass, config):
        outfile.write(data)


-def event_initialized(event):
-    """Register event initialized on metadatastream here."""
-    hass = event.device_config('hass')
-    discovery.load_platform(hass,
-                            convert(event.topic, 'topic', 'platform'),
-                            DOMAIN, {'axis_event': event})
-
-
 class AxisDeviceEvent(Entity):
    """Representation of a Axis device event."""

-    def __init__(self, axis_event):
+    def __init__(self, event_config):
        """Initialize the event."""
-        self.axis_event = axis_event
-        self._event_class = convert(self.axis_event.topic, 'topic', 'class')
-        self._name = '{}_{}_{}'.format(self.axis_event.device_name,
-                                       convert(self.axis_event.topic,
-                                               'topic', 'type'),
+        self.axis_event = event_config[CONF_EVENT]
+        self._name = '{}_{}_{}'.format(event_config[CONF_NAME],
+                                       self.axis_event.event_type,
                                       self.axis_event.id)
+        self.location = event_config[ATTR_LOCATION]
        self.axis_event.callback = self._update_callback

    def _update_callback(self):
@@ -321,7 +318,7 @@ class AxisDeviceEvent(Entity):
    @property
    def device_class(self):
        """Return the class of the event."""
-        return self._event_class
+        return self.axis_event.event_class

    @property
    def should_poll(self):
@@ -336,52 +333,6 @@ class AxisDeviceEvent(Entity):
        tripped = self.axis_event.is_tripped
        attr[ATTR_TRIPPED] = 'True' if tripped else 'False'

-        location = self.axis_event.device_config(ATTR_LOCATION)
-        if location:
-            attr[ATTR_LOCATION] = location
+        attr[ATTR_LOCATION] = self.location

        return attr
-
-
-def convert(item, from_key, to_key):
-    """Translate between Axis and HASS syntax."""
-    for entry in REMAP:
-        if entry[from_key] == item:
-            return entry[to_key]
-
-
-REMAP = [{'type': 'motion',
-          'class': 'motion',
-          'topic': 'tns1:VideoAnalytics/tnsaxis:MotionDetection',
-          'subscribe': 'onvif:VideoAnalytics/axis:MotionDetection',
-          'platform': 'binary_sensor'},
-         {'type': 'vmd3',
-          'class': 'motion',
-          'topic': 'tns1:RuleEngine/tnsaxis:VMD3/vmd3_video_1',
-          'subscribe': 'onvif:RuleEngine/axis:VMD3/vmd3_video_1',
-          'platform': 'binary_sensor'},
-         {'type': 'pir',
-          'class': 'motion',
-          'topic': 'tns1:Device/tnsaxis:Sensor/PIR',
-          'subscribe': 'onvif:Device/axis:Sensor/axis:PIR',
-          'platform': 'binary_sensor'},
-         {'type': 'sound',
-          'class': 'sound',
-          'topic': 'tns1:AudioSource/tnsaxis:TriggerLevel',
-          'subscribe': 'onvif:AudioSource/axis:TriggerLevel',
-          'platform': 'binary_sensor'},
-         {'type': 'daynight',
-          'class': 'light',
-          'topic': 'tns1:VideoSource/tnsaxis:DayNightVision',
-          'subscribe': 'onvif:VideoSource/axis:DayNightVision',
-          'platform': 'binary_sensor'},
-         {'type': 'tampering',
-          'class': 'safety',
-          'topic': 'tns1:VideoSource/tnsaxis:Tampering',
-          'subscribe': 'onvif:VideoSource/axis:Tampering',
-          'platform': 'binary_sensor'},
-         {'type': 'input',
-          'class': 'input',
-          'topic': 'tns1:Device/tnsaxis:IO/Port',
-          'subscribe': 'onvif:Device/axis:IO/Port',
-          'platform': 'binary_sensor'}, ]
@@ -30,6 +30,7 @@ DEVICE_CLASSES = [
    'moving',        # On means moving, Off means stopped
    'occupancy',     # On means occupied, Off means not occupied
    'opening',       # Door, window, etc.
+    'plug',          # On means plugged in, Off means unplugged
    'power',         # Power, over-current, etc
    'safety',        # Generic on=unsafe, off=safe
    'smoke',         # Smoke detector
@@ -7,25 +7,32 @@ https://home-assistant.io/components/binary_sensor.aurora/
 from datetime import timedelta
 import logging

+from aiohttp.hdrs import USER_AGENT
 import requests
 import voluptuous as vol

-from homeassistant.components.binary_sensor \
-    import (BinarySensorDevice, PLATFORM_SCHEMA)
-from homeassistant.const import (CONF_NAME)
+from homeassistant.components.binary_sensor import (
+    PLATFORM_SCHEMA, BinarySensorDevice)
+from homeassistant.const import CONF_NAME, ATTR_ATTRIBUTION
 import homeassistant.helpers.config_validation as cv
 from homeassistant.util import Throttle

-CONF_THRESHOLD = "forecast_threshold"
-
 _LOGGER = logging.getLogger(__name__)

+CONF_ATTRIBUTION = "Data provided by the National Oceanic and Atmospheric" \
+                   "Administration"
+CONF_THRESHOLD = 'forecast_threshold'
+
+DEFAULT_DEVICE_CLASS = 'visible'
 DEFAULT_NAME = 'Aurora Visibility'
-DEFAULT_DEVICE_CLASS = "visible"
 DEFAULT_THRESHOLD = 75

+HA_USER_AGENT = "Home Assistant Aurora Tracker v.0.1.0"
+
 MIN_TIME_BETWEEN_UPDATES = timedelta(minutes=5)

+URL = "http://services.swpc.noaa.gov/text/aurora-nowcast-map.txt"
+
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
    vol.Optional(CONF_THRESHOLD, default=DEFAULT_THRESHOLD): cv.positive_int,
@@ -43,10 +50,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):

    try:
        aurora_data = AuroraData(
-            hass.config.latitude,
-            hass.config.longitude,
-            threshold
-        )
+            hass.config.latitude, hass.config.longitude, threshold)
        aurora_data.update()
    except requests.exceptions.HTTPError as error:
        _LOGGER.error(
@@ -85,9 +89,9 @@ class AuroraSensor(BinarySensorDevice):
        attrs = {}

        if self.aurora_data:
-            attrs["visibility_level"] = self.aurora_data.visibility_level
-            attrs["message"] = self.aurora_data.is_visible_text
-
+            attrs['visibility_level'] = self.aurora_data.visibility_level
+            attrs['message'] = self.aurora_data.is_visible_text
+            attrs[ATTR_ATTRIBUTION] = CONF_ATTRIBUTION
        return attrs

    def update(self):
@@ -104,10 +108,7 @@ class AuroraData(object):
        self.longitude = longitude
        self.number_of_latitude_intervals = 513
        self.number_of_longitude_intervals = 1024
-        self.api_url = \
-            "http://services.swpc.noaa.gov/text/aurora-nowcast-map.txt"
-        self.headers = {"User-Agent": "Home Assistant Aurora Tracker v.0.1.0"}
-
+        self.headers = {USER_AGENT: HA_USER_AGENT}
        self.threshold = int(threshold)
        self.is_visible = None
        self.is_visible_text = None
@@ -132,14 +133,14 @@ class AuroraData(object):

    def get_aurora_forecast(self):
        """Get forecast data and parse for given long/lat."""
-        raw_data = requests.get(self.api_url, headers=self.headers).text
+        raw_data = requests.get(URL, headers=self.headers, timeout=5).text
        forecast_table = [
            row.strip(" ").split("   ")
            for row in raw_data.split("\n")
            if not row.startswith("#")
        ]

-        # convert lat and long for data points in table
+        # Convert lat and long for data points in table
        converted_latitude = round((self.latitude / 180)
                                   * self.number_of_latitude_intervals)
        converted_longitude = round((self.longitude / 360)
@@ -21,19 +21,19 @@ _LOGGER = logging.getLogger(__name__)

 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Setup Axis device event."""
-    add_devices([AxisBinarySensor(discovery_info['axis_event'], hass)], True)
+    add_devices([AxisBinarySensor(hass, discovery_info)], True)


 class AxisBinarySensor(AxisDeviceEvent, BinarySensorDevice):
    """Representation of a binary Axis event."""

-    def __init__(self, axis_event, hass):
+    def __init__(self, hass, event_config):
        """Initialize the binary sensor."""
        self.hass = hass
        self._state = False
-        self._delay = axis_event.device_config(CONF_TRIGGER_TIME)
+        self._delay = event_config[CONF_TRIGGER_TIME]
        self._timer = None
-        AxisDeviceEvent.__init__(self, axis_event)
+        AxisDeviceEvent.__init__(self, event_config)

    @property
    def is_on(self):
@@ -22,6 +22,10 @@ from homeassistant.helpers.event import async_track_state_change

 _LOGGER = logging.getLogger(__name__)

+ATTR_OBSERVATIONS = 'observations'
+ATTR_PROBABILITY = 'probability'
+ATTR_PROBABILITY_THRESHOLD = 'probability_threshold'
+
 CONF_OBSERVATIONS = 'observations'
 CONF_PRIOR = 'prior'
 CONF_PROBABILITY_THRESHOLD = 'probability_threshold'
@@ -29,7 +33,8 @@ CONF_P_GIVEN_F = 'prob_given_false'
 CONF_P_GIVEN_T = 'prob_given_true'
 CONF_TO_STATE = 'to_state'

-DEFAULT_NAME = 'BayesianBinary'
+DEFAULT_NAME = "Bayesian Binary Sensor"
+DEFAULT_PROBABILITY_THRESHOLD = 0.5

 NUMERIC_STATE_SCHEMA = vol.Schema({
    CONF_PLATFORM: 'numeric_state',
@@ -49,16 +54,14 @@ STATE_SCHEMA = vol.Schema({
 }, required=True)

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Optional(CONF_NAME, default=DEFAULT_NAME):
-        cv.string,
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
    vol.Optional(CONF_DEVICE_CLASS): cv.string,
-    vol.Required(CONF_OBSERVATIONS): vol.Schema(
-        vol.All(cv.ensure_list, [vol.Any(NUMERIC_STATE_SCHEMA,
-                                         STATE_SCHEMA)])
-    ),
+    vol.Required(CONF_OBSERVATIONS):
+        vol.Schema(vol.All(cv.ensure_list,
+                           [vol.Any(NUMERIC_STATE_SCHEMA, STATE_SCHEMA)])),
    vol.Required(CONF_PRIOR): vol.Coerce(float),
-    vol.Optional(CONF_PROBABILITY_THRESHOLD):
-        vol.Coerce(float),
+    vol.Optional(CONF_PROBABILITY_THRESHOLD,
+                 default=DEFAULT_PROBABILITY_THRESHOLD): vol.Coerce(float),
 })


@@ -73,16 +76,16 @@ def update_probability(prior, prob_true, prob_false):

@asyncio.coroutine
 def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
-    """Set up the Threshold sensor."""
+    """Set up the Bayesian Binary sensor."""
    name = config.get(CONF_NAME)
    observations = config.get(CONF_OBSERVATIONS)
    prior = config.get(CONF_PRIOR)
-    probability_threshold = config.get(CONF_PROBABILITY_THRESHOLD, 0.5)
+    probability_threshold = config.get(CONF_PROBABILITY_THRESHOLD)
    device_class = config.get(CONF_DEVICE_CLASS)

    async_add_devices([
-        BayesianBinarySensor(name, prior, observations, probability_threshold,
-                             device_class)
+        BayesianBinarySensor(
+            name, prior, observations, probability_threshold, device_class)
    ], True)


@@ -107,7 +110,7 @@ class BayesianBinarySensor(BinarySensorDevice):
        self.entity_obs = dict.fromkeys(to_observe, [])

        for ind, obs in enumerate(self._observations):
-            obs["id"] = ind
+            obs['id'] = ind
            self.entity_obs[obs['entity_id']].append(obs)

        self.watchers = {
@@ -117,7 +120,7 @@ class BayesianBinarySensor(BinarySensorDevice):

    @asyncio.coroutine
    def async_added_to_hass(self):
-        """Call when entity about to be added to hass."""
+        """Call when entity about to be added."""
        @callback
        # pylint: disable=invalid-name
        def async_threshold_sensor_state_listener(entity, old_state,
@@ -135,8 +138,8 @@ class BayesianBinarySensor(BinarySensorDevice):

            prior = self.prior
            for obs in self.current_obs.values():
-                prior = update_probability(prior, obs['prob_true'],
-                                           obs['prob_false'])
+                prior = update_probability(
+                    prior, obs['prob_true'], obs['prob_false'])
            self.probability = prior

            self.hass.async_add_job(self.async_update_ha_state, True)
@@ -206,9 +209,9 @@ class BayesianBinarySensor(BinarySensorDevice):
    def device_state_attributes(self):
        """Return the state attributes of the sensor."""
        return {
-            'observations': [val for val in self.current_obs.values()],
-            'probability': round(self.probability, 2),
-            'probability_threshold': self._probability_threshold
+            ATTR_OBSERVATIONS: [val for val in self.current_obs.values()],
+            ATTR_PROBABILITY: round(self.probability, 2),
+            ATTR_PROBABILITY_THRESHOLD: self._probability_threshold,
        }

    @asyncio.coroutine
@@ -0,0 +1,69 @@
+"""
+Support for binary sensor using GC100.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.gc100/
+"""
+import voluptuous as vol
+
+from homeassistant.components.gc100 import DATA_GC100, CONF_PORTS
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.const import DEVICE_DEFAULT_NAME
+import homeassistant.helpers.config_validation as cv
+
+DEPENDENCIES = ['gc100']
+
+_SENSORS_SCHEMA = vol.Schema({
+    cv.string: cv.string,
+})
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_PORTS): vol.All(cv.ensure_list, [_SENSORS_SCHEMA])
+})
+
+
+# pylint: disable=unused-argument
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the GC100 devices."""
+    binary_sensors = []
+    ports = config.get(CONF_PORTS)
+    for port in ports:
+        for port_addr, port_name in port.items():
+            binary_sensors.append(GC100BinarySensor(
+                port_name, port_addr, hass.data[DATA_GC100]))
+    add_devices(binary_sensors, True)
+
+
+class GC100BinarySensor(BinarySensorDevice):
+    """Representation of a binary sensor from GC100."""
+
+    def __init__(self, name, port_addr, gc100):
+        """Initialize the GC100 binary sensor."""
+        # pylint: disable=no-member
+        self._name = name or DEVICE_DEFAULT_NAME
+        self._port_addr = port_addr
+        self._gc100 = gc100
+        self._state = None
+
+        # Subscribe to be notified about state changes (PUSH)
+        self._gc100.subscribe(self._port_addr, self.set_state)
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._name
+
+    @property
+    def is_on(self):
+        """Return the state of the entity."""
+        return self._state
+
+    def update(self):
+        """Update the sensor state."""
+        self._gc100.read_sensor(self._port_addr, self.set_state)
+
+    def set_state(self, state):
+        """Set the current state."""
+        self._state = state == 1
+        self.schedule_update_ha_state()
@@ -0,0 +1,96 @@
+"""
+Support for monitoring the state of Linode Nodes.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.linode/
+"""
+import logging
+
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.components.linode import (
+    CONF_NODES, ATTR_CREATED, ATTR_NODE_ID, ATTR_NODE_NAME,
+    ATTR_IPV4_ADDRESS, ATTR_IPV6_ADDRESS, ATTR_MEMORY,
+    ATTR_REGION, ATTR_VCPUS, DATA_LINODE)
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_NAME = 'Node'
+DEFAULT_DEVICE_CLASS = 'moving'
+DEPENDENCIES = ['linode']
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_NODES): vol.All(cv.ensure_list, [cv.string]),
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the Linode droplet sensor."""
+    linode = hass.data.get(DATA_LINODE)
+    nodes = config.get(CONF_NODES)
+
+    dev = []
+    for node in nodes:
+        node_id = linode.get_node_id(node)
+        if node_id is None:
+            _LOGGER.error("Node %s is not available", node)
+            return
+        dev.append(LinodeBinarySensor(linode, node_id))
+
+    add_devices(dev, True)
+
+
+class LinodeBinarySensor(BinarySensorDevice):
+    """Representation of a Linode droplet sensor."""
+
+    def __init__(self, li, node_id):
+        """Initialize a new Linode sensor."""
+        self._linode = li
+        self._node_id = node_id
+        self._state = None
+        self.data = None
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        if self.data is not None:
+            return self.data.label
+
+    @property
+    def is_on(self):
+        """Return true if the binary sensor is on."""
+        if self.data is not None:
+            return self.data.status == 'running'
+        return False
+
+    @property
+    def device_class(self):
+        """Return the class of this sensor."""
+        return DEFAULT_DEVICE_CLASS
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes of the Linode Node."""
+        if self.data:
+            return {
+                ATTR_CREATED: self.data.created,
+                ATTR_NODE_ID: self.data.id,
+                ATTR_NODE_NAME: self.data.label,
+                ATTR_IPV4_ADDRESS: self.data.ipv4,
+                ATTR_IPV6_ADDRESS: self.data.ipv6,
+                ATTR_MEMORY: self.data.specs.memory,
+                ATTR_REGION: self.data.region.country,
+                ATTR_VCPUS: self.data.specs.vcpus,
+            }
+        return {}
+
+    def update(self):
+        """Update state of sensor."""
+        self._linode.update()
+        if self._linode.data is not None:
+            for node in self._linode.data:
+                if node.id == self._node_id:
+                    self.data = node
@@ -0,0 +1,64 @@
+"""
+Support for showing random states.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.random/
+"""
+import asyncio
+import logging
+
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA, DEVICE_CLASSES_SCHEMA)
+from homeassistant.const import CONF_NAME, CONF_DEVICE_CLASS
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_NAME = 'Random Binary Sensor'
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
+})
+
+
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+    """Set up the Random binary sensor."""
+    name = config.get(CONF_NAME)
+    device_class = config.get(CONF_DEVICE_CLASS)
+
+    async_add_devices([RandomSensor(name, device_class)], True)
+
+
+class RandomSensor(BinarySensorDevice):
+    """Representation of a Random binary sensor."""
+
+    def __init__(self, name, device_class):
+        """Initialize the Random binary sensor."""
+        self._name = name
+        self._device_class = device_class
+        self._state = None
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._name
+
+    @property
+    def is_on(self):
+        """Return true if sensor is on."""
+        return self._state
+
+    @property
+    def device_class(self):
+        """Return the sensor class of the sensor."""
+        return self._device_class
+
+    @asyncio.coroutine
+    def async_update(self):
+        """Get new state and update the sensor's state."""
+        from random import getrandbits
+        self._state = bool(getrandbits(1))
@@ -62,7 +62,6 @@ def setup_platform(hass, config, add_devices_callback, discovery_info=None):
                                    entity[CONF_COMMAND_ON],
                                    entity[CONF_COMMAND_OFF])
        device.hass = hass
-        device.is_lighting4 = (packet_id[2:4] == '13')
        sensors.append(device)
        rfxtrx.RFX_DEVICES[device_id] = device

@@ -86,17 +85,16 @@ def setup_platform(hass, config, add_devices_callback, discovery_info=None):
            if not config[ATTR_AUTOMATIC_ADD]:
                return

-            poss_dev = rfxtrx.find_possible_pt2262_device(device_id)
-
-            if poss_dev is not None:
-                poss_id = slugify(poss_dev.event.device.id_string.lower())
-                _LOGGER.info("Found possible matching deviceid %s.",
-                             poss_id)
+            if event.device.packettype == 0x13:
+                poss_dev = rfxtrx.find_possible_pt2262_device(device_id)
+                if poss_dev is not None:
+                    poss_id = slugify(poss_dev.event.device.id_string.lower())
+                    _LOGGER.info("Found possible matching deviceid %s.",
+                                 poss_id)

            pkt_id = "".join("{0:02x}".format(x) for x in event.data)
            sensor = RfxtrxBinarySensor(event, pkt_id)
            sensor.hass = hass
-            sensor.is_lighting4 = (pkt_id[2:4] == '13')
            rfxtrx.RFX_DEVICES[device_id] = sensor
            add_devices_callback([sensor])
            _LOGGER.info("Added binary sensor %s "
@@ -114,6 +112,7 @@ def setup_platform(hass, config, add_devices_callback, discovery_info=None):
                         slugify(event.device.id_string.lower()),
                         event.device.__class__.__name__,
                         event.device.subtype)
+
        if sensor.is_lighting4:
            if sensor.data_bits is not None:
                cmd = rfxtrx.get_pt2262_cmd(device_id, sensor.data_bits)
@@ -154,7 +153,7 @@ class RfxtrxBinarySensor(BinarySensorDevice):
        self._device_class = device_class
        self._off_delay = off_delay
        self._state = False
-        self.is_lighting4 = False
+        self.is_lighting4 = (event.device.packettype == 0x13)
        self.delay_listener = None
        self._data_bits = data_bits
        self._cmd_on = cmd_on
@@ -11,7 +11,7 @@ import voluptuous as vol
 import homeassistant.helpers.config_validation as cv

 from homeassistant.components.ring import (
-    CONF_ATTRIBUTION, DEFAULT_ENTITY_NAMESPACE)
+    CONF_ATTRIBUTION, DEFAULT_ENTITY_NAMESPACE, DATA_RING)

 from homeassistant.const import (
    ATTR_ATTRIBUTION, CONF_ENTITY_NAMESPACE, CONF_MONITORED_CONDITIONS)
@@ -28,20 +28,20 @@ SCAN_INTERVAL = timedelta(seconds=5)
 # Sensor types: Name, category, device_class
 SENSOR_TYPES = {
    'ding': ['Ding', ['doorbell'], 'occupancy'],
-    'motion': ['Motion', ['doorbell'], 'motion'],
+    'motion': ['Motion', ['doorbell', 'stickup_cams'], 'motion'],
 }

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Optional(CONF_ENTITY_NAMESPACE, default=DEFAULT_ENTITY_NAMESPACE):
        cv.string,
-    vol.Required(CONF_MONITORED_CONDITIONS, default=[]):
+    vol.Required(CONF_MONITORED_CONDITIONS, default=list(SENSOR_TYPES)):
        vol.All(cv.ensure_list, [vol.In(SENSOR_TYPES)]),
 })


 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up a sensor for a Ring device."""
-    ring = hass.data.get('ring')
+    ring = hass.data[DATA_RING]

    sensors = []
    for sensor_type in config.get(CONF_MONITORED_CONDITIONS):
@@ -50,6 +50,12 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
                sensors.append(RingBinarySensor(hass,
                                                device,
                                                sensor_type))
+
+        for device in ring.stickup_cams:
+            if 'stickup_cams' in SENSOR_TYPES[sensor_type][1]:
+                sensors.append(RingBinarySensor(hass,
+                                                device,
+                                                sensor_type))
    add_devices(sensors, True)
    return True

@@ -67,7 +67,7 @@ class SpcBinarySensor(BinarySensorDevice):
        spc_registry.register_sensor_device(zone_id, self)

    @asyncio.coroutine
-    def async_update_from_spc(self, state):
+    def async_update_from_spc(self, state, extra):
        """Update the state of the device."""
        self._state = state
        yield from self.async_update_ha_state()
@@ -0,0 +1,34 @@
+"""
+Support for binary sensors using Tellstick Net.
+
+This platform uses the Telldus Live online service.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.tellduslive/
+
+"""
+import logging
+
+from homeassistant.components.tellduslive import TelldusLiveEntity
+from homeassistant.components.binary_sensor import BinarySensorDevice
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up Tellstick sensors."""
+    if discovery_info is None:
+        return
+    add_devices(
+        TelldusLiveSensor(hass, binary_sensor)
+        for binary_sensor in discovery_info
+    )
+
+
+class TelldusLiveSensor(TelldusLiveEntity, BinarySensorDevice):
+    """Representation of a Tellstick sensor."""
+
+    @property
+    def is_on(self):
+        """Return true if switch is on."""
+        return self.device.is_on
@@ -1,11 +1,13 @@
 """
-A sensor that monitors trands in other components.
+A sensor that monitors trends in other components.

 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/sensor.trend/
 """
 import asyncio
+from collections import deque
 import logging
+import math

 import voluptuous as vol

@@ -16,21 +18,40 @@ from homeassistant.components.binary_sensor import (
    BinarySensorDevice, ENTITY_ID_FORMAT, PLATFORM_SCHEMA,
    DEVICE_CLASSES_SCHEMA)
 from homeassistant.const import (
-    ATTR_FRIENDLY_NAME, ATTR_ENTITY_ID, CONF_DEVICE_CLASS, STATE_UNKNOWN)
+    ATTR_ENTITY_ID, ATTR_FRIENDLY_NAME,
+    CONF_DEVICE_CLASS, CONF_ENTITY_ID, CONF_FRIENDLY_NAME,
+    STATE_UNKNOWN)
 from homeassistant.helpers.entity import generate_entity_id
-from homeassistant.helpers.event import track_state_change
+from homeassistant.helpers.event import async_track_state_change
+from homeassistant.util import utcnow
+
+REQUIREMENTS = ['numpy==1.13.3']

 _LOGGER = logging.getLogger(__name__)
+
+ATTR_ATTRIBUTE = 'attribute'
+ATTR_GRADIENT = 'gradient'
+ATTR_MIN_GRADIENT = 'min_gradient'
+ATTR_INVERT = 'invert'
+ATTR_SAMPLE_DURATION = 'sample_duration'
+ATTR_SAMPLE_COUNT = 'sample_count'
+
 CONF_SENSORS = 'sensors'
 CONF_ATTRIBUTE = 'attribute'
+CONF_MAX_SAMPLES = 'max_samples'
+CONF_MIN_GRADIENT = 'min_gradient'
 CONF_INVERT = 'invert'
+CONF_SAMPLE_DURATION = 'sample_duration'

 SENSOR_SCHEMA = vol.Schema({
-    vol.Required(ATTR_ENTITY_ID): cv.entity_id,
+    vol.Required(CONF_ENTITY_ID): cv.entity_id,
    vol.Optional(CONF_ATTRIBUTE): cv.string,
-    vol.Optional(ATTR_FRIENDLY_NAME): cv.string,
-    vol.Optional(CONF_INVERT, default=False): cv.boolean,
    vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
+    vol.Optional(CONF_FRIENDLY_NAME): cv.string,
+    vol.Optional(CONF_MAX_SAMPLES, default=2): cv.positive_int,
+    vol.Optional(CONF_MIN_GRADIENT, default=0.0): vol.Coerce(float),
+    vol.Optional(CONF_INVERT, default=False): cv.boolean,
+    vol.Optional(CONF_SAMPLE_DURATION, default=0): cv.positive_int,
 })

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
@@ -43,17 +64,21 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the trend sensors."""
    sensors = []

-    for device, device_config in config[CONF_SENSORS].items():
+    for device_id, device_config in config[CONF_SENSORS].items():
        entity_id = device_config[ATTR_ENTITY_ID]
        attribute = device_config.get(CONF_ATTRIBUTE)
-        friendly_name = device_config.get(ATTR_FRIENDLY_NAME, device)
        device_class = device_config.get(CONF_DEVICE_CLASS)
+        friendly_name = device_config.get(ATTR_FRIENDLY_NAME, device_id)
        invert = device_config[CONF_INVERT]
+        max_samples = device_config[CONF_MAX_SAMPLES]
+        min_gradient = device_config[CONF_MIN_GRADIENT]
+        sample_duration = device_config[CONF_SAMPLE_DURATION]

        sensors.append(
            SensorTrend(
-                hass, device, friendly_name, entity_id, attribute,
-                device_class, invert)
+                hass, device_id, friendly_name, entity_id, attribute,
+                device_class, invert, max_samples, min_gradient,
+                sample_duration)
            )
    if not sensors:
        _LOGGER.error("No sensors added")
@@ -65,30 +90,23 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 class SensorTrend(BinarySensorDevice):
    """Representation of a trend Sensor."""

-    def __init__(self, hass, device_id, friendly_name,
-                 target_entity, attribute, device_class, invert):
+    def __init__(self, hass, device_id, friendly_name, entity_id,
+                 attribute, device_class, invert, max_samples,
+                 min_gradient, sample_duration):
        """Initialize the sensor."""
        self._hass = hass
        self.entity_id = generate_entity_id(
            ENTITY_ID_FORMAT, device_id, hass=hass)
        self._name = friendly_name
-        self._target_entity = target_entity
+        self._entity_id = entity_id
        self._attribute = attribute
        self._device_class = device_class
        self._invert = invert
+        self._sample_duration = sample_duration
+        self._min_gradient = min_gradient
+        self._gradient = None
        self._state = None
-        self.from_state = None
-        self.to_state = None
-
-        @callback
-        def trend_sensor_state_listener(entity, old_state, new_state):
-            """Handle the target device state changes."""
-            self.from_state = old_state
-            self.to_state = new_state
-            hass.async_add_job(self.async_update_ha_state(True))
-
-        track_state_change(hass, target_entity,
-                           trend_sensor_state_listener)
+        self.samples = deque(maxlen=max_samples)

    @property
    def name(self):
@@ -105,33 +123,77 @@ class SensorTrend(BinarySensorDevice):
        """Return the sensor class of the sensor."""
        return self._device_class

+    @property
+    def device_state_attributes(self):
+        """Return the state attributes of the sensor."""
+        return {
+            ATTR_ENTITY_ID: self._entity_id,
+            ATTR_FRIENDLY_NAME: self._name,
+            ATTR_INVERT: self._invert,
+            ATTR_GRADIENT: self._gradient,
+            ATTR_MIN_GRADIENT: self._min_gradient,
+            ATTR_SAMPLE_DURATION: self._sample_duration,
+            ATTR_SAMPLE_COUNT: len(self.samples),
+        }
+
    @property
    def should_poll(self):
        """No polling needed."""
        return False

+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Complete device setup after being added to hass."""
+        @callback
+        def trend_sensor_state_listener(entity, old_state, new_state):
+            """Handle state changes on the observed device."""
+            try:
+                if self._attribute:
+                    state = new_state.attributes.get(self._attribute)
+                else:
+                    state = new_state.state
+                if state != STATE_UNKNOWN:
+                    sample = (utcnow().timestamp(), float(state))
+                    self.samples.append(sample)
+                    self.async_schedule_update_ha_state(True)
+            except (ValueError, TypeError) as ex:
+                _LOGGER.error(ex)
+
+        async_track_state_change(
+            self.hass, self._entity_id,
+            trend_sensor_state_listener)
+
    @asyncio.coroutine
    def async_update(self):
        """Get the latest data and update the states."""
-        if self.from_state is None or self.to_state is None:
-            return
-        if (self.from_state.state == STATE_UNKNOWN or
-                self.to_state.state == STATE_UNKNOWN):
-            return
-        try:
-            if self._attribute:
-                from_value = float(
-                    self.from_state.attributes.get(self._attribute))
-                to_value = float(
-                    self.to_state.attributes.get(self._attribute))
-            else:
-                from_value = float(self.from_state.state)
-                to_value = float(self.to_state.state)
+        # Remove outdated samples
+        if self._sample_duration > 0:
+            cutoff = utcnow().timestamp() - self._sample_duration
+            while self.samples and self.samples[0][0] < cutoff:
+                self.samples.popleft()

-            self._state = to_value > from_value
-            if self._invert:
-                self._state = not self._state
+        if len(self.samples) < 2:
+            return

-        except (ValueError, TypeError) as ex:
-            self._state = None
-            _LOGGER.error(ex)
+        # Calculate gradient of linear trend
+        yield from self.hass.async_add_job(self._calculate_gradient)
+
+        # Update state
+        self._state = (
+            abs(self._gradient) > abs(self._min_gradient) and
+            math.copysign(self._gradient, self._min_gradient) == self._gradient
+        )
+
+        if self._invert:
+            self._state = not self._state
+
+    def _calculate_gradient(self):
+        """Compute the linear trend gradient of the current samples.
+
+        This need run inside executor.
+        """
+        import numpy as np
+        timestamps = np.array([t for t, _ in self.samples])
+        values = np.array([s for _, s in self.samples])
+        coeffs = np.polyfit(timestamps, values, 1)
+        self._gradient = coeffs[0]
@@ -0,0 +1,103 @@
+"""
+Support for monitoring the state of Vultr subscriptions (VPS).
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.vultr/
+"""
+import logging
+
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.const import CONF_NAME
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.components.vultr import (
+    CONF_SUBSCRIPTION, ATTR_AUTO_BACKUPS, ATTR_ALLOWED_BANDWIDTH,
+    ATTR_CREATED_AT, ATTR_SUBSCRIPTION_ID, ATTR_SUBSCRIPTION_NAME,
+    ATTR_IPV4_ADDRESS, ATTR_IPV6_ADDRESS, ATTR_MEMORY, ATTR_DISK,
+    ATTR_COST_PER_MONTH, ATTR_OS, ATTR_REGION, ATTR_VCPUS, DATA_VULTR)
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_DEVICE_CLASS = 'power'
+DEFAULT_NAME = 'Vultr {}'
+DEPENDENCIES = ['vultr']
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_SUBSCRIPTION): cv.string,
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the Vultr subscription (server) sensor."""
+    vultr = hass.data[DATA_VULTR]
+
+    subscription = config.get(CONF_SUBSCRIPTION)
+    name = config.get(CONF_NAME)
+
+    if subscription not in vultr.data:
+        _LOGGER.error("Subscription %s not found", subscription)
+        return False
+
+    add_devices([VultrBinarySensor(vultr, subscription, name)], True)
+
+
+class VultrBinarySensor(BinarySensorDevice):
+    """Representation of a Vultr subscription sensor."""
+
+    def __init__(self, vultr, subscription, name):
+        """Initialize a new Vultr sensor."""
+        self._vultr = vultr
+        self._name = name
+
+        self.subscription = subscription
+        self.data = None
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        try:
+            return self._name.format(self.data['label'])
+        except (KeyError, TypeError):
+            return self._name
+
+    @property
+    def icon(self):
+        """Return the icon of this server."""
+        return 'mdi:server' if self.is_on else 'mdi:server-off'
+
+    @property
+    def is_on(self):
+        """Return true if the binary sensor is on."""
+        return self.data['power_status'] == 'running'
+
+    @property
+    def device_class(self):
+        """Return the class of this sensor."""
+        return DEFAULT_DEVICE_CLASS
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes of the Vultr subscription."""
+        return {
+            ATTR_ALLOWED_BANDWIDTH: self.data.get('allowed_bandwidth_gb'),
+            ATTR_AUTO_BACKUPS: self.data.get('auto_backups'),
+            ATTR_COST_PER_MONTH: self.data.get('cost_per_month'),
+            ATTR_CREATED_AT: self.data.get('date_created'),
+            ATTR_DISK: self.data.get('disk'),
+            ATTR_IPV4_ADDRESS: self.data.get('main_ip'),
+            ATTR_IPV6_ADDRESS: self.data.get('v6_main_ip'),
+            ATTR_MEMORY: self.data.get('ram'),
+            ATTR_OS: self.data.get('os'),
+            ATTR_REGION: self.data.get('location'),
+            ATTR_SUBSCRIPTION_ID: self.data.get('SUBID'),
+            ATTR_SUBSCRIPTION_NAME: self.data.get('label'),
+            ATTR_VCPUS: self.data.get('vcpu_count')
+        }
+
+    def update(self):
+        """Update state of sensor."""
+        self._vultr.update()
+        self.data = self._vultr.data[self.subscription]
@@ -25,13 +25,9 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    for (_, gateway) in hass.data[PY_XIAOMI_GATEWAY].gateways.items():
        for device in gateway.devices['binary_sensor']:
            model = device['model']
-            if model == 'motion':
+            if model in ['motion', 'sensor_motion.aq2']:
                devices.append(XiaomiMotionSensor(device, hass, gateway))
-            elif model == 'sensor_motion.aq2':
-                devices.append(XiaomiMotionSensor(device, hass, gateway))
-            elif model == 'magnet':
-                devices.append(XiaomiDoorSensor(device, gateway))
-            elif model == 'sensor_magnet.aq2':
+            elif model in ['magnet', 'sensor_magnet.aq2']:
                devices.append(XiaomiDoorSensor(device, gateway))
            elif model == 'sensor_wleak.aq1':
                devices.append(XiaomiWaterLeakSensor(device, gateway))
@@ -39,10 +35,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
                devices.append(XiaomiSmokeSensor(device, gateway))
            elif model == 'natgas':
                devices.append(XiaomiNatgasSensor(device, gateway))
-            elif model == 'switch':
-                devices.append(XiaomiButton(device, 'Switch', 'status',
-                                            hass, gateway))
-            elif model == 'sensor_switch.aq2':
+            elif model in ['switch', 'sensor_switch.aq2', 'sensor_switch.aq3']:
                devices.append(XiaomiButton(device, 'Switch', 'status',
                                            hass, gateway))
            elif model == '86sw1':
@@ -289,9 +282,17 @@ class XiaomiButton(XiaomiBinarySensor):
    def __init__(self, device, name, data_key, hass, xiaomi_hub):
        """Initialize the XiaomiButton."""
        self._hass = hass
+        self._last_action = None
        XiaomiBinarySensor.__init__(self, device, name, xiaomi_hub,
                                    data_key, None)

+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        attrs = {ATTR_LAST_ACTION: self._last_action}
+        attrs.update(super().device_state_attributes)
+        return attrs
+
    def parse_data(self, data):
        """Parse data sent by gateway."""
        value = data.get(self._data_key)
@@ -317,6 +318,8 @@ class XiaomiButton(XiaomiBinarySensor):
            'entity_id': self.entity_id,
            'click_type': click_type
        })
+        self._last_action = click_type
+
        if value in ['long_click_press', 'long_click_release']:
            return True
        return False
@@ -4,16 +4,17 @@ Support for BloomSky weather station.
 For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/bloomsky/
 """
-import logging
 from datetime import timedelta
+import logging

+from aiohttp.hdrs import AUTHORIZATION
 import requests
 import voluptuous as vol

 from homeassistant.const import CONF_API_KEY
 from homeassistant.helpers import discovery
-from homeassistant.util import Throttle
 import homeassistant.helpers.config_validation as cv
+from homeassistant.util import Throttle

 _LOGGER = logging.getLogger(__name__)

@@ -68,7 +69,7 @@ class BloomSky(object):
        """Use the API to retrieve a list of devices."""
        _LOGGER.debug("Fetching BloomSky update")
        response = requests.get(
-            self.API_URL, headers={"Authorization": self._api_key}, timeout=10)
+            self.API_URL, headers={AUTHORIZATION: self._api_key}, timeout=10)
        if response.status_code == 401:
            raise RuntimeError("Invalid API_KEY")
        elif response.status_code != 200:
@@ -1,19 +1,21 @@
+# Describes the format for available calendar services
+
 todoist:
  new_task:
    description: Create a new task and add it to a project.
    fields:
      content: 
-        description: The name of the task. [Required]
+        description: The name of the task (Required).
        example: Pick up the mail
      project:
-        description: The name of the project this task should belong to. Defaults to Inbox. [Optional]
+        description: The name of the project this task should belong to. Defaults to Inbox (Optional).
        example: Errands
      labels:
-        description: Any labels that you want to apply to this task, separated by a comma. [Optional]
+        description: Any labels that you want to apply to this task, separated by a comma (Optional).
        example: Chores,Deliveries
      priority:
-        description: The priority of this task, from 1 (normal) to 4 (urgent). [Optional]
+        description: The priority of this task, from 1 (normal) to 4 (urgent) (Optional).
        example: 2
      due_date:
-        description: The day this task is due, in format YYYY-MM-DD. [Optional]
+        description: The day this task is due, in format YYYY-MM-DD (Optional).
        example: "2018-04-01"
@@ -29,18 +29,22 @@ from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.config_validation import PLATFORM_SCHEMA  # noqa
 from homeassistant.components.http import HomeAssistantView, KEY_AUTHENTICATED
-from homeassistant.helpers.event import async_track_time_interval
 import homeassistant.helpers.config_validation as cv

+DOMAIN = 'camera'
+DEPENDENCIES = ['http']
+
 _LOGGER = logging.getLogger(__name__)

-SERVICE_EN_MOTION = 'enable_motion_detection'
-SERVICE_DISEN_MOTION = 'disable_motion_detection'
-DOMAIN = 'camera'
-DEPENDENCIES = ['http']
+SERVICE_ENABLE_MOTION = 'enable_motion_detection'
+SERVICE_DISABLE_MOTION = 'disable_motion_detection'
+SERVICE_SNAPSHOT = 'snapshot'
+
 SCAN_INTERVAL = timedelta(seconds=30)
 ENTITY_ID_FORMAT = DOMAIN + '.{}'

+ATTR_FILENAME = 'filename'
+
 STATE_RECORDING = 'recording'
 STATE_STREAMING = 'streaming'
 STATE_IDLE = 'idle'
@@ -55,13 +59,17 @@ CAMERA_SERVICE_SCHEMA = vol.Schema({
    vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
 })

+CAMERA_SERVICE_SNAPSHOT = CAMERA_SERVICE_SCHEMA.extend({
+    vol.Required(ATTR_FILENAME): cv.template
+})
+

@bind_hass
 def enable_motion_detection(hass, entity_id=None):
    """Enable Motion Detection."""
    data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
    hass.async_add_job(hass.services.async_call(
-        DOMAIN, SERVICE_EN_MOTION, data))
+        DOMAIN, SERVICE_ENABLE_MOTION, data))


@bind_hass
@@ -69,9 +77,20 @@ def disable_motion_detection(hass, entity_id=None):
    """Disable Motion Detection."""
    data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
    hass.async_add_job(hass.services.async_call(
-        DOMAIN, SERVICE_DISEN_MOTION, data))
+        DOMAIN, SERVICE_DISABLE_MOTION, data))


+@bind_hass
+def async_snapshot(hass, filename, entity_id=None):
+    """Make a snapshot from a camera."""
+    data = {ATTR_ENTITY_ID: entity_id} if entity_id else {}
+    data[ATTR_FILENAME] = filename
+
+    hass.async_add_job(hass.services.async_call(
+        DOMAIN, SERVICE_SNAPSHOT, data))
+
+
+@bind_hass
@asyncio.coroutine
 def async_get_image(hass, entity_id, timeout=10):
    """Fetch a image from a camera entity."""
@@ -119,7 +138,8 @@ def async_setup(hass, config):
            entity.async_update_token()
            hass.async_add_job(entity.async_update_ha_state())

-    async_track_time_interval(hass, update_tokens, TOKEN_CHANGE_INTERVAL)
+    hass.helpers.event.async_track_time_interval(
+        update_tokens, TOKEN_CHANGE_INTERVAL)

    @asyncio.coroutine
    def async_handle_camera_service(service):
@@ -128,9 +148,9 @@ def async_setup(hass, config):

        update_tasks = []
        for camera in target_cameras:
-            if service.service == SERVICE_EN_MOTION:
+            if service.service == SERVICE_ENABLE_MOTION:
                yield from camera.async_enable_motion_detection()
-            elif service.service == SERVICE_DISEN_MOTION:
+            elif service.service == SERVICE_DISABLE_MOTION:
                yield from camera.async_disable_motion_detection()

            if not camera.should_poll:
@@ -140,16 +160,50 @@ def async_setup(hass, config):
        if update_tasks:
            yield from asyncio.wait(update_tasks, loop=hass.loop)

+    @asyncio.coroutine
+    def async_handle_snapshot_service(service):
+        """Handle snapshot services calls."""
+        target_cameras = component.async_extract_from_service(service)
+        filename = service.data[ATTR_FILENAME]
+        filename.hass = hass
+
+        for camera in target_cameras:
+            snapshot_file = filename.async_render(
+                variables={ATTR_ENTITY_ID: camera})
+
+            # check if we allow to access to that file
+            if not hass.config.is_allowed_path(snapshot_file):
+                _LOGGER.error(
+                    "Can't write %s, no access to path!", snapshot_file)
+                continue
+
+            image = yield from camera.async_camera_image()
+
+            def _write_image(to_file, image_data):
+                """Executor helper to write image."""
+                with open(to_file, 'wb') as img_file:
+                    img_file.write(image_data)
+
+            try:
+                yield from hass.async_add_job(
+                    _write_image, snapshot_file, image)
+            except OSError as err:
+                _LOGGER.error("Can't write image to file: %s", err)
+
    descriptions = yield from hass.async_add_job(
        load_yaml_config_file, os.path.join(
            os.path.dirname(__file__), 'services.yaml'))

    hass.services.async_register(
-        DOMAIN, SERVICE_EN_MOTION, async_handle_camera_service,
-        descriptions.get(SERVICE_EN_MOTION), schema=CAMERA_SERVICE_SCHEMA)
+        DOMAIN, SERVICE_ENABLE_MOTION, async_handle_camera_service,
+        descriptions.get(SERVICE_ENABLE_MOTION), schema=CAMERA_SERVICE_SCHEMA)
    hass.services.async_register(
-        DOMAIN, SERVICE_DISEN_MOTION, async_handle_camera_service,
-        descriptions.get(SERVICE_DISEN_MOTION), schema=CAMERA_SERVICE_SCHEMA)
+        DOMAIN, SERVICE_DISABLE_MOTION, async_handle_camera_service,
+        descriptions.get(SERVICE_DISABLE_MOTION), schema=CAMERA_SERVICE_SCHEMA)
+    hass.services.async_register(
+        DOMAIN, SERVICE_SNAPSHOT, async_handle_snapshot_service,
+        descriptions.get(SERVICE_SNAPSHOT),
+        schema=CAMERA_SERVICE_SNAPSHOT)

    return True

@@ -19,7 +19,7 @@ from homeassistant.helpers.aiohttp_client import async_aiohttp_proxy_stream

 _LOGGER = logging.getLogger(__name__)

-SCAN_INTERVAL = timedelta(minutes=10)
+SCAN_INTERVAL = timedelta(seconds=90)

 ARLO_MODE_ARMED = 'armed'
 ARLO_MODE_DISARMED = 'disarmed'
@@ -31,6 +31,7 @@ ATTR_MOTION = 'motion_detection_sensitivity'
 ATTR_POWERSAVE = 'power_save_mode'
 ATTR_SIGNAL_STRENGTH = 'signal_strength'
 ATTR_UNSEEN_VIDEOS = 'unseen_videos'
+ATTR_LAST_REFRESH = 'last_refresh'

 CONF_FFMPEG_ARGUMENTS = 'ffmpeg_arguments'

@@ -73,6 +74,8 @@ class ArloCam(Camera):
        self._motion_status = False
        self._ffmpeg = hass.data[DATA_FFMPEG]
        self._ffmpeg_arguments = device_info.get(CONF_FFMPEG_ARGUMENTS)
+        self._last_refresh = None
+        self._camera.base_station.refresh_rate = SCAN_INTERVAL.total_seconds()
        self.attrs = {}

    def camera_image(self):
@@ -105,14 +108,17 @@ class ArloCam(Camera):
    def device_state_attributes(self):
        """Return the state attributes."""
        return {
-            ATTR_BATTERY_LEVEL: self.attrs.get(ATTR_BATTERY_LEVEL),
-            ATTR_BRIGHTNESS: self.attrs.get(ATTR_BRIGHTNESS),
-            ATTR_FLIPPED: self.attrs.get(ATTR_FLIPPED),
-            ATTR_MIRRORED: self.attrs.get(ATTR_MIRRORED),
-            ATTR_MOTION: self.attrs.get(ATTR_MOTION),
-            ATTR_POWERSAVE: self.attrs.get(ATTR_POWERSAVE),
-            ATTR_SIGNAL_STRENGTH: self.attrs.get(ATTR_SIGNAL_STRENGTH),
-            ATTR_UNSEEN_VIDEOS: self.attrs.get(ATTR_UNSEEN_VIDEOS),
+            name: value for name, value in (
+                (ATTR_BATTERY_LEVEL, self._camera.battery_level),
+                (ATTR_BRIGHTNESS, self._camera.brightness),
+                (ATTR_FLIPPED, self._camera.flip_state),
+                (ATTR_MIRRORED, self._camera.mirror_state),
+                (ATTR_MOTION, self._camera.motion_detection_sensitivity),
+                (ATTR_POWERSAVE, POWERSAVE_MODE_MAPPING.get(
+                    self._camera.powersave_mode)),
+                (ATTR_SIGNAL_STRENGTH, self._camera.signal_strength),
+                (ATTR_UNSEEN_VIDEOS, self._camera.unseen_videos),
+            ) if value is not None
        }

    @property
@@ -160,13 +166,4 @@ class ArloCam(Camera):

    def update(self):
        """Add an attribute-update task to the executor pool."""
-        self.attrs[ATTR_BATTERY_LEVEL] = self._camera.get_battery_level
-        self.attrs[ATTR_BRIGHTNESS] = self._camera.get_battery_level
-        self.attrs[ATTR_FLIPPED] = self._camera.get_flip_state,
-        self.attrs[ATTR_MIRRORED] = self._camera.get_mirror_state,
-        self.attrs[
-            ATTR_MOTION] = self._camera.get_motion_detection_sensitivity,
-        self.attrs[ATTR_POWERSAVE] = POWERSAVE_MODE_MAPPING[
-            self._camera.get_powersave_mode],
-        self.attrs[ATTR_SIGNAL_STRENGTH] = self._camera.get_signal_strength,
-        self.attrs[ATTR_UNSEEN_VIDEOS] = self._camera.unseen_videos
+        self._camera.update()
@@ -11,7 +11,7 @@ from homeassistant.const import (
    CONF_AUTHENTICATION, HTTP_DIGEST_AUTHENTICATION)
 from homeassistant.components.camera.mjpeg import (
    CONF_MJPEG_URL, CONF_STILL_IMAGE_URL, MjpegCamera)
-from homeassistant.helpers.dispatcher import async_dispatcher_connect
+from homeassistant.helpers.dispatcher import dispatcher_connect

 _LOGGER = logging.getLogger(__name__)

@@ -52,9 +52,9 @@ class AxisCamera(MjpegCamera):
        """Initialize Axis Communications camera component."""
        super().__init__(hass, config)
        self.port = port
-        async_dispatcher_connect(hass,
-                                 DOMAIN + '_' + config[CONF_NAME] + '_new_ip',
-                                 self._new_ip)
+        dispatcher_connect(hass,
+                           DOMAIN + '_' + config[CONF_NAME] + '_new_ip',
+                           self._new_ip)

    def _new_ip(self, host):
        """Set new IP for video stream."""
@@ -0,0 +1,143 @@
+"""
+This component provides support to the Ring Door Bell camera.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/camera.ring/
+"""
+import asyncio
+import logging
+
+from datetime import timedelta
+
+import voluptuous as vol
+
+from homeassistant.helpers import config_validation as cv
+from homeassistant.components.ring import DATA_RING, CONF_ATTRIBUTION
+from homeassistant.components.camera import Camera, PLATFORM_SCHEMA
+from homeassistant.components.ffmpeg import DATA_FFMPEG
+from homeassistant.const import ATTR_ATTRIBUTION, CONF_SCAN_INTERVAL
+from homeassistant.helpers.aiohttp_client import async_aiohttp_proxy_stream
+from homeassistant.util import dt as dt_util
+
+CONF_FFMPEG_ARGUMENTS = 'ffmpeg_arguments'
+
+DEPENDENCIES = ['ring', 'ffmpeg']
+
+FORCE_REFRESH_INTERVAL = timedelta(minutes=45)
+
+_LOGGER = logging.getLogger(__name__)
+
+SCAN_INTERVAL = timedelta(seconds=90)
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_FFMPEG_ARGUMENTS): cv.string,
+    vol.Optional(CONF_SCAN_INTERVAL, default=SCAN_INTERVAL):
+        cv.time_period,
+})
+
+
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+    """Set up a Ring Door Bell and StickUp Camera."""
+    ring = hass.data[DATA_RING]
+
+    cams = []
+    for camera in ring.doorbells:
+        cams.append(RingCam(hass, camera, config))
+
+    for camera in ring.stickup_cams:
+        cams.append(RingCam(hass, camera, config))
+
+    async_add_devices(cams, True)
+    return True
+
+
+class RingCam(Camera):
+    """An implementation of a Ring Door Bell camera."""
+
+    def __init__(self, hass, camera, device_info):
+        """Initialize a Ring Door Bell camera."""
+        super(RingCam, self).__init__()
+        self._camera = camera
+        self._hass = hass
+        self._name = self._camera.name
+        self._ffmpeg = hass.data[DATA_FFMPEG]
+        self._ffmpeg_arguments = device_info.get(CONF_FFMPEG_ARGUMENTS)
+        self._last_video_id = self._camera.last_recording_id
+        self._video_url = self._camera.recording_url(self._last_video_id)
+        self._utcnow = dt_util.utcnow()
+        self._expires_at = FORCE_REFRESH_INTERVAL + self._utcnow
+
+    @property
+    def name(self):
+        """Return the name of this camera."""
+        return self._name
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return {
+            ATTR_ATTRIBUTION: CONF_ATTRIBUTION,
+            'device_id': self._camera.id,
+            'firmware': self._camera.firmware,
+            'kind': self._camera.kind,
+            'timezone': self._camera.timezone,
+            'type': self._camera.family,
+            'video_url': self._video_url,
+            'video_id': self._last_video_id
+        }
+
+    @asyncio.coroutine
+    def async_camera_image(self):
+        """Return a still image response from the camera."""
+        from haffmpeg import ImageFrame, IMAGE_JPEG
+        ffmpeg = ImageFrame(self._ffmpeg.binary, loop=self.hass.loop)
+
+        if self._video_url is None:
+            return
+
+        image = yield from asyncio.shield(ffmpeg.get_image(
+            self._video_url, output_format=IMAGE_JPEG,
+            extra_cmd=self._ffmpeg_arguments), loop=self.hass.loop)
+        return image
+
+    @asyncio.coroutine
+    def handle_async_mjpeg_stream(self, request):
+        """Generate an HTTP MJPEG stream from the camera."""
+        from haffmpeg import CameraMjpeg
+
+        if self._video_url is None:
+            return
+
+        stream = CameraMjpeg(self._ffmpeg.binary, loop=self.hass.loop)
+        yield from stream.open_camera(
+            self._video_url, extra_cmd=self._ffmpeg_arguments)
+
+        yield from async_aiohttp_proxy_stream(
+            self.hass, request, stream,
+            'multipart/x-mixed-replace;boundary=ffserver')
+        yield from stream.close()
+
+    @property
+    def should_poll(self):
+        """Update the image periodically."""
+        return True
+
+    def update(self):
+        """Update camera entity and refresh attributes."""
+        _LOGGER.debug("Checking if Ring DoorBell needs to refresh video_url")
+
+        self._camera.update()
+        self._utcnow = dt_util.utcnow()
+
+        last_recording_id = self._camera.last_recording_id
+
+        if self._last_video_id != last_recording_id or \
+           self._utcnow >= self._expires_at:
+
+            _LOGGER.info("Ring DoorBell properties refreshed")
+
+            # update attributes if new video or if URL has expired
+            self._last_video_id = self._camera.last_recording_id
+            self._video_url = self._camera.recording_url(self._last_video_id)
+            self._expires_at = FORCE_REFRESH_INTERVAL + self._utcnow
@@ -1,17 +1,25 @@
 # Describes the format for available camera services

 enable_motion_detection:
-  description: Enable the motion detection in a camera
-
+  description: Enable the motion detection in a camera.
  fields:
    entity_id:
-      description: Name(s) of entities to enable motion detection
+      description: Name(s) of entities to enable motion detection.
      example: 'camera.living_room_camera'

 disable_motion_detection:
-  description: Disable the motion detection in a camera
-  
+  description: Disable the motion detection in a camera.
  fields:
    entity_id:
-      description: Name(s) of entities to disable motion detection
+      description: Name(s) of entities to disable motion detection.
      example: 'camera.living_room_camera'
+
+snapshot:
+  description: Take a snapshot from a camera.
+  fields:
+    entity_id:
+      description: Name(s) of entities to create snapshots from.
+      example: 'camera.living_room_camera'
+    filename:
+      description: Template of a Filename. Variable is entity_id.
+      example: '/tmp/snapshot_{{ entity_id }}'
@@ -9,12 +9,12 @@ from datetime import timedelta
 import logging
 import os
 import functools as ft
-from numbers import Number

 import voluptuous as vol

 from homeassistant.config import load_yaml_config_file
 from homeassistant.loader import bind_hass
+from homeassistant.helpers.temperature import display_temp as show_temp
 from homeassistant.util.temperature import convert as convert_temperature
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.entity import Entity
@@ -22,7 +22,7 @@ from homeassistant.helpers.config_validation import PLATFORM_SCHEMA  # noqa
 import homeassistant.helpers.config_validation as cv
 from homeassistant.const import (
    ATTR_ENTITY_ID, ATTR_TEMPERATURE, STATE_ON, STATE_OFF, STATE_UNKNOWN,
-    TEMP_CELSIUS)
+    TEMP_CELSIUS, PRECISION_WHOLE, PRECISION_TENTHS)

 DOMAIN = 'climate'

@@ -71,11 +71,6 @@ ATTR_OPERATION_LIST = 'operation_list'
 ATTR_SWING_MODE = 'swing_mode'
 ATTR_SWING_LIST = 'swing_list'

-# The degree of precision for each platform
-PRECISION_WHOLE = 1
-PRECISION_HALVES = 0.5
-PRECISION_TENTHS = 0.1
-
 CONVERTIBLE_ATTRIBUTE = [
    ATTR_TEMPERATURE,
    ATTR_TARGET_TEMP_LOW,
@@ -456,12 +451,18 @@ class ClimateDevice(Entity):
    def state_attributes(self):
        """Return the optional state attributes."""
        data = {
-            ATTR_CURRENT_TEMPERATURE:
-            self._convert_for_display(self.current_temperature),
-            ATTR_MIN_TEMP: self._convert_for_display(self.min_temp),
-            ATTR_MAX_TEMP: self._convert_for_display(self.max_temp),
-            ATTR_TEMPERATURE:
-            self._convert_for_display(self.target_temperature),
+            ATTR_CURRENT_TEMPERATURE: show_temp(
+                self.hass, self.current_temperature, self.temperature_unit,
+                self.precision),
+            ATTR_MIN_TEMP: show_temp(
+                self.hass, self.min_temp, self.temperature_unit,
+                self.precision),
+            ATTR_MAX_TEMP: show_temp(
+                self.hass, self.max_temp, self.temperature_unit,
+                self.precision),
+            ATTR_TEMPERATURE: show_temp(
+                self.hass, self.target_temperature, self.temperature_unit,
+                self.precision),
        }

        if self.target_temperature_step is not None:
@@ -469,10 +470,12 @@ class ClimateDevice(Entity):

        target_temp_high = self.target_temperature_high
        if target_temp_high is not None:
-            data[ATTR_TARGET_TEMP_HIGH] = self._convert_for_display(
-                self.target_temperature_high)
-            data[ATTR_TARGET_TEMP_LOW] = self._convert_for_display(
-                self.target_temperature_low)
+            data[ATTR_TARGET_TEMP_HIGH] = show_temp(
+                self.hass, self.target_temperature_high, self.temperature_unit,
+                self.precision)
+            data[ATTR_TARGET_TEMP_LOW] = show_temp(
+                self.hass, self.target_temperature_low, self.temperature_unit,
+                self.precision)

        humidity = self.target_humidity
        if humidity is not None:
@@ -733,24 +736,3 @@ class ClimateDevice(Entity):
    def max_humidity(self):
        """Return the maximum humidity."""
        return 99
-
-    def _convert_for_display(self, temp):
-        """Convert temperature into preferred units for display purposes."""
-        if temp is None:
-            return temp
-
-        # if the temperature is not a number this can cause issues
-        # with polymer components, so bail early there.
-        if not isinstance(temp, Number):
-            raise TypeError("Temperature is not a number: %s" % temp)
-
-        if self.temperature_unit != self.unit_of_measurement:
-            temp = convert_temperature(
-                temp, self.temperature_unit, self.unit_of_measurement)
-        # Round in the units appropriate
-        if self.precision == PRECISION_HALVES:
-            return round(temp * 2) / 2.0
-        elif self.precision == PRECISION_TENTHS:
-            return round(temp, 1)
-        # PRECISION_WHOLE as a fall back
-        return round(temp)
@@ -0,0 +1,117 @@
+"""
+Support for the EPH Controls Ember themostats.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/climate.ephember/
+"""
+import logging
+from datetime import timedelta
+import voluptuous as vol
+
+from homeassistant.components.climate import (
+    ClimateDevice, PLATFORM_SCHEMA, STATE_HEAT, STATE_IDLE)
+from homeassistant.const import (
+    TEMP_CELSIUS, CONF_USERNAME, CONF_PASSWORD)
+import homeassistant.helpers.config_validation as cv
+
+REQUIREMENTS = ['pyephember==0.1.1']
+
+_LOGGER = logging.getLogger(__name__)
+
+# Return cached results if last scan was less then this time ago
+SCAN_INTERVAL = timedelta(seconds=120)
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_USERNAME): cv.string,
+    vol.Required(CONF_PASSWORD): cv.string
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the ephember thermostat."""
+    from pyephember.pyephember import EphEmber
+
+    username = config.get(CONF_USERNAME)
+    password = config.get(CONF_PASSWORD)
+
+    try:
+        ember = EphEmber(username, password)
+        zones = ember.get_zones()
+        for zone in zones:
+            add_devices([EphEmberThermostat(ember, zone)])
+    except RuntimeError:
+        _LOGGER.error("Cannot connect to EphEmber")
+        return
+
+    return
+
+
+class EphEmberThermostat(ClimateDevice):
+    """Representation of a HeatmiserV3 thermostat."""
+
+    def __init__(self, ember, zone):
+        """Initialize the thermostat."""
+        self._ember = ember
+        self._zone_name = zone['name']
+        self._zone = zone
+        self._hot_water = zone['isHotWater']
+
+    @property
+    def name(self):
+        """Return the name of the thermostat, if any."""
+        return self._zone_name
+
+    @property
+    def temperature_unit(self):
+        """Return the unit of measurement which this thermostat uses."""
+        return TEMP_CELSIUS
+
+    @property
+    def current_temperature(self):
+        """Return the current temperature."""
+        return self._zone['currentTemperature']
+
+    @property
+    def target_temperature(self):
+        """Return the temperature we try to reach."""
+        return self._zone['targetTemperature']
+
+    @property
+    def current_operation(self):
+        """Return current operation ie. heat, cool, idle."""
+        if self._zone['isCurrentlyActive']:
+            return STATE_HEAT
+        else:
+            return STATE_IDLE
+
+    @property
+    def is_aux_heat_on(self):
+        """Return true if aux heater."""
+        return self._zone['isBoostActive']
+
+    def turn_aux_heat_on(self):
+        """Turn auxiliary heater on."""
+        self._ember.activate_boost_by_name(
+            self._zone_name, self._zone['targetTemperature'])
+
+    def turn_aux_heat_off(self):
+        """Turn auxiliary heater off."""
+        self._ember.deactivate_boost_by_name(self._zone_name)
+
+    def set_temperature(self, **kwargs):
+        """Set new target temperature."""
+        return
+
+    @property
+    def min_temp(self):
+        """Return the minimum temperature."""
+        return self._zone['targetTemperature']
+
+    @property
+    def max_temp(self):
+        """Return the maximum temperature."""
+        return self._zone['targetTemperature']
+
+    def update(self):
+        """Get the latest data."""
+        self._zone = self._ember.get_zone(self._zone_name)
@@ -9,12 +9,9 @@ import logging
 import voluptuous as vol

 from homeassistant.components.climate import (
-    ClimateDevice, PLATFORM_SCHEMA, PRECISION_HALVES,
-    STATE_AUTO, STATE_ON, STATE_OFF,
-)
+    STATE_ON, STATE_OFF, STATE_AUTO, PLATFORM_SCHEMA, ClimateDevice)
 from homeassistant.const import (
-    CONF_MAC, TEMP_CELSIUS, CONF_DEVICES, ATTR_TEMPERATURE)
-
+    CONF_MAC, CONF_DEVICES, TEMP_CELSIUS, ATTR_TEMPERATURE, PRECISION_HALVES)
 import homeassistant.helpers.config_validation as cv

 REQUIREMENTS = ['python-eq3bt==0.1.6']
@@ -58,15 +55,17 @@ class EQ3BTSmartThermostat(ClimateDevice):

    def __init__(self, _mac, _name):
        """Initialize the thermostat."""
-        # we want to avoid name clash with this module..
+        # We want to avoid name clash with this module.
        import eq3bt as eq3

-        self.modes = {eq3.Mode.Open: STATE_ON,
-                      eq3.Mode.Closed: STATE_OFF,
-                      eq3.Mode.Auto: STATE_AUTO,
-                      eq3.Mode.Manual: STATE_MANUAL,
-                      eq3.Mode.Boost: STATE_BOOST,
-                      eq3.Mode.Away: STATE_AWAY}
+        self.modes = {
+            eq3.Mode.Open: STATE_ON,
+            eq3.Mode.Closed: STATE_OFF,
+            eq3.Mode.Auto: STATE_AUTO,
+            eq3.Mode.Manual: STATE_MANUAL,
+            eq3.Mode.Boost: STATE_BOOST,
+            eq3.Mode.Away: STATE_AWAY,
+        }

        self.reverse_modes = {v: k for k, v in self.modes.items()}

@@ -153,11 +152,11 @@ class EQ3BTSmartThermostat(ClimateDevice):
    def device_state_attributes(self):
        """Return the device specific state attributes."""
        dev_specific = {
+            ATTR_STATE_AWAY_END: self._thermostat.away_end,
            ATTR_STATE_LOCKED: self._thermostat.locked,
            ATTR_STATE_LOW_BAT: self._thermostat.low_battery,
            ATTR_STATE_VALVE: self._thermostat.valve_state,
            ATTR_STATE_WINDOW_OPEN: self._thermostat.window_open,
-            ATTR_STATE_AWAY_END: self._thermostat.away_end,
        }

        return dev_specific
@@ -36,7 +36,8 @@ CONF_MAX_TEMP = 'max_temp'
 CONF_TARGET_TEMP = 'target_temp'
 CONF_AC_MODE = 'ac_mode'
 CONF_MIN_DUR = 'min_cycle_duration'
-CONF_TOLERANCE = 'tolerance'
+CONF_COLD_TOLERANCE = 'cold_tolerance'
+CONF_HOT_TOLERANCE = 'hot_tolerance'
 CONF_KEEP_ALIVE = 'keep_alive'


@@ -48,7 +49,10 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Optional(CONF_MIN_DUR): vol.All(cv.time_period, cv.positive_timedelta),
    vol.Optional(CONF_MIN_TEMP): vol.Coerce(float),
    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
-    vol.Optional(CONF_TOLERANCE, default=DEFAULT_TOLERANCE): vol.Coerce(float),
+    vol.Optional(CONF_COLD_TOLERANCE, default=DEFAULT_TOLERANCE): vol.Coerce(
+        float),
+    vol.Optional(CONF_HOT_TOLERANCE, default=DEFAULT_TOLERANCE): vol.Coerce(
+        float),
    vol.Optional(CONF_TARGET_TEMP): vol.Coerce(float),
    vol.Optional(CONF_KEEP_ALIVE): vol.All(
        cv.time_period, cv.positive_timedelta),
@@ -66,12 +70,14 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
    target_temp = config.get(CONF_TARGET_TEMP)
    ac_mode = config.get(CONF_AC_MODE)
    min_cycle_duration = config.get(CONF_MIN_DUR)
-    tolerance = config.get(CONF_TOLERANCE)
+    cold_tolerance = config.get(CONF_COLD_TOLERANCE)
+    hot_tolerance = config.get(CONF_HOT_TOLERANCE)
    keep_alive = config.get(CONF_KEEP_ALIVE)

    async_add_devices([GenericThermostat(
        hass, name, heater_entity_id, sensor_entity_id, min_temp, max_temp,
-        target_temp, ac_mode, min_cycle_duration, tolerance, keep_alive)])
+        target_temp, ac_mode, min_cycle_duration, cold_tolerance,
+        hot_tolerance, keep_alive)])


 class GenericThermostat(ClimateDevice):
@@ -79,14 +85,15 @@ class GenericThermostat(ClimateDevice):

    def __init__(self, hass, name, heater_entity_id, sensor_entity_id,
                 min_temp, max_temp, target_temp, ac_mode, min_cycle_duration,
-                 tolerance, keep_alive):
+                 cold_tolerance, hot_tolerance, keep_alive):
        """Initialize the thermostat."""
        self.hass = hass
        self._name = name
        self.heater_entity_id = heater_entity_id
        self.ac_mode = ac_mode
        self.min_cycle_duration = min_cycle_duration
-        self._tolerance = tolerance
+        self._cold_tolerance = cold_tolerance
+        self._hot_tolerance = hot_tolerance
        self._keep_alive = keep_alive
        self._enabled = True

@@ -156,6 +163,7 @@ class GenericThermostat(ClimateDevice):
        """Set operation mode."""
        if operation_mode == STATE_AUTO:
            self._enabled = True
+            self._async_control_heating()
        elif operation_mode == STATE_OFF:
            self._enabled = False
            if self._is_device_active:
@@ -261,25 +269,29 @@ class GenericThermostat(ClimateDevice):
        if self.ac_mode:
            is_cooling = self._is_device_active
            if is_cooling:
-                too_cold = self._target_temp - self._cur_temp > self._tolerance
+                too_cold = self._target_temp - self._cur_temp >= \
+                    self._cold_tolerance
                if too_cold:
                    _LOGGER.info('Turning off AC %s', self.heater_entity_id)
                    switch.async_turn_off(self.hass, self.heater_entity_id)
            else:
-                too_hot = self._cur_temp - self._target_temp > self._tolerance
+                too_hot = self._cur_temp - self._target_temp >= \
+                    self._hot_tolerance
                if too_hot:
                    _LOGGER.info('Turning on AC %s', self.heater_entity_id)
                    switch.async_turn_on(self.hass, self.heater_entity_id)
        else:
            is_heating = self._is_device_active
            if is_heating:
-                too_hot = self._cur_temp - self._target_temp > self._tolerance
+                too_hot = self._cur_temp - self._target_temp >= \
+                    self._hot_tolerance
                if too_hot:
                    _LOGGER.info('Turning off heater %s',
                                 self.heater_entity_id)
                    switch.async_turn_off(self.hass, self.heater_entity_id)
            else:
-                too_cold = self._target_temp - self._cur_temp > self._tolerance
+                too_cold = self._target_temp - self._cur_temp >= \
+                    self._cold_tolerance
                if too_cold:
                    _LOGGER.info('Turning on heater %s', self.heater_entity_id)
                    switch.async_turn_on(self.hass, self.heater_entity_id)
@@ -7,7 +7,6 @@ https://home-assistant.io/components/climate.homematic/
 import logging
 from homeassistant.components.climate import ClimateDevice, STATE_AUTO
 from homeassistant.components.homematic import HMDevice, ATTR_DISCOVER_DEVICES
-from homeassistant.util.temperature import convert
 from homeassistant.const import TEMP_CELSIUS, STATE_UNKNOWN, ATTR_TEMPERATURE

 DEPENDENCIES = ['homematic']
@@ -121,12 +120,12 @@ class HMThermostat(HMDevice, ClimateDevice):
    @property
    def min_temp(self):
        """Return the minimum temperature - 4.5 means off."""
-        return convert(4.5, TEMP_CELSIUS, self.unit_of_measurement)
+        return 4.5

    @property
    def max_temp(self):
        """Return the maximum temperature - 30.5 means on."""
-        return convert(30.5, TEMP_CELSIUS, self.unit_of_measurement)
+        return 30.5

    def _init_data_struct(self):
        """Generate a data dict (self._data) from the Homematic metadata."""
@@ -11,16 +11,15 @@ import datetime
 import requests
 import voluptuous as vol

+import homeassistant.helpers.config_validation as cv
 from homeassistant.components.climate import (
    ClimateDevice, PLATFORM_SCHEMA, ATTR_FAN_MODE, ATTR_FAN_LIST,
    ATTR_OPERATION_MODE, ATTR_OPERATION_LIST)
 from homeassistant.const import (
    CONF_PASSWORD, CONF_USERNAME, TEMP_CELSIUS, TEMP_FAHRENHEIT,
-    ATTR_TEMPERATURE)
-import homeassistant.helpers.config_validation as cv
+    ATTR_TEMPERATURE, CONF_REGION)

-REQUIREMENTS = ['evohomeclient==0.2.5',
-                'somecomfort==0.4.1']
+REQUIREMENTS = ['evohomeclient==0.2.5', 'somecomfort==0.4.1']

 _LOGGER = logging.getLogger(__name__)

@@ -31,7 +30,6 @@ ATTR_CURRENT_OPERATION = 'equipment_output_status'
 CONF_AWAY_TEMPERATURE = 'away_temperature'
 CONF_COOL_AWAY_TEMPERATURE = 'away_cool_temperature'
 CONF_HEAT_AWAY_TEMPERATURE = 'away_heat_temperature'
-CONF_REGION = 'region'

 DEFAULT_AWAY_TEMPERATURE = 16
 DEFAULT_COOL_AWAY_TEMPERATURE = 30
@@ -13,9 +13,11 @@ from homeassistant.const import CONF_NAME, TEMP_CELSIUS, ATTR_TEMPERATURE
 from homeassistant.core import callback
 import homeassistant.helpers.config_validation as cv

-CONF_SETPOINT_ADDRESS = 'setpoint_address'
 CONF_SETPOINT_SHIFT_ADDRESS = 'setpoint_shift_address'
 CONF_SETPOINT_SHIFT_STATE_ADDRESS = 'setpoint_shift_state_address'
+CONF_SETPOINT_SHIFT_STEP = 'setpoint_shift_step'
+CONF_SETPOINT_SHIFT_MAX = 'setpoint_shift_max'
+CONF_SETPOINT_SHIFT_MIN = 'setpoint_shift_min'
 CONF_TEMPERATURE_ADDRESS = 'temperature_address'
 CONF_TARGET_TEMPERATURE_ADDRESS = 'target_temperature_address'
 CONF_OPERATION_MODE_ADDRESS = 'operation_mode_address'
@@ -28,15 +30,24 @@ CONF_OPERATION_MODE_NIGHT_ADDRESS = 'operation_mode_night_address'
 CONF_OPERATION_MODE_COMFORT_ADDRESS = 'operation_mode_comfort_address'

 DEFAULT_NAME = 'KNX Climate'
+DEFAULT_SETPOINT_SHIFT_STEP = 0.5
+DEFAULT_SETPOINT_SHIFT_MAX = 6
+DEFAULT_SETPOINT_SHIFT_MIN = -6
 DEPENDENCIES = ['knx']

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
-    vol.Required(CONF_SETPOINT_ADDRESS): cv.string,
    vol.Required(CONF_TEMPERATURE_ADDRESS): cv.string,
    vol.Required(CONF_TARGET_TEMPERATURE_ADDRESS): cv.string,
    vol.Optional(CONF_SETPOINT_SHIFT_ADDRESS): cv.string,
    vol.Optional(CONF_SETPOINT_SHIFT_STATE_ADDRESS): cv.string,
+    vol.Optional(CONF_SETPOINT_SHIFT_STEP,
+                 default=DEFAULT_SETPOINT_SHIFT_STEP): vol.All(
+                     float, vol.Range(min=0, max=2)),
+    vol.Optional(CONF_SETPOINT_SHIFT_MAX, default=DEFAULT_SETPOINT_SHIFT_MAX):
+        vol.All(int, vol.Range(min=-32, max=0)),
+    vol.Optional(CONF_SETPOINT_SHIFT_MIN, default=DEFAULT_SETPOINT_SHIFT_MIN):
+        vol.All(int, vol.Range(min=0, max=32)),
    vol.Optional(CONF_OPERATION_MODE_ADDRESS): cv.string,
    vol.Optional(CONF_OPERATION_MODE_STATE_ADDRESS): cv.string,
    vol.Optional(CONF_CONTROLLER_STATUS_ADDRESS): cv.string,
@@ -77,6 +88,7 @@ def async_add_devices_discovery(hass, discovery_info, async_add_devices):
 def async_add_devices_config(hass, config, async_add_devices):
    """Set up climate for KNX platform configured within plattform."""
    import xknx
+
    climate = xknx.devices.Climate(
        hass.data[DATA_KNX].xknx,
        name=config.get(CONF_NAME),
@@ -84,12 +96,16 @@ def async_add_devices_config(hass, config, async_add_devices):
            CONF_TEMPERATURE_ADDRESS),
        group_address_target_temperature=config.get(
            CONF_TARGET_TEMPERATURE_ADDRESS),
-        group_address_setpoint=config.get(
-            CONF_SETPOINT_ADDRESS),
        group_address_setpoint_shift=config.get(
            CONF_SETPOINT_SHIFT_ADDRESS),
        group_address_setpoint_shift_state=config.get(
            CONF_SETPOINT_SHIFT_STATE_ADDRESS),
+        setpoint_shift_step=config.get(
+            CONF_SETPOINT_SHIFT_STEP),
+        setpoint_shift_max=config.get(
+            CONF_SETPOINT_SHIFT_MAX),
+        setpoint_shift_min=config.get(
+            CONF_SETPOINT_SHIFT_MIN),
        group_address_operation_mode=config.get(
            CONF_OPERATION_MODE_ADDRESS),
        group_address_operation_mode_state=config.get(
@@ -118,8 +134,6 @@ class KNXClimate(ClimateDevice):
        self.async_register_callbacks()

        self._unit_of_measurement = TEMP_CELSIUS
-        self._away = False  # not yet supported
-        self._is_fan_on = False  # not yet supported

    def async_register_callbacks(self):
        """Register callbacks to update hass after device was changed."""
@@ -150,28 +164,25 @@ class KNXClimate(ClimateDevice):
        """Return the current temperature."""
        return self.device.temperature.value

+    @property
+    def target_temperature_step(self):
+        """Return the supported step of target temperature."""
+        return self.device.setpoint_shift_step
+
    @property
    def target_temperature(self):
        """Return the temperature we try to reach."""
-        return self.device.target_temperature_comfort
+        return self.device.target_temperature.value

    @property
-    def target_temperature_high(self):
-        """Return the highbound target temperature we try to reach."""
-        if self.device.target_temperature_comfort:
-            return max(
-                self.device.target_temperature_comfort,
-                self.device.target_temperature.value)
-        return None
+    def min_temp(self):
+        """Return the minimum temperature."""
+        return self.device.target_temperature_min

    @property
-    def target_temperature_low(self):
-        """Return the lowbound target temperature we try to reach."""
-        if self.device.target_temperature_comfort:
-            return min(
-                self.device.target_temperature_comfort,
-                self.device.target_temperature.value)
-        return None
+    def max_temp(self):
+        """Return the maximum temperature."""
+        return self.device.target_temperature_max

    @asyncio.coroutine
    def async_set_temperature(self, **kwargs):
@@ -179,7 +190,7 @@ class KNXClimate(ClimateDevice):
        temperature = kwargs.get(ATTR_TEMPERATURE)
        if temperature is None:
            return
-        yield from self.device.set_target_temperature_comfort(temperature)
+        yield from self.device.set_target_temperature(temperature)
        yield from self.async_update_ha_state()

    @property
@@ -1,132 +1,102 @@
+# Describes the format for available climate services
+
 set_aux_heat:
-  description: Turn auxiliary heater on/off for climate device
-
+  description: Turn auxiliary heater on/off for climate device.
  fields:
    entity_id:
-      description: Name(s) of entities to change
+      description: Name(s) of entities to change.
      example: 'climate.kitchen'
-
    aux_heat:
-      description: New value of axillary heater
+      description: New value of axillary heater.
      example: true
-
 set_away_mode:
-  description: Turn away mode on/off for climate device
-
+  description: Turn away mode on/off for climate device.
  fields:
    entity_id:
-      description: Name(s) of entities to change
+      description: Name(s) of entities to change.
      example: 'climate.kitchen'
-
    away_mode:
-      description: New value of away mode
+      description: New value of away mode.
      example: true
-
 set_hold_mode:
-  description: Turn hold mode for climate device
-
+  description: Turn hold mode for climate device.
  fields:
    entity_id:
-      description: Name(s) of entities to change
+      description: Name(s) of entities to change.
      example: 'climate.kitchen'
-
    hold_mode:
      description: New value of hold mode
      example: 'away'
-
 set_temperature:
-  description: Set target temperature of climate device
-
+  description: Set target temperature of climate device.
  fields:
    entity_id:
-      description: Name(s) of entities to change
+      description: Name(s) of entities to change.
      example: 'climate.kitchen'
-
    temperature:
-      description: New target temperature for hvac
+      description: New target temperature for HVAC.
      example: 25
-
    target_temp_high:
-      description: New target high tempereature for hvac
+      description: New target high tempereature for HVAC.
      example: 26
- 
    target_temp_low:
-      description: New target low temperature for hvac
+      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
-
+  description: Set target humidity of climate device.
  fields:
    entity_id:
-      description: Name(s) of entities to change
+      description: Name(s) of entities to change.
      example: 'climate.kitchen'
-
    humidity:
-      description: New target humidity for climate device
+      description: New target humidity for climate device.
      example: 60
-
 set_fan_mode:
-  description: Set fan operation for climate device
-
+  description: Set fan operation for climate device.
  fields:
    entity_id:
-      description: Name(s) of entities to change
+      description: Name(s) of entities to change.
      example: 'climate.nest'
-
    fan_mode:
-      description: New value of fan mode
+      description: New value of fan mode.
      example: On Low
-
 set_operation_mode:
-  description: Set operation mode for climate device
-
+  description: Set operation mode for climate device.
  fields:
    entity_id:
-      description: Name(s) of entities to change
+      description: Name(s) of entities to change.
      example: 'climate.nest'
-
    operation_mode:
-      description: New value of operation mode
+      description: New value of operation mode.
      example: Heat
-
-
 set_swing_mode:
-  description: Set swing operation for climate device
-
+  description: Set swing operation for climate device.
  fields:
    entity_id:
-      description: Name(s) of entities to change
+      description: Name(s) of entities to change.
      example: 'climate.nest'
-
    swing_mode:
-      description: New value of swing mode
+      description: New value of swing mode.
      example: 1
-
 ecobee_set_fan_min_on_time:
-  description: Set the minimum fan on time
-
+  description: Set the minimum fan on time.
  fields:
    entity_id:
-      description: Name(s) of entities to change
+      description: Name(s) of entities to change.
      example: 'climate.kitchen'
-
    fan_min_on_time:
-      description: New value of fan min on time
+      description: New value of fan min on time.
      example: 5

 ecobee_resume_program:
-  description: Resume the programmed schedule
-
+  description: Resume the programmed schedule.
  fields:
    entity_id:
-      description: Name(s) of entities to change
+      description: Name(s) of entities to change.
      example: 'climate.kitchen'
-
    resume_all:
      description: Resume all events and return to the scheduled program. This default to false which removes only the top event.
      example: true
@@ -3,23 +3,20 @@ Toon van Eneco Thermostat Support.

 This provides a component for the rebranded Quby thermostat as provided by
 Eneco.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/climate.toon/
 """
-
-from homeassistant.components.climate import (ClimateDevice,
-                                              ATTR_TEMPERATURE,
-                                              STATE_PERFORMANCE,
-                                              STATE_HEAT,
-                                              STATE_ECO,
-                                              STATE_COOL)
-from homeassistant.const import TEMP_CELSIUS
-
 import homeassistant.components.toon as toon_main
+from homeassistant.components.climate import (
+    ClimateDevice, ATTR_TEMPERATURE, STATE_PERFORMANCE, STATE_HEAT, STATE_ECO,
+    STATE_COOL)
+from homeassistant.const import TEMP_CELSIUS


 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup thermostat."""
-    # Add toon
-    add_devices((ThermostatDevice(hass), ), True)
+    """Set up the Toon thermostat."""
+    add_devices([ThermostatDevice(hass)], True)


 class ThermostatDevice(ClimateDevice):
@@ -31,25 +28,21 @@ class ThermostatDevice(ClimateDevice):
        self.hass = hass
        self.thermos = hass.data[toon_main.TOON_HANDLE]

-        # set up internal state vars
        self._state = None
        self._temperature = None
        self._setpoint = None
-        self._operation_list = [STATE_PERFORMANCE,
-                                STATE_HEAT,
-                                STATE_ECO,
-                                STATE_COOL]
+        self._operation_list = [
+            STATE_PERFORMANCE,
+            STATE_HEAT,
+            STATE_ECO,
+            STATE_COOL,
+        ]

    @property
    def name(self):
        """Name of this Thermostat."""
        return self._name

-    @property
-    def should_poll(self):
-        """Polling is required."""
-        return True
-
    @property
    def temperature_unit(self):
        """The unit of measurement used by the platform."""
@@ -83,10 +76,12 @@ class ThermostatDevice(ClimateDevice):

    def set_operation_mode(self, operation_mode):
        """Set new operation mode as toonlib requires it."""
-        toonlib_values = {STATE_PERFORMANCE: 'Comfort',
-                          STATE_HEAT: 'Home',
-                          STATE_ECO: 'Away',
-                          STATE_COOL: 'Sleep'}
+        toonlib_values = {
+            STATE_PERFORMANCE: 'Comfort',
+            STATE_HEAT: 'Home',
+            STATE_ECO: 'Away',
+            STATE_COOL: 'Sleep',
+        }

        self.thermos.set_state(toonlib_values[operation_mode])

@@ -4,46 +4,51 @@ Support for Wink thermostats, Air Conditioners, and Water Heaters.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/climate.wink/
 """
-import logging
 import asyncio
+import logging

-from homeassistant.components.wink import WinkDevice, DOMAIN
 from homeassistant.components.climate import (
-    STATE_AUTO, STATE_COOL, STATE_HEAT, ClimateDevice,
-    ATTR_TARGET_TEMP_HIGH, ATTR_TARGET_TEMP_LOW,
-    ATTR_TEMPERATURE, STATE_FAN_ONLY,
-    ATTR_CURRENT_HUMIDITY, STATE_ECO, STATE_ELECTRIC,
-    STATE_PERFORMANCE, STATE_HIGH_DEMAND,
-    STATE_HEAT_PUMP, STATE_GAS)
+    STATE_ECO, STATE_GAS, STATE_AUTO, STATE_COOL, STATE_HEAT, STATE_ELECTRIC,
+    STATE_FAN_ONLY, STATE_HEAT_PUMP, ATTR_TEMPERATURE, STATE_HIGH_DEMAND,
+    STATE_PERFORMANCE, ATTR_TARGET_TEMP_LOW, ATTR_CURRENT_HUMIDITY,
+    ATTR_TARGET_TEMP_HIGH, ClimateDevice)
+from homeassistant.components.wink import DOMAIN, WinkDevice
 from homeassistant.const import (
-    TEMP_CELSIUS, STATE_ON,
-    STATE_OFF, STATE_UNKNOWN)
+    STATE_ON, STATE_OFF, TEMP_CELSIUS, STATE_UNKNOWN, PRECISION_TENTHS)
+from homeassistant.helpers.temperature import display_temp as show_temp

 _LOGGER = logging.getLogger(__name__)

+ATTR_ECO_TARGET = 'eco_target'
+ATTR_EXTERNAL_TEMPERATURE = 'external_temperature'
+ATTR_OCCUPIED = 'occupied'
+ATTR_RHEEM_TYPE = 'rheem_type'
+ATTR_SCHEDULE_ENABLED = 'schedule_enabled'
+ATTR_SMART_TEMPERATURE = 'smart_temperature'
+ATTR_TOTAL_CONSUMPTION = 'total_consumption'
+ATTR_VACATION_MODE = 'vacation_mode'
+
 DEPENDENCIES = ['wink']

 SPEED_LOW = 'low'
 SPEED_MEDIUM = 'medium'
 SPEED_HIGH = 'high'

-HA_STATE_TO_WINK = {STATE_AUTO: 'auto',
-                    STATE_ECO: 'eco',
-                    STATE_FAN_ONLY: 'fan_only',
-                    STATE_HEAT: 'heat_only',
-                    STATE_COOL: 'cool_only',
-                    STATE_PERFORMANCE: 'performance',
-                    STATE_HIGH_DEMAND: 'high_demand',
-                    STATE_HEAT_PUMP: 'heat_pump',
-                    STATE_ELECTRIC: 'electric_only',
-                    STATE_GAS: 'gas',
-                    STATE_OFF: 'off'}
-WINK_STATE_TO_HA = {value: key for key, value in HA_STATE_TO_WINK.items()}
+HA_STATE_TO_WINK = {
+    STATE_AUTO: 'auto',
+    STATE_COOL: 'cool_only',
+    STATE_ECO: 'eco',
+    STATE_ELECTRIC: 'electric_only',
+    STATE_FAN_ONLY: 'fan_only',
+    STATE_GAS: 'gas',
+    STATE_HEAT: 'heat_only',
+    STATE_HEAT_PUMP: 'heat_pump',
+    STATE_HIGH_DEMAND: 'high_demand',
+    STATE_OFF: 'off',
+    STATE_PERFORMANCE: 'performance',
+}

-ATTR_EXTERNAL_TEMPERATURE = "external_temperature"
-ATTR_SMART_TEMPERATURE = "smart_temperature"
-ATTR_ECO_TARGET = "eco_target"
-ATTR_OCCUPIED = "occupied"
+WINK_STATE_TO_HA = {value: key for key, value in HA_STATE_TO_WINK.items()}


 def setup_platform(hass, config, add_devices, discovery_info=None):
@@ -85,15 +90,18 @@ class WinkThermostat(WinkDevice, ClimateDevice):
        target_temp_high = self.target_temperature_high
        target_temp_low = self.target_temperature_low
        if target_temp_high is not None:
-            data[ATTR_TARGET_TEMP_HIGH] = self._convert_for_display(
-                self.target_temperature_high)
+            data[ATTR_TARGET_TEMP_HIGH] = show_temp(
+                self.hass, self.target_temperature_high, self.temperature_unit,
+                PRECISION_TENTHS)
        if target_temp_low is not None:
-            data[ATTR_TARGET_TEMP_LOW] = self._convert_for_display(
-                self.target_temperature_low)
+            data[ATTR_TARGET_TEMP_LOW] = show_temp(
+                self.hass, self.target_temperature_low, self.temperature_unit,
+                PRECISION_TENTHS)

        if self.external_temperature:
-            data[ATTR_EXTERNAL_TEMPERATURE] = self._convert_for_display(
-                self.external_temperature)
+            data[ATTR_EXTERNAL_TEMPERATURE] = show_temp(
+                self.hass, self.external_temperature, self.temperature_unit,
+                PRECISION_TENTHS)

        if self.smart_temperature:
            data[ATTR_SMART_TEMPERATURE] = self.smart_temperature
@@ -139,7 +147,7 @@ class WinkThermostat(WinkDevice, ClimateDevice):

    @property
    def eco_target(self):
-        """Return status of eco target (Is the termostat in eco mode)."""
+        """Return status of eco target (Is the thermostat in eco mode)."""
        return self.wink.eco_target()

    @property
@@ -249,7 +257,7 @@ class WinkThermostat(WinkDevice, ClimateDevice):
            if ha_mode is not None:
                op_list.append(ha_mode)
            else:
-                error = "Invaid operation mode mapping. " + mode + \
+                error = "Invalid operation mode mapping. " + mode + \
                    " doesn't map. Please report this."
                _LOGGER.error(error)
        return op_list
@@ -297,7 +305,6 @@ class WinkThermostat(WinkDevice, ClimateDevice):
        minimum = 7  # Default minimum
        min_min = self.wink.min_min_set_point()
        min_max = self.wink.min_max_set_point()
-        return_value = minimum
        if self.current_operation == STATE_HEAT:
            if min_min:
                return_value = min_min
@@ -323,7 +330,6 @@ class WinkThermostat(WinkDevice, ClimateDevice):
        maximum = 35  # Default maximum
        max_min = self.wink.max_min_set_point()
        max_max = self.wink.max_max_set_point()
-        return_value = maximum
        if self.current_operation == STATE_HEAT:
            if max_min:
                return_value = max_min
@@ -360,13 +366,15 @@ class WinkAC(WinkDevice, ClimateDevice):
        target_temp_high = self.target_temperature_high
        target_temp_low = self.target_temperature_low
        if target_temp_high is not None:
-            data[ATTR_TARGET_TEMP_HIGH] = self._convert_for_display(
-                self.target_temperature_high)
+            data[ATTR_TARGET_TEMP_HIGH] = show_temp(
+                self.hass, self.target_temperature_high, self.temperature_unit,
+                PRECISION_TENTHS)
        if target_temp_low is not None:
-            data[ATTR_TARGET_TEMP_LOW] = self._convert_for_display(
-                self.target_temperature_low)
-        data["total_consumption"] = self.wink.total_consumption()
-        data["schedule_enabled"] = self.wink.schedule_enabled()
+            data[ATTR_TARGET_TEMP_LOW] = show_temp(
+                self.hass, self.target_temperature_low, self.temperature_unit,
+                PRECISION_TENTHS)
+        data[ATTR_TOTAL_CONSUMPTION] = self.wink.total_consumption()
+        data[ATTR_SCHEDULE_ENABLED] = self.wink.schedule_enabled()

        return data

@@ -377,11 +385,14 @@ class WinkAC(WinkDevice, ClimateDevice):

    @property
    def current_operation(self):
-        """Return current operation ie. heat, cool, idle."""
+        """Return current operation ie. auto_eco, cool_only, fan_only."""
        if not self.wink.is_on():
            current_op = STATE_OFF
        else:
-            current_op = WINK_STATE_TO_HA.get(self.wink.current_hvac_mode())
+            wink_mode = self.wink.current_mode()
+            if wink_mode == "auto_eco":
+                wink_mode = "eco"
+            current_op = WINK_STATE_TO_HA.get(wink_mode)
            if current_op is None:
                current_op = STATE_UNKNOWN
        return current_op
@@ -392,11 +403,13 @@ class WinkAC(WinkDevice, ClimateDevice):
        op_list = ['off']
        modes = self.wink.modes()
        for mode in modes:
+            if mode == "auto_eco":
+                mode = "eco"
            ha_mode = WINK_STATE_TO_HA.get(mode)
            if ha_mode is not None:
                op_list.append(ha_mode)
            else:
-                error = "Invaid operation mode mapping. " + mode + \
+                error = "Invalid operation mode mapping. " + mode + \
                    " doesn't map. Please report this."
                _LOGGER.error(error)
        return op_list
@@ -420,15 +433,19 @@ class WinkAC(WinkDevice, ClimateDevice):

    @property
    def current_fan_mode(self):
-        """Return the current fan mode."""
+        """
+        Return the current fan mode.
+
+        The official Wink app only supports 3 modes [low, medium, high]
+        which are equal to [0.33, 0.66, 1.0] respectively.
+        """
        speed = self.wink.current_fan_speed()
-        if speed <= 0.4 and speed > 0.3:
+        if speed <= 0.33:
            return SPEED_LOW
-        elif speed <= 0.8 and speed > 0.5:
+        elif speed <= 0.66:
            return SPEED_MEDIUM
-        elif speed <= 1.0 and speed > 0.8:
+        else:
            return SPEED_HIGH
-        return STATE_UNKNOWN

    @property
    def fan_list(self):
@@ -436,11 +453,16 @@ class WinkAC(WinkDevice, ClimateDevice):
        return [SPEED_LOW, SPEED_MEDIUM, SPEED_HIGH]

    def set_fan_mode(self, fan):
-        """Set fan speed."""
+        """
+        Set fan speed.
+
+        The official Wink app only supports 3 modes [low, medium, high]
+        which are equal to [0.33, 0.66, 1.0] respectively.
+        """
        if fan == SPEED_LOW:
-            speed = 0.4
+            speed = 0.33
        elif fan == SPEED_MEDIUM:
-            speed = 0.8
+            speed = 0.66
        elif fan == SPEED_HIGH:
            speed = 1.0
        self.wink.set_ac_fan_speed(speed)
@@ -459,8 +481,8 @@ class WinkWaterHeater(WinkDevice, ClimateDevice):
    def device_state_attributes(self):
        """Return the optional state attributes."""
        data = {}
-        data["vacation_mode"] = self.wink.vacation_mode_enabled()
-        data["rheem_type"] = self.wink.rheem_type()
+        data[ATTR_VACATION_MODE] = self.wink.vacation_mode_enabled()
+        data[ATTR_RHEEM_TYPE] = self.wink.rheem_type()

        return data

@@ -492,7 +514,7 @@ class WinkWaterHeater(WinkDevice, ClimateDevice):
            if ha_mode is not None:
                op_list.append(ha_mode)
            else:
-                error = "Invaid operation mode mapping. " + mode + \
+                error = "Invalid operation mode mapping. " + mode + \
                    " doesn't map. Please report this."
                _LOGGER.error(error)
        return op_list
@@ -1,27 +1,41 @@
 """Component to integrate the Home Assistant cloud."""
 import asyncio
+from datetime import datetime
 import json
 import logging
 import os

 import voluptuous as vol

-from homeassistant.const import EVENT_HOMEASSISTANT_START
+from homeassistant.const import (
+    EVENT_HOMEASSISTANT_START, CONF_REGION, CONF_MODE)
+from homeassistant.helpers import entityfilter
+from homeassistant.util import dt as dt_util
+from homeassistant.components.alexa import smart_home

 from . import http_api, iot
 from .const import CONFIG_DIR, DOMAIN, SERVERS

-
 REQUIREMENTS = ['warrant==0.5.0']
-DEPENDENCIES = ['http']
-CONF_MODE = 'mode'
+
+_LOGGER = logging.getLogger(__name__)
+
+CONF_ALEXA = 'alexa'
+CONF_ALEXA_FILTER = 'filter'
 CONF_COGNITO_CLIENT_ID = 'cognito_client_id'
-CONF_USER_POOL_ID = 'user_pool_id'
-CONF_REGION = 'region'
 CONF_RELAYER = 'relayer'
+CONF_USER_POOL_ID = 'user_pool_id'
+
 MODE_DEV = 'development'
 DEFAULT_MODE = MODE_DEV
-_LOGGER = logging.getLogger(__name__)
+DEPENDENCIES = ['http']
+
+ALEXA_SCHEMA = vol.Schema({
+    vol.Optional(
+        CONF_ALEXA_FILTER,
+        default=lambda: entityfilter.generate_filter([], [], [], [])
+    ): entityfilter.FILTER_SCHEMA,
+})

 CONFIG_SCHEMA = vol.Schema({
    DOMAIN: vol.Schema({
@@ -32,6 +46,7 @@ CONFIG_SCHEMA = vol.Schema({
        vol.Required(CONF_USER_POOL_ID): str,
        vol.Required(CONF_REGION): str,
        vol.Required(CONF_RELAYER): str,
+        vol.Optional(CONF_ALEXA): ALEXA_SCHEMA
    }),
 }, extra=vol.ALLOW_EXTRA)

@@ -44,6 +59,10 @@ def async_setup(hass, config):
    else:
        kwargs = {CONF_MODE: DEFAULT_MODE}

+    if CONF_ALEXA not in kwargs:
+        kwargs[CONF_ALEXA] = ALEXA_SCHEMA({})
+
+    kwargs[CONF_ALEXA] = smart_home.Config(**kwargs[CONF_ALEXA])
    cloud = hass.data[DOMAIN] = Cloud(hass, **kwargs)

    @asyncio.coroutine
@@ -61,11 +80,11 @@ class Cloud:
    """Store the configuration of the cloud connection."""

    def __init__(self, hass, mode, cognito_client_id=None, user_pool_id=None,
-                 region=None, relayer=None):
+                 region=None, relayer=None, alexa=None):
        """Create an instance of Cloud."""
        self.hass = hass
        self.mode = mode
-        self.email = None
+        self.alexa_config = alexa
        self.id_token = None
        self.access_token = None
        self.refresh_token = None
@@ -88,7 +107,29 @@ class Cloud:
    @property
    def is_logged_in(self):
        """Get if cloud is logged in."""
-        return self.email is not None
+        return self.id_token is not None
+
+    @property
+    def subscription_expired(self):
+        """Return a boolen if the subscription has expired."""
+        # For now, don't enforce subscriptions to exist
+        if 'custom:sub-exp' not in self.claims:
+            return False
+
+        return dt_util.utcnow() > self.expiration_date
+
+    @property
+    def expiration_date(self):
+        """Return the subscription expiration as a UTC datetime object."""
+        return datetime.combine(
+            dt_util.parse_date(self.claims['custom:sub-exp']),
+            datetime.min.time()).replace(tzinfo=dt_util.UTC)
+
+    @property
+    def claims(self):
+        """Get the claims from the id token."""
+        from jose import jwt
+        return jwt.get_unverified_claims(self.id_token)

    @property
    def user_info_path(self):
@@ -109,18 +150,20 @@ class Cloud:
            if os.path.isfile(user_info):
                with open(user_info, 'rt') as file:
                    info = json.loads(file.read())
-                self.email = info['email']
                self.id_token = info['id_token']
                self.access_token = info['access_token']
                self.refresh_token = info['refresh_token']

        yield from self.hass.async_add_job(load_config)

-        if self.email is not None:
+        if self.id_token is not None:
            yield from self.iot.connect()

    def path(self, *parts):
-        """Get config path inside cloud dir."""
+        """Get config path inside cloud dir.
+
+        Async friendly.
+        """
        return self.hass.config.path(CONFIG_DIR, *parts)

    @asyncio.coroutine
@@ -128,7 +171,6 @@ class Cloud:
        """Close connection and remove all credentials."""
        yield from self.iot.disconnect()

-        self.email = None
        self.id_token = None
        self.access_token = None
        self.refresh_token = None
@@ -140,7 +182,6 @@ class Cloud:
        """Write user info to a file."""
        with open(self.user_info_path, 'wt') as file:
            file.write(json.dumps({
-                'email': self.email,
                'id_token': self.id_token,
                'access_token': self.access_token,
                'refresh_token': self.refresh_token,
@@ -113,7 +113,6 @@ def login(cloud, email, password):
    cloud.id_token = cognito.id_token
    cloud.access_token = cognito.access_token
    cloud.refresh_token = cognito.refresh_token
-    cloud.email = email
    cloud.write_user_info()


@@ -12,3 +12,8 @@ SERVERS = {
    #     'relayer': ''
    # }
 }
+
+MESSAGE_EXPIRATION = """
+It looks like your Home Assistant Cloud subscription has expired. Please check
+your [account page](/config/cloud/account) to continue using the service.
+"""
@@ -79,8 +79,10 @@ class CloudLoginView(HomeAssistantView):
        with async_timeout.timeout(REQUEST_TIMEOUT, loop=hass.loop):
            yield from hass.async_add_job(auth_api.login, cloud, data['email'],
                                          data['password'])
-            hass.async_add_job(cloud.iot.connect)

+        hass.async_add_job(cloud.iot.connect)
+        # Allow cloud to start connecting.
+        yield from asyncio.sleep(0, loop=hass.loop)
        return self.json(_account_data(cloud))


@@ -222,6 +224,10 @@ class CloudConfirmForgotPasswordView(HomeAssistantView):

 def _account_data(cloud):
    """Generate the auth data JSON response."""
+    claims = cloud.claims
+
    return {
-        'email': cloud.email
+        'email': claims['email'],
+        'sub_exp': claims.get('custom:sub-exp'),
+        'cloud': cloud.iot.state,
    }
@@ -9,11 +9,16 @@ from homeassistant.components.alexa import smart_home
 from homeassistant.util.decorator import Registry
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from . import auth_api
+from .const import MESSAGE_EXPIRATION


 HANDLERS = Registry()
 _LOGGER = logging.getLogger(__name__)

+STATE_CONNECTING = 'connecting'
+STATE_CONNECTED = 'connected'
+STATE_DISCONNECTED = 'disconnected'
+

 class UnknownHandler(Exception):
    """Exception raised when trying to handle unknown handler."""
@@ -25,27 +30,41 @@ class CloudIoT:
    def __init__(self, cloud):
        """Initialize the CloudIoT class."""
        self.cloud = cloud
+        # The WebSocket client
        self.client = None
+        # Scheduled sleep task till next connection retry
+        self.retry_task = None
+        # Boolean to indicate if we wanted the connection to close
        self.close_requested = False
+        # The current number of attempts to connect, impacts wait time
        self.tries = 0
-
-    @property
-    def is_connected(self):
-        """Return if connected to the cloud."""
-        return self.client is not None
+        # Current state of the connection
+        self.state = STATE_DISCONNECTED

    @asyncio.coroutine
    def connect(self):
        """Connect to the IoT broker."""
-        if self.client is not None:
-            raise RuntimeError('Cannot connect while already connected')
-
-        self.close_requested = False
-
        hass = self.cloud.hass
-        remove_hass_stop_listener = None
+        if self.cloud.subscription_expired:
+            # Try refreshing the token to see if it is still expired.
+            yield from hass.async_add_job(auth_api.check_token, self.cloud)

+            if self.cloud.subscription_expired:
+                hass.components.persistent_notification.async_create(
+                    MESSAGE_EXPIRATION, 'Subscription expired',
+                    'cloud_subscription_expired')
+                self.state = STATE_DISCONNECTED
+                return
+
+        if self.state == STATE_CONNECTED:
+            raise RuntimeError('Already connected')
+
+        self.state = STATE_CONNECTING
+        self.close_requested = False
+        remove_hass_stop_listener = None
        session = async_get_clientsession(self.cloud.hass)
+        client = None
+        disconnect_warn = None

        @asyncio.coroutine
        def _handle_hass_stop(event):
@@ -54,15 +73,13 @@ class CloudIoT:
            remove_hass_stop_listener = None
            yield from self.disconnect()

-        client = None
-        disconnect_warn = None
        try:
            yield from hass.async_add_job(auth_api.check_token, self.cloud)

            self.client = client = yield from session.ws_connect(
                self.cloud.relayer, headers={
                    hdrs.AUTHORIZATION:
-                        'Bearer {}'.format(self.cloud.access_token)
+                        'Bearer {}'.format(self.cloud.id_token)
                })
            self.tries = 0

@@ -70,13 +87,14 @@ class CloudIoT:
                EVENT_HOMEASSISTANT_STOP, _handle_hass_stop)

            _LOGGER.info('Connected')
+            self.state = STATE_CONNECTED

            while not client.closed:
                msg = yield from client.receive()

                if msg.type in (WSMsgType.ERROR, WSMsgType.CLOSED,
                                WSMsgType.CLOSING):
-                    disconnect_warn = 'Closed by server'
+                    disconnect_warn = 'Connection cancelled.'
                    break

                elif msg.type != WSMsgType.TEXT:
@@ -144,20 +162,33 @@ class CloudIoT:
                self.client = None
                yield from client.close()

-            if not self.close_requested:
+            if self.close_requested:
+                self.state = STATE_DISCONNECTED
+
+            else:
+                self.state = STATE_CONNECTING
                self.tries += 1

-                # Sleep 0, 5, 10, 15 … up to 30 seconds between retries
-                yield from asyncio.sleep(
-                    min(30, (self.tries - 1) * 5), loop=hass.loop)
-
-                hass.async_add_job(self.connect())
+                try:
+                    # Sleep 0, 5, 10, 15 … up to 30 seconds between retries
+                    self.retry_task = hass.async_add_job(asyncio.sleep(
+                        min(30, (self.tries - 1) * 5), loop=hass.loop))
+                    yield from self.retry_task
+                    self.retry_task = None
+                    hass.async_add_job(self.connect())
+                except asyncio.CancelledError:
+                    # Happens if disconnect called
+                    pass

    @asyncio.coroutine
    def disconnect(self):
        """Disconnect the client."""
        self.close_requested = True
-        yield from self.client.close()
+
+        if self.client is not None:
+            yield from self.client.close()
+        elif self.retry_task is not None:
+            self.retry_task.cancel()


@asyncio.coroutine
@@ -175,7 +206,9 @@ def async_handle_message(hass, cloud, handler_name, payload):
@asyncio.coroutine
 def async_handle_alexa(hass, cloud, payload):
    """Handle an incoming IoT message for Alexa."""
-    return (yield from smart_home.async_handle_message(hass, payload))
+    return (yield from smart_home.async_handle_message(hass,
+                                                       cloud.alexa_config,
+                                                       payload))


@HANDLERS.register('cloud')
@@ -8,7 +8,6 @@ from homeassistant.core import callback
 from homeassistant.const import EVENT_COMPONENT_LOADED, CONF_ID
 from homeassistant.setup import (
    async_prepare_setup_platform, ATTR_COMPONENT)
-from homeassistant.components.frontend import register_built_in_panel
 from homeassistant.components.http import HomeAssistantView
 from homeassistant.util.yaml import load_yaml, dump

@@ -21,7 +20,8 @@ ON_DEMAND = ('zwave')
@asyncio.coroutine
 def async_setup(hass, config):
    """Set up the config component."""
-    register_built_in_panel(hass, 'config', 'Configuration', 'mdi:settings')
+    yield from hass.components.frontend.async_register_built_in_panel(
+        'config', 'config', 'mdi:settings')

    @asyncio.coroutine
    def setup_panel(panel_name):
@@ -1,17 +1,19 @@
 """Provide configuration end points for Z-Wave."""
 import asyncio
+import logging

+from collections import deque
+from aiohttp.web import Response
 import homeassistant.core as ha
-from homeassistant.const import HTTP_NOT_FOUND
+from homeassistant.const import HTTP_NOT_FOUND, HTTP_OK
 from homeassistant.components.http import HomeAssistantView
 from homeassistant.components.config import EditKeyBasedConfigView
 from homeassistant.components.zwave import const, DEVICE_CONFIG_SCHEMA_ENTRY
 import homeassistant.helpers.config_validation as cv

-
+_LOGGER = logging.getLogger(__name__)
 CONFIG_PATH = 'zwave_device_config.yaml'
 OZW_LOG_FILENAME = 'OZW_Log.txt'
-URL_API_OZW_LOG = '/api/zwave/ozwlog'


@asyncio.coroutine
@@ -25,12 +27,64 @@ def async_setup(hass):
    hass.http.register_view(ZWaveNodeGroupView)
    hass.http.register_view(ZWaveNodeConfigView)
    hass.http.register_view(ZWaveUserCodeView)
-    hass.http.register_static_path(
-        URL_API_OZW_LOG, hass.config.path(OZW_LOG_FILENAME), False)
+    hass.http.register_view(ZWaveLogView)
+    hass.http.register_view(ZWaveConfigWriteView)

    return True


+class ZWaveLogView(HomeAssistantView):
+    """View to read the ZWave log file."""
+
+    url = "/api/zwave/ozwlog"
+    name = "api:zwave:ozwlog"
+
+# pylint: disable=no-self-use
+    @asyncio.coroutine
+    def get(self, request):
+        """Retrieve the lines from ZWave log."""
+        try:
+            lines = int(request.query.get('lines', 0))
+        except ValueError:
+            return Response(text='Invalid datetime', status=400)
+
+        hass = request.app['hass']
+        response = yield from hass.async_add_job(self._get_log, hass, lines)
+
+        return Response(text='\n'.join(response))
+
+    def _get_log(self, hass, lines):
+        """Retrieve the logfile content."""
+        logfilepath = hass.config.path(OZW_LOG_FILENAME)
+        with open(logfilepath, 'r') as logfile:
+            data = (line.rstrip() for line in logfile)
+            if lines == 0:
+                loglines = list(data)
+            else:
+                loglines = deque(data, lines)
+        return loglines
+
+
+class ZWaveConfigWriteView(HomeAssistantView):
+    """View to save the ZWave configuration to zwcfg_xxxxx.xml."""
+
+    url = "/api/zwave/saveconfig"
+    name = "api:zwave:saveconfig"
+
+    @ha.callback
+    def post(self, request):
+        """Save cache configuration to zwcfg_xxxxx.xml."""
+        hass = request.app['hass']
+        network = hass.data.get(const.DATA_NETWORK)
+        if network is None:
+            return self.json_message('No Z-Wave network data found',
+                                     HTTP_NOT_FOUND)
+        _LOGGER.info("Z-Wave configuration written to file.")
+        network.write_config()
+        return self.json_message('Z-Wave configuration saved to file.',
+                                 HTTP_OK)
+
+
 class ZWaveNodeValueView(HomeAssistantView):
    """View to return the node values."""

@@ -207,7 +207,7 @@ class Configurator(object):

        self.hass.bus.async_listen_once(EVENT_TIME_CHANGED, deferred_remove)

-    @async_callback
+    @asyncio.coroutine
    def async_handle_service_call(self, call):
        """Handle a configure service call."""
        request_id = call.data.get(ATTR_CONFIGURE_ID)
@@ -220,7 +220,8 @@ class Configurator(object):

        # field validation goes here?
        if callback:
-            self.hass.async_add_job(callback, call.data.get(ATTR_FIELDS, {}))
+            yield from self.hass.async_add_job(callback,
+                                               call.data.get(ATTR_FIELDS, {}))

    def _generate_unique_id(self):
        """Generate a unique configurator ID."""
@@ -140,13 +140,13 @@ def async_setup(hass, config):

    hass.services.async_register(
        DOMAIN, SERVICE_INCREMENT, async_handler_service,
-        descriptions[DOMAIN][SERVICE_INCREMENT], SERVICE_SCHEMA)
+        descriptions[SERVICE_INCREMENT], SERVICE_SCHEMA)
    hass.services.async_register(
        DOMAIN, SERVICE_DECREMENT, async_handler_service,
-        descriptions[DOMAIN][SERVICE_DECREMENT], SERVICE_SCHEMA)
+        descriptions[SERVICE_DECREMENT], SERVICE_SCHEMA)
    hass.services.async_register(
        DOMAIN, SERVICE_RESET, async_handler_service,
-        descriptions[DOMAIN][SERVICE_RESET], SERVICE_SCHEMA)
+        descriptions[SERVICE_RESET], SERVICE_SCHEMA)

    yield from component.async_add_entities(entities)
    return True
@@ -0,0 +1,20 @@
+# Describes the format for available counter services
+
+decrement:
+  description: Decrement a counter.
+  fields:
+    entity_id:
+      description: Entity id of the counter to decrement.
+      example: 'counter.count0'
+increment:
+  description: Increment a counter.
+  fields:
+    entity_id:
+      description: Entity id of the counter to increment.
+      example: 'counter.count0'
+reset:
+  description: Reset a counter.
+  fields:
+    entity_id:
+      description: Entity id of the counter to reset.
+      example: 'counter.count0'
@@ -4,6 +4,7 @@ Support for Lutron Caseta shades.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/cover.lutron_caseta/
 """
+import asyncio
 import logging

 from homeassistant.components.cover import (
@@ -18,7 +19,8 @@ DEPENDENCIES = ['lutron_caseta']


 # pylint: disable=unused-argument
-def setup_platform(hass, config, add_devices, discovery_info=None):
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
    """Set up the Lutron Caseta shades as a cover device."""
    devs = []
    bridge = hass.data[LUTRON_CASETA_SMARTBRIDGE]
@@ -27,7 +29,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
        dev = LutronCasetaCover(cover_device, bridge)
        devs.append(dev)

-    add_devices(devs, True)
+    async_add_devices(devs, True)


 class LutronCasetaCover(LutronCasetaDevice, CoverDevice):
@@ -48,21 +50,25 @@ class LutronCasetaCover(LutronCasetaDevice, CoverDevice):
        """Return the current position of cover."""
        return self._state['current_state']

-    def close_cover(self, **kwargs):
+    @asyncio.coroutine
+    def async_close_cover(self, **kwargs):
        """Close the cover."""
        self._smartbridge.set_value(self._device_id, 0)

-    def open_cover(self, **kwargs):
+    @asyncio.coroutine
+    def async_open_cover(self, **kwargs):
        """Open the cover."""
        self._smartbridge.set_value(self._device_id, 100)

-    def set_cover_position(self, **kwargs):
+    @asyncio.coroutine
+    def async_set_cover_position(self, **kwargs):
        """Move the shade to a specific position."""
        if ATTR_POSITION in kwargs:
            position = kwargs[ATTR_POSITION]
            self._smartbridge.set_value(self._device_id, position)

-    def update(self):
+    @asyncio.coroutine
+    def async_update(self):
        """Call when forcing a refresh of the device."""
        self._state = self._smartbridge.get_device_by_id(self._device_id)
        _LOGGER.debug(self._state)
@@ -104,6 +104,9 @@ PLATFORM_SCHEMA = mqtt.MQTT_BASE_PLATFORM_SCHEMA.extend({
@asyncio.coroutine
 def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
    """Set up the MQTT Cover."""
+    if discovery_info is not None:
+        config = PLATFORM_SCHEMA(discovery_info)
+
    value_template = config.get(CONF_VALUE_TEMPLATE)
    if value_template is not None:
        value_template.hass = hass
@@ -1,71 +1,63 @@
-open_cover:
-  description: Open all or specified cover
+# Describes the format for available cover services

+open_cover:
+  description: Open all or specified cover.
  fields:
    entity_id:
-      description: Name(s) of cover(s) to open
+      description: Name(s) of cover(s) to open.
      example: 'cover.living_room'

 close_cover:
-  description: Close all or specified cover
-
+  description: Close all or specified cover.
  fields:
    entity_id:
-      description: Name(s) of cover(s) to close
+      description: Name(s) of cover(s) to close.
      example: 'cover.living_room'

 set_cover_position:
-  description: Move to specific position all or specified cover
-
+  description: Move to specific position all or specified cover.
  fields:
    entity_id:
-      description: Name(s) of cover(s) to set cover position
+      description: Name(s) of cover(s) to set cover position.
      example: 'cover.living_room'
-
    position:
-      description: Position of the cover (0 to 100)
+      description: Position of the cover (0 to 100).
      example: 30

 stop_cover:
-  description: Stop all or specified cover
-
+  description: Stop all or specified cover.
  fields:
    entity_id:
-      description: Name(s) of cover(s) to stop
+      description: Name(s) of cover(s) to stop.
      example: 'cover.living_room'

 open_cover_tilt:
-  description: Open all or specified cover tilt
-
+  description: Open all or specified cover tilt.
  fields:
    entity_id:
-      description: Name(s) of cover(s) tilt to open
+      description: Name(s) of cover(s) tilt to open.
      example: 'cover.living_room'

 close_cover_tilt:
-  description: Close all or specified cover tilt
-
+  description: Close all or specified cover tilt.
  fields:
    entity_id:
-      description: Name(s) of cover(s) to close tilt
+      description: Name(s) of cover(s) to close tilt.
      example: 'cover.living_room'

 set_cover_tilt_position:
-  description: Move to specific position all or specified cover tilt
-
+  description: Move to specific position all or specified cover tilt.
  fields:
    entity_id:
-      description: Name(s) of cover(s) to set cover tilt position
+      description: Name(s) of cover(s) to set cover tilt position.
      example: 'cover.living_room'
-
    position:
-      description: Position of the cover (0 to 100)
+      description: Position of the cover (0 to 100).
      example: 30

 stop_cover_tilt:
-  description: Stop all or specified cover
-
+  description: Stop all or specified cover.
  fields:
    entity_id:
-      description: Name(s) of cover(s) to stop
+      description: Name(s) of cover(s) to stop.
      example: 'cover.living_room'
@@ -19,7 +19,8 @@ from homeassistant.const import (
    CONF_FRIENDLY_NAME, CONF_ENTITY_ID,
    EVENT_HOMEASSISTANT_START, MATCH_ALL,
    CONF_VALUE_TEMPLATE, CONF_ICON_TEMPLATE,
-    CONF_OPTIMISTIC, STATE_OPEN, STATE_CLOSED)
+    CONF_ENTITY_PICTURE_TEMPLATE, CONF_OPTIMISTIC,
+    STATE_OPEN, STATE_CLOSED)
 from homeassistant.exceptions import TemplateError
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.entity import async_generate_entity_id
@@ -57,6 +58,7 @@ COVER_SCHEMA = vol.Schema({
    vol.Optional(CONF_POSITION_TEMPLATE): cv.template,
    vol.Optional(CONF_TILT_TEMPLATE): cv.template,
    vol.Optional(CONF_ICON_TEMPLATE): cv.template,
+    vol.Optional(CONF_ENTITY_PICTURE_TEMPLATE): cv.template,
    vol.Optional(CONF_OPTIMISTIC): cv.boolean,
    vol.Optional(CONF_TILT_OPTIMISTIC): cv.boolean,
    vol.Optional(POSITION_ACTION): cv.SCRIPT_SCHEMA,
@@ -81,6 +83,8 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
        position_template = device_config.get(CONF_POSITION_TEMPLATE)
        tilt_template = device_config.get(CONF_TILT_TEMPLATE)
        icon_template = device_config.get(CONF_ICON_TEMPLATE)
+        entity_picture_template = device_config.get(
+            CONF_ENTITY_PICTURE_TEMPLATE)
        open_action = device_config.get(OPEN_ACTION)
        close_action = device_config.get(CLOSE_ACTION)
        stop_action = device_config.get(STOP_ACTION)
@@ -114,6 +118,11 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
            if str(temp_ids) != MATCH_ALL:
                template_entity_ids |= set(temp_ids)

+        if entity_picture_template is not None:
+            temp_ids = entity_picture_template.extract_entities()
+            if str(temp_ids) != MATCH_ALL:
+                template_entity_ids |= set(temp_ids)
+
        if not template_entity_ids:
            template_entity_ids = MATCH_ALL

@@ -124,8 +133,8 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
                hass,
                device, friendly_name, state_template,
                position_template, tilt_template, icon_template,
-                open_action, close_action, stop_action,
-                position_action, tilt_action,
+                entity_picture_template, open_action, close_action,
+                stop_action, position_action, tilt_action,
                optimistic, tilt_optimistic, entity_ids
            )
        )
@@ -142,8 +151,8 @@ class CoverTemplate(CoverDevice):

    def __init__(self, hass, device_id, friendly_name, state_template,
                 position_template, tilt_template, icon_template,
-                 open_action, close_action, stop_action,
-                 position_action, tilt_action,
+                 entity_picture_template, open_action, close_action,
+                 stop_action, position_action, tilt_action,
                 optimistic, tilt_optimistic, entity_ids):
        """Initialize the Template cover."""
        self.hass = hass
@@ -154,6 +163,7 @@ class CoverTemplate(CoverDevice):
        self._position_template = position_template
        self._tilt_template = tilt_template
        self._icon_template = icon_template
+        self._entity_picture_template = entity_picture_template
        self._open_script = None
        if open_action is not None:
            self._open_script = Script(hass, open_action)
@@ -173,6 +183,7 @@ class CoverTemplate(CoverDevice):
                            (not state_template and not position_template))
        self._tilt_optimistic = tilt_optimistic or not tilt_template
        self._icon = None
+        self._entity_picture = None
        self._position = None
        self._tilt_value = None
        self._entities = entity_ids
@@ -185,6 +196,8 @@ class CoverTemplate(CoverDevice):
            self._tilt_template.hass = self.hass
        if self._icon_template is not None:
            self._icon_template.hass = self.hass
+        if self._entity_picture_template is not None:
+            self._entity_picture_template.hass = self.hass

    @asyncio.coroutine
    def async_added_to_hass(self):
@@ -236,6 +249,11 @@ class CoverTemplate(CoverDevice):
        """Return the icon to use in the frontend, if any."""
        return self._icon

+    @property
+    def entity_picture(self):
+        """Return the entity picture to use in the frontend, if any."""
+        return self._entity_picture
+
    @property
    def supported_features(self):
        """Flag supported features."""
@@ -283,7 +301,7 @@ class CoverTemplate(CoverDevice):
    def async_stop_cover(self, **kwargs):
        """Fire the stop action."""
        if self._stop_script:
-            self.hass.async_add_job(self._stop_script.async_run())
+            yield from self._stop_script.async_run()

    @asyncio.coroutine
    def async_set_cover_position(self, **kwargs):
@@ -369,16 +387,28 @@ class CoverTemplate(CoverDevice):
            except ValueError as ex:
                _LOGGER.error(ex)
                self._tilt_value = None
-        if self._icon_template is not None:
+
+        for property_name, template in (
+                ('_icon', self._icon_template),
+                ('_entity_picture', self._entity_picture_template)):
+            if template is None:
+                continue
+
            try:
-                self._icon = self._icon_template.async_render()
+                setattr(self, property_name, template.async_render())
            except TemplateError as ex:
+                friendly_property_name = property_name[1:].replace('_', ' ')
                if ex.args and ex.args[0].startswith(
                        "UndefinedError: 'None' has no attribute"):
                    # Common during HA startup - so just a warning
-                    _LOGGER.warning('Could not render icon template %s,'
-                                    ' the state is unknown.', self._name)
+                    _LOGGER.warning('Could not render %s template %s,'
+                                    ' the state is unknown.',
+                                    friendly_property_name, self._name)
                    return
-                self._icon = super().icon
-                _LOGGER.error('Could not render icon template %s: %s',
-                              self._name, ex)
+
+                try:
+                    setattr(self, property_name,
+                            getattr(super(), property_name))
+                except AttributeError:
+                    _LOGGER.error('Could not render %s template %s: %s',
+                                  friendly_property_name, self._name, ex)
@@ -21,7 +21,7 @@ from homeassistant.components import group, zone
 from homeassistant.config import load_yaml_config_file, async_log_exception
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers import config_per_platform
+from homeassistant.helpers import config_per_platform, discovery
 from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.event import async_track_time_interval
 from homeassistant.helpers.restore_state import async_get_last_state
@@ -76,6 +76,7 @@ ATTR_LOCATION_NAME = 'location_name'
 ATTR_MAC = 'mac'
 ATTR_NAME = 'name'
 ATTR_SOURCE_TYPE = 'source_type'
+ATTR_VENDOR = 'vendor'

 SOURCE_TYPE_GPS = 'gps'
 SOURCE_TYPE_ROUTER = 'router'
@@ -175,6 +176,13 @@ def async_setup(hass: HomeAssistantType, config: ConfigType):

    tracker.async_setup_group()

+    @asyncio.coroutine
+    def async_platform_discovered(platform, info):
+        """Load a platform."""
+        yield from async_setup_platform(platform, {}, disc_info=info)
+
+    discovery.async_listen_platform(hass, DOMAIN, async_platform_discovered)
+
    # Clean up stale devices
    async_track_utc_time_change(
        hass, tracker.async_update_stale, second=range(0, 60, 5))
@@ -278,11 +286,6 @@ class DeviceTracker(object):
        if device.track:
            yield from device.async_update_ha_state()

-        self.hass.bus.async_fire(EVENT_NEW_DEVICE, {
-            ATTR_ENTITY_ID: device.entity_id,
-            ATTR_HOST_NAME: device.host_name,
-        })
-
        # During init, we ignore the group
        if self.group and self.track_new:
            self.group.async_set_group(
@@ -292,6 +295,13 @@ class DeviceTracker(object):
        # lookup mac vendor string to be stored in config
        yield from device.set_vendor_for_mac()

+        self.hass.bus.async_fire(EVENT_NEW_DEVICE, {
+            ATTR_ENTITY_ID: device.entity_id,
+            ATTR_HOST_NAME: device.host_name,
+            ATTR_MAC: device.mac,
+            ATTR_VENDOR: device.vendor,
+        })
+
        # update known_devices.yaml
        self.hass.async_add_job(
            self.async_update_config(
@@ -12,18 +12,17 @@ from collections import namedtuple

 import voluptuous as vol

+import homeassistant.helpers.config_validation as cv
 from homeassistant.components.device_tracker import (
    DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import (
-    CONF_HOST, CONF_PASSWORD, CONF_USERNAME, CONF_PORT)
-import homeassistant.helpers.config_validation as cv
+    CONF_HOST, CONF_PASSWORD, CONF_USERNAME, CONF_PORT, CONF_MODE,
+    CONF_PROTOCOL)

 REQUIREMENTS = ['pexpect==4.0.1']

 _LOGGER = logging.getLogger(__name__)

-CONF_MODE = 'mode'
-CONF_PROTOCOL = 'protocol'
 CONF_PUB_KEY = 'pub_key'
 CONF_SSH_KEY = 'ssh_key'

@@ -36,10 +35,8 @@ PLATFORM_SCHEMA = vol.All(
    PLATFORM_SCHEMA.extend({
        vol.Required(CONF_HOST): cv.string,
        vol.Required(CONF_USERNAME): cv.string,
-        vol.Optional(CONF_PROTOCOL, default='ssh'):
-            vol.In(['ssh', 'telnet']),
-        vol.Optional(CONF_MODE, default='router'):
-            vol.In(['router', 'ap']),
+        vol.Optional(CONF_PROTOCOL, default='ssh'): vol.In(['ssh', 'telnet']),
+        vol.Optional(CONF_MODE, default='router'): vol.In(['router', 'ap']),
        vol.Optional(CONF_PORT, default=DEFAULT_SSH_PORT): cv.port,
        vol.Exclusive(CONF_PASSWORD, SECRET_GROUP): cv.string,
        vol.Exclusive(CONF_SSH_KEY, SECRET_GROUP): cv.isfile,
@@ -102,21 +99,18 @@ class AsusWrtDeviceScanner(DeviceScanner):
                self.success_init = False
                return

-            self.connection = SshConnection(self.host, self.port,
-                                            self.username,
-                                            self.password,
-                                            self.ssh_key,
-                                            self.mode == "ap")
+            self.connection = SshConnection(
+                self.host, self.port, self.username, self.password,
+                self.ssh_key, self.mode == 'ap')
        else:
            if not self.password:
                _LOGGER.error("No password specified")
                self.success_init = False
                return

-            self.connection = TelnetConnection(self.host, self.port,
-                                               self.username,
-                                               self.password,
-                                               self.mode == "ap")
+            self.connection = TelnetConnection(
+                self.host, self.port, self.username, self.password,
+                self.mode == 'ap')

        self.last_results = {}

@@ -23,7 +23,7 @@ from homeassistant.helpers.aiohttp_client import async_get_clientsession
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.event import async_track_time_interval

-REQUIREMENTS = ['aioautomatic==0.6.3']
+REQUIREMENTS = ['aioautomatic==0.6.4']
 DEPENDENCIES = ['http']

 _LOGGER = logging.getLogger(__name__)
@@ -35,7 +35,7 @@ CONF_CURRENT_LOCATION = 'current_location'

 DEFAULT_TIMEOUT = 5

-DEFAULT_SCOPE = ['location', 'vehicle:profile', 'trip']
+DEFAULT_SCOPE = ['location', 'trip', 'vehicle:events', 'vehicle:profile']
 FULL_SCOPE = DEFAULT_SCOPE + ['current_location']

 ATTR_FUEL_LEVEL = 'fuel_level'
@@ -21,6 +21,9 @@ _LOGGER = logging.getLogger(__name__)

 DEPENDENCIES = ['http']

+ATTR_CURRENT_LATITUDE = 'currentLatitude'
+ATTR_CURRENT_LONGITUDE = 'currentLongitude'
+
 BEACON_DEV_PREFIX = 'beacon'
 CONF_MOBILE_BEACONS = 'mobile_beacons'

@@ -72,6 +75,9 @@ class GeofencyView(HomeAssistantView):
                location_name = data['name']
            else:
                location_name = STATE_NOT_HOME
+                if ATTR_CURRENT_LATITUDE in data:
+                    data[ATTR_LATITUDE] = data[ATTR_CURRENT_LATITUDE]
+                    data[ATTR_LONGITUDE] = data[ATTR_CURRENT_LONGITUDE]

            return (yield from self._set_location(hass, data, location_name))

@@ -96,8 +102,12 @@ class GeofencyView(HomeAssistantView):
        data['device'] = slugify(data['device'])
        data['name'] = slugify(data['name'])

-        data[ATTR_LATITUDE] = float(data[ATTR_LATITUDE])
-        data[ATTR_LONGITUDE] = float(data[ATTR_LONGITUDE])
+        gps_attributes = [ATTR_LATITUDE, ATTR_LONGITUDE,
+                          ATTR_CURRENT_LATITUDE, ATTR_CURRENT_LONGITUDE]
+
+        for attribute in gps_attributes:
+            if attribute in data:
+                data[attribute] = float(data[attribute])

        return data

@@ -0,0 +1,138 @@
+"""
+Support for the Hitron CODA-4582U, provided by Rogers.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.hitron_coda/
+"""
+import logging
+from collections import namedtuple
+
+import requests
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.device_tracker import (
+    DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
+from homeassistant.const import (
+    CONF_HOST, CONF_PASSWORD, CONF_USERNAME
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_HOST): cv.string,
+    vol.Required(CONF_USERNAME): cv.string,
+    vol.Required(CONF_PASSWORD): cv.string
+})
+
+
+def get_scanner(_hass, config):
+    """Validate the configuration and return a Nmap scanner."""
+    scanner = HitronCODADeviceScanner(config[DOMAIN])
+
+    return scanner if scanner.success_init else None
+
+
+Device = namedtuple('Device', ['mac', 'name'])
+
+
+class HitronCODADeviceScanner(DeviceScanner):
+    """This class scans for devices using the CODA's web interface."""
+
+    def __init__(self, config):
+        """Initialize the scanner."""
+        self.last_results = []
+        host = config[CONF_HOST]
+        self._url = 'http://{}/data/getConnectInfo.asp'.format(host)
+        self._loginurl = 'http://{}/goform/login'.format(host)
+
+        self._username = config.get(CONF_USERNAME)
+        self._password = config.get(CONF_PASSWORD)
+
+        self._userid = None
+
+        self.success_init = self._update_info()
+        _LOGGER.info("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 device with the given MAC address."""
+        name = next((
+            device.name for device in self.last_results
+            if device.mac == mac), None)
+        return name
+
+    def _login(self):
+        """Log in to the router. This is required for subsequent api calls."""
+        _LOGGER.info("Logging in to CODA...")
+
+        try:
+            data = [
+                ('user', self._username),
+                ('pws', self._password),
+            ]
+            res = requests.post(self._loginurl, data=data, timeout=10)
+        except requests.exceptions.Timeout:
+            _LOGGER.error(
+                "Connection to the router timed out at URL %s", self._url)
+            return False
+        if res.status_code != 200:
+            _LOGGER.error(
+                "Connection failed with http code %s", res.status_code)
+            return False
+        try:
+            self._userid = res.cookies['userid']
+            return True
+        except KeyError:
+            _LOGGER.error("Failed to log in to router")
+            return False
+
+    def _update_info(self):
+        """Get ARP from router."""
+        _LOGGER.info("Fetching...")
+
+        if self._userid is None:
+            if not self._login():
+                _LOGGER.error("Could not obtain a user ID from the router")
+                return False
+        last_results = []
+
+        # doing a request
+        try:
+            res = requests.get(self._url, timeout=10, cookies={
+                'userid': self._userid
+            })
+        except requests.exceptions.Timeout:
+            _LOGGER.error(
+                "Connection to the router timed out at URL %s", self._url)
+            return False
+        if res.status_code != 200:
+            _LOGGER.error(
+                "Connection failed with http code %s", res.status_code)
+            return False
+        try:
+            result = res.json()
+        except ValueError:
+            # If json decoder could not parse the response
+            _LOGGER.error("Failed to parse response from router")
+            return False
+
+        # parsing response
+        for info in result:
+            mac = info['macAddr']
+            name = info['hostName']
+            # No address = no item :)
+            if mac is None:
+                continue
+
+            last_results.append(Device(mac.upper(), name))
+
+        self.last_results = last_results
+
+        _LOGGER.info("Request successful")
+        return True
@@ -76,25 +76,47 @@ class MikrotikScanner(DeviceScanner):
                port=int(self.port)
            )

-            routerboard_info = self.client(cmd='/system/routerboard/getall')
+            try:
+                routerboard_info = self.client(
+                    cmd='/system/routerboard/getall')
+            except (librouteros.exceptions.TrapError,
+                    librouteros.exceptions.MultiTrapError,
+                    librouteros.exceptions.ConnectionError):
+                routerboard_info = None
+                raise

            if routerboard_info:
                _LOGGER.info("Connected to Mikrotik %s with IP %s",
                             routerboard_info[0].get('model', 'Router'),
                             self.host)
+
                self.connected = True
-                self.capsman_exist = self.client(
-                    cmd='/capsman/interface/getall'
-                )
+
+                try:
+                    self.capsman_exist = self.client(
+                        cmd='/caps-man/interface/getall'
+                    )
+                except (librouteros.exceptions.TrapError,
+                        librouteros.exceptions.MultiTrapError,
+                        librouteros.exceptions.ConnectionError):
+                    self.capsman_exist = False
+
                if not self.capsman_exist:
                    _LOGGER.info(
                        'Mikrotik %s: Not a CAPSman controller. Trying '
                        'local interfaces ',
                        self.host
                    )
-                self.wireless_exist = self.client(
-                    cmd='/interface/wireless/getall'
-                )
+
+                try:
+                    self.wireless_exist = self.client(
+                        cmd='/interface/wireless/getall'
+                    )
+                except (librouteros.exceptions.TrapError,
+                        librouteros.exceptions.MultiTrapError,
+                        librouteros.exceptions.ConnectionError):
+                    self.wireless_exist = False
+
                if not self.wireless_exist:
                    _LOGGER.info(
                        'Mikrotik %s: Wireless adapters not found. Try to '
@@ -104,6 +126,7 @@ class MikrotikScanner(DeviceScanner):
                    )

        except (librouteros.exceptions.TrapError,
+                librouteros.exceptions.MultiTrapError,
                librouteros.exceptions.ConnectionError) as api_error:
            _LOGGER.error("Connection error: %s", api_error)

@@ -20,7 +20,7 @@ from homeassistant.const import STATE_HOME
 from homeassistant.core import callback
 from homeassistant.util import slugify, decorator

-REQUIREMENTS = ['libnacl==1.6.0']
+REQUIREMENTS = ['libnacl==1.6.1']

 _LOGGER = logging.getLogger(__name__)

@@ -199,7 +199,7 @@ class OwnTracksContext:
        self.async_see = async_see
        self.secret = secret
        self.max_gps_accuracy = max_gps_accuracy
-        self.mobile_beacons_active = defaultdict(list)
+        self.mobile_beacons_active = defaultdict(set)
        self.regions_entered = defaultdict(list)
        self.import_waypoints = import_waypoints
        self.waypoint_whitelist = waypoint_whitelist
@@ -234,10 +234,25 @@ class OwnTracksContext:
        return True

    @asyncio.coroutine
-    def async_see_beacons(self, dev_id, kwargs_param):
+    def async_see_beacons(self, hass, dev_id, kwargs_param):
        """Set active beacons to the current location."""
        kwargs = kwargs_param.copy()
+
+        # Mobile beacons should always be set to the location of the
+        # tracking device. I get the device state and make the necessary
+        # changes to kwargs.
+        device_tracker_state = hass.states.get(
+            "device_tracker.{}".format(dev_id))
+
+        if device_tracker_state is not None:
+            acc = device_tracker_state.attributes.get("gps_accuracy")
+            lat = device_tracker_state.attributes.get("latitude")
+            lon = device_tracker_state.attributes.get("longitude")
+            kwargs['gps_accuracy'] = acc
+            kwargs['gps'] = (lat, lon)
+
        # the battery state applies to the tracking device, not the beacon
+        # kwargs location is the beacon's configured lat/lon
        kwargs.pop('battery', None)
        for beacon in self.mobile_beacons_active[dev_id]:
            kwargs['dev_id'] = "{}_{}".format(BEACON_DEV_ID, beacon)
@@ -261,7 +276,7 @@ def async_handle_location_message(hass, context, message):
        return

    yield from context.async_see(**kwargs)
-    yield from context.async_see_beacons(dev_id, kwargs)
+    yield from context.async_see_beacons(hass, dev_id, kwargs)


@asyncio.coroutine
@@ -271,11 +286,15 @@ def _async_transition_message_enter(hass, context, message, location):
    dev_id, kwargs = _parse_see_args(message)

    if zone is None and message.get('t') == 'b':
-        # Not a HA zone, and a beacon so assume mobile
+        # Not a HA zone, and a beacon so mobile beacon.
+        # kwargs will contain the lat/lon of the beacon
+        # which is not where the beacon actually is
+        # and is probably set to 0/0
        beacons = context.mobile_beacons_active[dev_id]
        if location not in beacons:
-            beacons.append(location)
+            beacons.add(location)
        _LOGGER.info("Added beacon %s", location)
+        yield from context.async_see_beacons(hass, dev_id, kwargs)
    else:
        # Normal region
        regions = context.regions_entered[dev_id]
@@ -283,9 +302,8 @@ def _async_transition_message_enter(hass, context, message, location):
            regions.append(location)
        _LOGGER.info("Enter region %s", location)
        _set_gps_from_zone(kwargs, location, zone)
-
-    yield from context.async_see(**kwargs)
-    yield from context.async_see_beacons(dev_id, kwargs)
+        yield from context.async_see(**kwargs)
+        yield from context.async_see_beacons(hass, dev_id, kwargs)


@asyncio.coroutine
@@ -297,30 +315,29 @@ def _async_transition_message_leave(hass, context, message, location):
    if location in regions:
        regions.remove(location)

-    new_region = regions[-1] if regions else None
-
-    if new_region:
-        # Exit to previous region
-        zone = hass.states.get(
-            "zone.{}".format(slugify(new_region)))
-        _set_gps_from_zone(kwargs, new_region, zone)
-        _LOGGER.info("Exit to %s", new_region)
-        yield from context.async_see(**kwargs)
-        yield from context.async_see_beacons(dev_id, kwargs)
-        return
-
+    beacons = context.mobile_beacons_active[dev_id]
+    if location in beacons:
+        beacons.remove(location)
+        _LOGGER.info("Remove beacon %s", location)
+        yield from context.async_see_beacons(hass, dev_id, kwargs)
    else:
+        new_region = regions[-1] if regions else None
+        if new_region:
+            # Exit to previous region
+            zone = hass.states.get(
+                "zone.{}".format(slugify(new_region)))
+            _set_gps_from_zone(kwargs, new_region, zone)
+            _LOGGER.info("Exit to %s", new_region)
+            yield from context.async_see(**kwargs)
+            yield from context.async_see_beacons(hass, dev_id, kwargs)
+            return
+
        _LOGGER.info("Exit to GPS")

        # Check for GPS accuracy
        if context.async_valid_accuracy(message):
            yield from context.async_see(**kwargs)
-            yield from context.async_see_beacons(dev_id, kwargs)
-
-    beacons = context.mobile_beacons_active[dev_id]
-    if location in beacons:
-        beacons.remove(location)
-        _LOGGER.info("Remove beacon %s", location)
+            yield from context.async_see_beacons(hass, dev_id, kwargs)


@HANDLERS.register('transition')
@@ -350,6 +367,29 @@ def async_handle_transition_message(hass, context, message):
            message['event'])


+@asyncio.coroutine
+def async_handle_waypoint(hass, name_base, waypoint):
+    """Handle a waypoint."""
+    name = waypoint['desc']
+    pretty_name = '{} - {}'.format(name_base, name)
+    lat = waypoint['lat']
+    lon = waypoint['lon']
+    rad = waypoint['rad']
+
+    # check zone exists
+    entity_id = zone_comp.ENTITY_ID_FORMAT.format(slugify(pretty_name))
+
+    # Check if state already exists
+    if hass.states.get(entity_id) is not None:
+        return
+
+    zone = zone_comp.Zone(hass, pretty_name, lat, lon, rad,
+                          zone_comp.ICON_IMPORT, False)
+    zone.entity_id = entity_id
+    yield from zone.async_update_ha_state()
+
+
+@HANDLERS.register('waypoint')
@HANDLERS.register('waypoints')
@asyncio.coroutine
 def async_handle_waypoints_message(hass, context, message):
@@ -363,30 +403,17 @@ def async_handle_waypoints_message(hass, context, message):
        if user not in context.waypoint_whitelist:
            return

-    wayps = message['waypoints']
+    if 'waypoints' in message:
+        wayps = message['waypoints']
+    else:
+        wayps = [message]

    _LOGGER.info("Got %d waypoints from %s", len(wayps), message['topic'])

    name_base = ' '.join(_parse_topic(message['topic']))

    for wayp in wayps:
-        name = wayp['desc']
-        pretty_name = '{} - {}'.format(name_base, name)
-        lat = wayp['lat']
-        lon = wayp['lon']
-        rad = wayp['rad']
-
-        # check zone exists
-        entity_id = zone_comp.ENTITY_ID_FORMAT.format(slugify(pretty_name))
-
-        # Check if state already exists
-        if hass.states.get(entity_id) is not None:
-            continue
-
-        zone = zone_comp.Zone(hass, pretty_name, lat, lon, rad,
-                              zone_comp.ICON_IMPORT, False)
-        zone.entity_id = entity_id
-        yield from zone.async_update_ha_state()
+        yield from async_handle_waypoint(hass, name_base, wayp)


@HANDLERS.register('encrypted')
@@ -406,10 +433,22 @@ def async_handle_encrypted_message(hass, context, message):


@HANDLERS.register('lwt')
+@HANDLERS.register('configuration')
+@HANDLERS.register('beacon')
+@HANDLERS.register('cmd')
+@HANDLERS.register('steps')
+@HANDLERS.register('card')
@asyncio.coroutine
-def async_handle_lwt_message(hass, context, message):
-    """Handle an lwt message."""
-    _LOGGER.debug('Not handling lwt message: %s', message)
+def async_handle_not_impl_msg(hass, context, message):
+    """Handle valid but not implemented message types."""
+    _LOGGER.debug('Not handling %s message: %s', message.get("_type"), message)
+
+
+@asyncio.coroutine
+def async_handle_unsupported_msg(hass, context, message):
+    """Handle an unsupported or invalid message type."""
+    _LOGGER.warning('Received unsupported message type: %s.',
+                    message.get('_type'))


@asyncio.coroutine
@@ -417,11 +456,6 @@ def async_handle_message(hass, context, message):
    """Handle an OwnTracks message."""
    msgtype = message.get('_type')

-    handler = HANDLERS.get(msgtype)
-
-    if handler is None:
-        _LOGGER.warning(
-            'Received unsupported message type: %s.', msgtype)
-        return
+    handler = HANDLERS.get(msgtype, async_handle_unsupported_msg)

    yield from handler(hass, context, message)
@@ -1,41 +1,33 @@
 # Describes the format for available device tracker services

 see:
-  description: Control tracked device
-
+  description: Control tracked device.
  fields:
    mac:
      description: MAC address of device
      example: 'FF:FF:FF:FF:FF:FF'
-
    dev_id:
-      description: Id of device (find id in known_devices.yaml)
+      description: Id of device (find id in known_devices.yaml).
      example: 'phonedave'
-
    host_name:
      description: Hostname of device
      example: 'Dave'
-
    location_name:
-      description: Name of location where device is located (not_home is away)
+      description: Name of location where device is located (not_home is away).
      example: 'home'
-
    gps:
-      description: GPS coordinates where device is located (latitude, longitude)
+      description: GPS coordinates where device is located (latitude, longitude).
      example: '[51.509802, -0.086692]'
-
    gps_accuracy:
-      description: Accuracy of GPS coordinates
+      description: Accuracy of GPS coordinates.
      example: '80'
-
    battery:
-      description: Battery level of device
+      description: Battery level of device.
      example: '100'

 icloud:
  icloud_lost_iphone:
-    description: Service to play the lost iphone sound on an iDevice
-
+    description: Service to play the lost iphone sound on an iDevice.
    fields:
      account_name:
        description: Name of the account in the config that will be used to look for the device. This is optional, if it isn't given it will use all accounts.
@@ -43,10 +35,8 @@ icloud:
      device_name:
        description: Name of the device that will play the sound. This is optional, if it isn't given it will play on all devices for the given account.
        example: 'iphonebart'
-
  icloud_set_interval:
-    description: Service to set the interval of an iDevice
-
+    description: Service to set the interval of an iDevice.
    fields:
      account_name:
        description: Name of the account in the config that will be used to look for the device. This is optional, if it isn't given it will use all accounts.
@@ -57,10 +47,8 @@ icloud:
      interval:
        description: The interval (in minutes) that the iDevice will have until the according device_tracker entity changes from zone or until this service is used again. This is optional, if it isn't given the interval of the device will revert back to the original interval based on the current state.
        example: 1
-
  icloud_update:
    description: Service to ask for an update of an iDevice.
-
    fields:
      account_name:
        description: Name of the account in the config that will be used to look for the device. This is optional, if it isn't given it will use all accounts.
@@ -68,10 +56,8 @@ icloud:
      device_name:
        description: Name of the device that will be updated. This is optional, if it isn't given it will update all devices for the given account.
        example: 'iphonebart'
-
  icloud_reset_account:
    description: Service to restart an iCloud account. Helpful when not all devices are found after initializing or when you add a new device.
-
    fields:
      account_name:
        description: Name of the account in the config that will be restarted. This is optional, if it isn't given it will restart all accounts.
@@ -14,23 +14,23 @@ from homeassistant.components.device_tracker import (
    DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST

+REQUIREMENTS = ['pysnmp==4.4.2']
+
 _LOGGER = logging.getLogger(__name__)

-REQUIREMENTS = ['pysnmp==4.3.10']
-
-CONF_COMMUNITY = 'community'
 CONF_AUTHKEY = 'authkey'
-CONF_PRIVKEY = 'privkey'
 CONF_BASEOID = 'baseoid'
+CONF_COMMUNITY = 'community'
+CONF_PRIVKEY = 'privkey'

 DEFAULT_COMMUNITY = 'public'

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_BASEOID): cv.string,
    vol.Required(CONF_HOST): 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
 })


@@ -6,13 +6,14 @@ https://home-assistant.io/components/device_tracker.swisscom/
 """
 import logging

+from aiohttp.hdrs import CONTENT_TYPE
 import requests
 import voluptuous as vol

-import homeassistant.helpers.config_validation as cv
 from homeassistant.components.device_tracker import (
    DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST
+import homeassistant.helpers.config_validation as cv

 _LOGGER = logging.getLogger(__name__)

@@ -77,7 +78,7 @@ class SwisscomDeviceScanner(DeviceScanner):
    def get_swisscom_data(self):
        """Retrieve data from Swisscom and return parsed result."""
        url = 'http://{}/ws'.format(self.host)
-        headers = {'Content-Type': 'application/x-sah-ws-4-call+json'}
+        headers = {CONTENT_TYPE: 'application/x-sah-ws-4-call+json'}
        data = """
        {"service":"Devices", "method":"get",
        "parameters":{"expression":"lan and not self"}}"""
@@ -0,0 +1,124 @@
+"""
+Support for Tile® Bluetooth trackers.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.tile/
+"""
+import logging
+
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.device_tracker import (
+    PLATFORM_SCHEMA, DeviceScanner)
+from homeassistant.const import (
+    CONF_USERNAME, CONF_MONITORED_VARIABLES, CONF_PASSWORD)
+from homeassistant.helpers.event import track_utc_time_change
+from homeassistant.util import slugify
+from homeassistant.util.json import load_json, save_json
+
+_LOGGER = logging.getLogger(__name__)
+
+REQUIREMENTS = ['pytile==1.0.0']
+
+CLIENT_UUID_CONFIG_FILE = '.tile.conf'
+DEFAULT_ICON = 'mdi:bluetooth'
+DEVICE_TYPES = ['PHONE', 'TILE']
+
+ATTR_ALTITUDE = 'altitude'
+ATTR_CONNECTION_STATE = 'connection_state'
+ATTR_IS_DEAD = 'is_dead'
+ATTR_IS_LOST = 'is_lost'
+ATTR_LAST_SEEN = 'last_seen'
+ATTR_LAST_UPDATED = 'last_updated'
+ATTR_RING_STATE = 'ring_state'
+ATTR_VOIP_STATE = 'voip_state'
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_USERNAME): cv.string,
+    vol.Required(CONF_PASSWORD): cv.string,
+    vol.Optional(CONF_MONITORED_VARIABLES):
+        vol.All(cv.ensure_list, [vol.In(DEVICE_TYPES)]),
+})
+
+
+def setup_scanner(hass, config: dict, see, discovery_info=None):
+    """Validate the configuration and return a Tile scanner."""
+    TileDeviceScanner(hass, config, see)
+    return True
+
+
+class TileDeviceScanner(DeviceScanner):
+    """Define a device scanner for Tiles."""
+
+    def __init__(self, hass, config, see):
+        """Initialize."""
+        from pytile import Client
+
+        _LOGGER.debug('Received configuration data: %s', config)
+
+        # Load the client UUID (if it exists):
+        config_data = load_json(hass.config.path(CLIENT_UUID_CONFIG_FILE))
+        if config_data:
+            _LOGGER.debug('Using existing client UUID')
+            self._client = Client(
+                config[CONF_USERNAME],
+                config[CONF_PASSWORD],
+                config_data['client_uuid'])
+        else:
+            _LOGGER.debug('Generating new client UUID')
+            self._client = Client(
+                config[CONF_USERNAME],
+                config[CONF_PASSWORD])
+
+            if not save_json(
+                    hass.config.path(CLIENT_UUID_CONFIG_FILE),
+                    {'client_uuid': self._client.client_uuid}):
+                _LOGGER.error("Failed to save configuration file")
+
+        _LOGGER.debug('Client UUID: %s', self._client.client_uuid)
+        _LOGGER.debug('User UUID: %s', self._client.user_uuid)
+
+        self._types = config.get(CONF_MONITORED_VARIABLES)
+
+        self.devices = {}
+        self.see = see
+
+        track_utc_time_change(
+            hass, self._update_info, second=range(0, 60, 30))
+
+        self._update_info()
+
+    def _update_info(self, now=None) -> None:
+        """Update the device info."""
+        device_data = self._client.get_tiles(type_whitelist=self._types)
+
+        try:
+            self.devices = device_data['result']
+        except KeyError:
+            _LOGGER.warning('No Tiles found')
+            _LOGGER.debug(device_data)
+            return
+
+        for info in self.devices.values():
+            dev_id = 'tile_{0}'.format(slugify(info['name']))
+            lat = info['tileState']['latitude']
+            lon = info['tileState']['longitude']
+
+            attrs = {
+                ATTR_ALTITUDE: info['tileState']['altitude'],
+                ATTR_CONNECTION_STATE: info['tileState']['connection_state'],
+                ATTR_IS_DEAD: info['is_dead'],
+                ATTR_IS_LOST: info['tileState']['is_lost'],
+                ATTR_LAST_SEEN: info['tileState']['timestamp'],
+                ATTR_LAST_UPDATED: device_data['timestamp_ms'],
+                ATTR_RING_STATE: info['tileState']['ring_state'],
+                ATTR_VOIP_STATE: info['tileState']['voip_state'],
+            }
+
+            self.see(
+                dev_id=dev_id,
+                gps=(lat, lon),
+                attributes=attrs,
+                icon=DEFAULT_ICON
+            )
@@ -5,21 +5,27 @@ For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/device_tracker.tplink/
 """
 import base64
+from datetime import datetime
 import hashlib
 import logging
 import re
-from datetime import datetime

+from aiohttp.hdrs import (
+    ACCEPT, COOKIE, PRAGMA, REFERER, CONNECTION, KEEP_ALIVE, USER_AGENT,
+    CONTENT_TYPE, CACHE_CONTROL, ACCEPT_ENCODING, ACCEPT_LANGUAGE)
 import requests
 import voluptuous as vol

-import homeassistant.helpers.config_validation as cv
 from homeassistant.components.device_tracker import (
    DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
-from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
+from homeassistant.const import (
+    CONF_HOST, CONF_PASSWORD, CONF_USERNAME, HTTP_HEADER_X_REQUESTED_WITH)
+import homeassistant.helpers.config_validation as cv

 _LOGGER = logging.getLogger(__name__)

+HTTP_HEADER_NO_CACHE = 'no-cache'
+
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Required(CONF_HOST): cv.string,
    vol.Required(CONF_PASSWORD): cv.string,
@@ -78,7 +84,7 @@ class TplinkDeviceScanner(DeviceScanner):
        referer = 'http://{}'.format(self.host)
        page = requests.get(
            url, auth=(self.username, self.password),
-            headers={'referer': referer}, timeout=4)
+            headers={REFERER: referer}, timeout=4)

        result = self.parse_macs.findall(page.text)

@@ -123,7 +129,7 @@ class Tplink2DeviceScanner(TplinkDeviceScanner):
            .format(b64_encoded_username_password)

        response = requests.post(
-            url, headers={'referer': referer, 'cookie': cookie},
+            url, headers={REFERER: referer, COOKIE: cookie},
            timeout=4)

        try:
@@ -174,11 +180,11 @@ class Tplink3DeviceScanner(TplinkDeviceScanner):
            .format(self.host)
        referer = 'http://{}/webpages/login.html'.format(self.host)

-        # If possible implement rsa encryption of password here.
+        # If possible implement RSA encryption of password here.
        response = requests.post(
            url, params={'operation': 'login', 'username': self.username,
                         'password': self.password},
-            headers={'referer': referer}, timeout=4)
+            headers={REFERER: referer}, timeout=4)

        try:
            self.stok = response.json().get('data').get('stok')
@@ -207,11 +213,9 @@ class Tplink3DeviceScanner(TplinkDeviceScanner):
               'form=statistics').format(self.host, self.stok)
        referer = 'http://{}/webpages/index.html'.format(self.host)

-        response = requests.post(url,
-                                 params={'operation': 'load'},
-                                 headers={'referer': referer},
-                                 cookies={'sysauth': self.sysauth},
-                                 timeout=5)
+        response = requests.post(
+            url, params={'operation': 'load'}, headers={REFERER: referer},
+            cookies={'sysauth': self.sysauth}, timeout=5)

        try:
            json_response = response.json()
@@ -248,10 +252,9 @@ class Tplink3DeviceScanner(TplinkDeviceScanner):
               'form=logout').format(self.host, self.stok)
        referer = 'http://{}/webpages/index.html'.format(self.host)

-        requests.post(url,
-                      params={'operation': 'write'},
-                      headers={'referer': referer},
-                      cookies={'sysauth': self.sysauth})
+        requests.post(
+            url, params={'operation': 'write'}, headers={REFERER: referer},
+            cookies={'sysauth': self.sysauth})
        self.stok = ''
        self.sysauth = ''

@@ -292,7 +295,7 @@ class Tplink4DeviceScanner(TplinkDeviceScanner):
        # Create the authorization cookie.
        cookie = 'Authorization=Basic {}'.format(self.credentials)

-        response = requests.get(url, headers={'cookie': cookie})
+        response = requests.get(url, headers={COOKIE: cookie})

        try:
            result = re.search(r'window.parent.location.href = '
@@ -326,8 +329,8 @@ class Tplink4DeviceScanner(TplinkDeviceScanner):
            cookie = 'Authorization=Basic {}'.format(self.credentials)

            page = requests.get(url, headers={
-                'cookie': cookie,
-                'referer': referer
+                COOKIE: cookie,
+                REFERER: referer,
            })
            mac_results.extend(self.parse_macs.findall(page.text))

@@ -361,31 +364,31 @@ class Tplink5DeviceScanner(TplinkDeviceScanner):
        base_url = 'http://{}'.format(self.host)

        header = {
-            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.12;"
-                          " rv:53.0) Gecko/20100101 Firefox/53.0",
-            "Accept": "application/json, text/javascript, */*; q=0.01",
-            "Accept-Language": "Accept-Language: en-US,en;q=0.5",
-            "Accept-Encoding": "gzip, deflate",
-            "Content-Type": "application/x-www-form-urlencoded; "
-                            "charset=UTF-8",
-            "X-Requested-With": "XMLHttpRequest",
-            "Referer": "http://" + self.host + "/",
-            "Connection": "keep-alive",
-            "Pragma": "no-cache",
-            "Cache-Control": "no-cache"
+            USER_AGENT:
+                "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.12;"
+                " rv:53.0) Gecko/20100101 Firefox/53.0",
+            ACCEPT: "application/json, text/javascript, */*; q=0.01",
+            ACCEPT_LANGUAGE: "Accept-Language: en-US,en;q=0.5",
+            ACCEPT_ENCODING: "gzip, deflate",
+            CONTENT_TYPE: "application/x-www-form-urlencoded; charset=UTF-8",
+            HTTP_HEADER_X_REQUESTED_WITH: "XMLHttpRequest",
+            REFERER: "http://{}/".format(self.host),
+            CONNECTION: KEEP_ALIVE,
+            PRAGMA: HTTP_HEADER_NO_CACHE,
+            CACHE_CONTROL: HTTP_HEADER_NO_CACHE,
        }

        password_md5 = hashlib.md5(
            self.password.encode('utf')).hexdigest().upper()

-        # create a session to handle cookie easier
+        # Create a session to handle cookie easier
        session = requests.session()
        session.get(base_url, headers=header)

        login_data = {"username": self.username, "password": password_md5}
        session.post(base_url, login_data, headers=header)

-        # a timestamp is required to be sent as get parameter
+        # A timestamp is required to be sent as get parameter
        timestamp = int(datetime.now().timestamp() * 1e3)

        client_list_url = '{}/data/monitor.client.client.json'.format(
@@ -393,18 +396,17 @@ class Tplink5DeviceScanner(TplinkDeviceScanner):

        get_params = {
            'operation': 'load',
-            '_': timestamp
+            '_': timestamp,
        }

-        response = session.get(client_list_url,
-                               headers=header,
-                               params=get_params)
+        response = session.get(
+            client_list_url, headers=header, params=get_params)
        session.close()
        try:
            list_of_devices = response.json()
        except ValueError:
            _LOGGER.error("AP didn't respond with JSON. "
-                          "Check if credentials are correct.")
+                          "Check if credentials are correct")
            return False

        if list_of_devices:
@@ -19,16 +19,29 @@ from homeassistant.exceptions import HomeAssistantError

 _LOGGER = logging.getLogger(__name__)

+CONF_DHCP_SOFTWARE = 'dhcp_software'
+DEFAULT_DHCP_SOFTWARE = 'dnsmasq'
+DHCP_SOFTWARES = [
+    'dnsmasq',
+    'odhcpd'
+]
+
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Required(CONF_HOST): cv.string,
    vol.Required(CONF_PASSWORD): cv.string,
-    vol.Required(CONF_USERNAME): cv.string
+    vol.Required(CONF_USERNAME): cv.string,
+    vol.Optional(CONF_DHCP_SOFTWARE,
+                 default=DEFAULT_DHCP_SOFTWARE): vol.In(DHCP_SOFTWARES)
 })


 def get_scanner(hass, config):
    """Validate the configuration and return an ubus scanner."""
-    scanner = UbusDeviceScanner(config[DOMAIN])
+    dhcp_sw = config[DOMAIN][CONF_DHCP_SOFTWARE]
+    if dhcp_sw == 'dnsmasq':
+        scanner = DnsmasqUbusDeviceScanner(config[DOMAIN])
+    else:
+        scanner = OdhcpdUbusDeviceScanner(config[DOMAIN])

    return scanner if scanner.success_init else None

@@ -70,7 +83,6 @@ class UbusDeviceScanner(DeviceScanner):
        self.session_id = _get_session_id(self.url, self.username,
                                          self.password)
        self.hostapd = []
-        self.leasefile = None
        self.mac2name = None
        self.success_init = self.session_id is not None

@@ -79,44 +91,29 @@ class UbusDeviceScanner(DeviceScanner):
        self._update_info()
        return self.last_results

+    def _generate_mac2name(self):
+        """Must be implemented depending on the software."""
+        raise NotImplementedError
+
    @_refresh_on_acccess_denied
    def get_device_name(self, mac):
        """Return the name of the given device or None if we don't know."""
-        if self.leasefile is None:
-            result = _req_json_rpc(
-                self.url, self.session_id, 'call', 'uci', 'get',
-                config="dhcp", type="dnsmasq")
-            if result:
-                values = result["values"].values()
-                self.leasefile = next(iter(values))["leasefile"]
-            else:
-                return
-
        if self.mac2name is None:
-            result = _req_json_rpc(
-                self.url, self.session_id, 'call', 'file', 'read',
-                path=self.leasefile)
-            if result:
-                self.mac2name = dict()
-                for line in result["data"].splitlines():
-                    hosts = line.split(" ")
-                    self.mac2name[hosts[1].upper()] = hosts[3]
-            else:
-                # Error, handled in the _req_json_rpc
-                return
-
-        return self.mac2name.get(mac.upper(), None)
+            self._generate_mac2name()
+        name = self.mac2name.get(mac.upper(), None)
+        self.mac2name = None
+        return name

    @_refresh_on_acccess_denied
    def _update_info(self):
-        """Ensure the information from the Luci router is up to date.
+        """Ensure the information from the router is up to date.

        Returns boolean if scanning successful.
        """
        if not self.success_init:
            return False

-        _LOGGER.info("Checking ARP")
+        _LOGGER.info("Checking hostapd")

        if not self.hostapd:
            hostapd = _req_json_rpc(
@@ -136,6 +133,57 @@ class UbusDeviceScanner(DeviceScanner):
        return bool(results)


+class DnsmasqUbusDeviceScanner(UbusDeviceScanner):
+    """Implement the Ubus device scanning for the dnsmasq DHCP server."""
+
+    def __init__(self, config):
+        """Initialize the scanner."""
+        super(DnsmasqUbusDeviceScanner, self).__init__(config)
+        self.leasefile = None
+
+    def _generate_mac2name(self):
+        if self.leasefile is None:
+            result = _req_json_rpc(
+                self.url, self.session_id, 'call', 'uci', 'get',
+                config="dhcp", type="dnsmasq")
+            if result:
+                values = result["values"].values()
+                self.leasefile = next(iter(values))["leasefile"]
+            else:
+                return
+
+        result = _req_json_rpc(
+            self.url, self.session_id, 'call', 'file', 'read',
+            path=self.leasefile)
+        if result:
+            self.mac2name = dict()
+            for line in result["data"].splitlines():
+                hosts = line.split(" ")
+                self.mac2name[hosts[1].upper()] = hosts[3]
+        else:
+            # Error, handled in the _req_json_rpc
+            return
+
+
+class OdhcpdUbusDeviceScanner(UbusDeviceScanner):
+    """Implement the Ubus device scanning for the odhcp DHCP server."""
+
+    def _generate_mac2name(self):
+        result = _req_json_rpc(
+            self.url, self.session_id, 'call', 'dhcp', 'ipv4leases')
+        if result:
+            self.mac2name = dict()
+            for device in result["device"].values():
+                for lease in device['leases']:
+                    mac = lease['mac']  # mac = aabbccddeeff
+                    # Convert it to expected format with colon
+                    mac = ":".join(mac[i:i+2] for i in range(0, len(mac), 2))
+                    self.mac2name[mac.upper()] = lease['hostname']
+        else:
+            # Error, handled in the _req_json_rpc
+            return
+
+
 def _req_json_rpc(url, session_id, rpcmethod, subsystem, method, **params):
    """Perform one JSON RPC operation."""
    data = json.dumps({"jsonrpc": "2.0",
@@ -8,28 +8,28 @@ import asyncio
 import logging

 import aiohttp
+from aiohttp.hdrs import REFERER, USER_AGENT
 import async_timeout
 import voluptuous as vol

-import homeassistant.helpers.config_validation as cv
 from homeassistant.components.device_tracker import (
    DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
-from homeassistant.const import CONF_HOST
+from homeassistant.const import CONF_HOST, HTTP_HEADER_X_REQUESTED_WITH
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
-
+import homeassistant.helpers.config_validation as cv

 REQUIREMENTS = ['defusedxml==0.5.0']

 _LOGGER = logging.getLogger(__name__)

+CMD_DEVICES = 123
+
 DEFAULT_IP = '192.168.0.1'

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Optional(CONF_HOST, default=DEFAULT_IP): cv.string,
 })

-CMD_DEVICES = 123
-

@asyncio.coroutine
 def async_get_scanner(hass, config):
@@ -52,11 +52,11 @@ class UPCDeviceScanner(DeviceScanner):
        self.token = None

        self.headers = {
-            'X-Requested-With': 'XMLHttpRequest',
-            'Referer': "http://{}/index.html".format(self.host),
-            'User-Agent': ("Mozilla/5.0 (Windows NT 10.0; WOW64) "
-                           "AppleWebKit/537.36 (KHTML, like Gecko) "
-                           "Chrome/47.0.2526.106 Safari/537.36")
+            HTTP_HEADER_X_REQUESTED_WITH: 'XMLHttpRequest',
+            REFERER: "http://{}/index.html".format(self.host),
+            USER_AGENT: ("Mozilla/5.0 (Windows NT 10.0; WOW64) "
+                         "AppleWebKit/537.36 (KHTML, like Gecko) "
+                         "Chrome/47.0.2526.106 Safari/537.36")
        }

        self.websession = async_get_clientsession(hass)
@@ -95,8 +95,7 @@ class UPCDeviceScanner(DeviceScanner):
            with async_timeout.timeout(10, loop=self.hass.loop):
                response = yield from self.websession.get(
                    "http://{}/common_page/login.html".format(self.host),
-                    headers=self.headers
-                )
+                    headers=self.headers)

                yield from response.text()

@@ -118,17 +117,15 @@ class UPCDeviceScanner(DeviceScanner):
                response = yield from self.websession.post(
                    "http://{}/xml/getter.xml".format(self.host),
                    data="token={}&fun={}".format(self.token, function),
-                    headers=self.headers,
-                    allow_redirects=False
-                )
+                    headers=self.headers, allow_redirects=False)

-                # error?
+                # Error?
                if response.status != 200:
                    _LOGGER.warning("Receive http code %d", response.status)
                    self.token = None
                    return

-                # load data, store token for next request
+                # Load data, store token for next request
                self.token = response.cookies['sessionToken'].value
                return (yield from response.text())

@@ -1,31 +1,32 @@
 """
-Support for API.AI webhook.
+Support for Dialogflow webhook.

 For more details about this component, please refer to the documentation at
-https://home-assistant.io/components/apiai/
+https://home-assistant.io/components/dialogflow/
 """
 import asyncio
 import logging

 import voluptuous as vol

-from homeassistant.const import PROJECT_NAME, HTTP_BAD_REQUEST
+from homeassistant.const import HTTP_BAD_REQUEST
 from homeassistant.helpers import intent, template
 from homeassistant.components.http import HomeAssistantView

 _LOGGER = logging.getLogger(__name__)

-INTENTS_API_ENDPOINT = '/api/apiai'
-
 CONF_INTENTS = 'intents'
 CONF_SPEECH = 'speech'
 CONF_ACTION = 'action'
 CONF_ASYNC_ACTION = 'async_action'

 DEFAULT_CONF_ASYNC_ACTION = False
-
-DOMAIN = 'apiai'
 DEPENDENCIES = ['http']
+DOMAIN = 'dialogflow'
+
+INTENTS_API_ENDPOINT = '/api/dialogflow'
+
+SOURCE = "Home Assistant Dialogflow"

 CONFIG_SCHEMA = vol.Schema({
    DOMAIN: {}
@@ -34,30 +35,30 @@ CONFIG_SCHEMA = vol.Schema({

@asyncio.coroutine
 def async_setup(hass, config):
-    """Activate API.AI component."""
-    hass.http.register_view(ApiaiIntentsView)
+    """Set up Dialogflow component."""
+    hass.http.register_view(DialogflowIntentsView)

    return True


-class ApiaiIntentsView(HomeAssistantView):
-    """Handle API.AI requests."""
+class DialogflowIntentsView(HomeAssistantView):
+    """Handle Dialogflow requests."""

    url = INTENTS_API_ENDPOINT
-    name = 'api:apiai'
+    name = 'api:dialogflow'

    @asyncio.coroutine
    def post(self, request):
-        """Handle API.AI."""
+        """Handle Dialogflow."""
        hass = request.app['hass']
        data = yield from request.json()

-        _LOGGER.debug("Received api.ai request: %s", data)
+        _LOGGER.debug("Received Dialogflow request: %s", data)

        req = data.get('result')

        if req is None:
-            _LOGGER.error("Received invalid data from api.ai: %s", data)
+            _LOGGER.error("Received invalid data from Dialogflow: %s", data)
            return self.json_message(
                "Expected result value not received", HTTP_BAD_REQUEST)

@@ -68,13 +69,13 @@ class ApiaiIntentsView(HomeAssistantView):

        action = req.get('action')
        parameters = req.get('parameters')
-        apiai_response = ApiaiResponse(parameters)
+        dialogflow_response = DialogflowResponse(parameters)

        if action == "":
            _LOGGER.warning("Received intent with empty action")
-            apiai_response.add_speech(
-                "You have not defined an action in your api.ai intent.")
-            return self.json(apiai_response)
+            dialogflow_response.add_speech(
+                "You have not defined an action in your Dialogflow intent.")
+            return self.json(dialogflow_response)

        try:
            intent_response = yield from intent.async_handle(
@@ -83,31 +84,31 @@ class ApiaiIntentsView(HomeAssistantView):
                 in parameters.items()})

        except intent.UnknownIntent as err:
-            _LOGGER.warning('Received unknown intent %s', action)
-            apiai_response.add_speech(
+            _LOGGER.warning("Received unknown intent %s", action)
+            dialogflow_response.add_speech(
                "This intent is not yet configured within Home Assistant.")
-            return self.json(apiai_response)
+            return self.json(dialogflow_response)

        except intent.InvalidSlotInfo as err:
-            _LOGGER.error('Received invalid slot data: %s', err)
+            _LOGGER.error("Received invalid slot data: %s", err)
            return self.json_message('Invalid slot data received',
                                     HTTP_BAD_REQUEST)
        except intent.IntentError:
-            _LOGGER.exception('Error handling request for %s', action)
+            _LOGGER.exception("Error handling request for %s", action)
            return self.json_message('Error handling intent', HTTP_BAD_REQUEST)

        if 'plain' in intent_response.speech:
-            apiai_response.add_speech(
+            dialogflow_response.add_speech(
                intent_response.speech['plain']['speech'])

-        return self.json(apiai_response)
+        return self.json(dialogflow_response)


-class ApiaiResponse(object):
-    """Help generating the response for API.AI."""
+class DialogflowResponse(object):
+    """Help generating the response for Dialogflow."""

    def __init__(self, parameters):
-        """Initialize the response."""
+        """Initialize the Dialogflow response."""
        self.speech = None
        self.parameters = {}
        # Parameter names replace '.' and '-' for '_'
@@ -125,9 +126,9 @@ class ApiaiResponse(object):
        self.speech = text

    def as_dict(self):
-        """Return response in an API.AI valid dict."""
+        """Return response in a Dialogflow valid dictionary."""
        return {
            'speech': self.speech,
            'displayText': self.speech,
-            'source': PROJECT_NAME,
+            'source': SOURCE,
        }
@@ -21,7 +21,7 @@ from homeassistant.helpers.event import async_track_point_in_utc_time
 from homeassistant.helpers.discovery import async_load_platform, async_discover
 import homeassistant.util.dt as dt_util

-REQUIREMENTS = ['netdisco==1.2.2']
+REQUIREMENTS = ['netdisco==1.2.3']

 DOMAIN = 'discovery'

@@ -17,8 +17,10 @@ from homeassistant.util import sanitize_filename

 _LOGGER = logging.getLogger(__name__)

+ATTR_FILENAME = 'filename'
 ATTR_SUBDIR = 'subdir'
 ATTR_URL = 'url'
+ATTR_OVERWRITE = 'overwrite'

 CONF_DOWNLOAD_DIR = 'download_dir'

@@ -29,6 +31,8 @@ SERVICE_DOWNLOAD_FILE = 'download_file'
 SERVICE_DOWNLOAD_FILE_SCHEMA = vol.Schema({
    vol.Required(ATTR_URL): cv.url,
    vol.Optional(ATTR_SUBDIR): cv.string,
+    vol.Optional(ATTR_FILENAME): cv.string,
+    vol.Optional(ATTR_OVERWRITE, default=False): cv.boolean,
 })

 CONFIG_SCHEMA = vol.Schema({
@@ -62,6 +66,10 @@ def setup(hass, config):

                subdir = service.data.get(ATTR_SUBDIR)

+                filename = service.data.get(ATTR_FILENAME)
+
+                overwrite = service.data.get(ATTR_OVERWRITE)
+
                if subdir:
                    subdir = sanitize_filename(subdir)

@@ -69,10 +77,15 @@ def setup(hass, config):

                req = requests.get(url, stream=True, timeout=10)

-                if req.status_code == 200:
-                    filename = None
+                if req.status_code != 200:
+                    _LOGGER.warning(
+                        "downloading '%s' failed, stauts_code=%d",
+                        url,
+                        req.status_code)

-                    if 'content-disposition' in req.headers:
+                else:
+                    if filename is None and \
+                       'content-disposition' in req.headers:
                        match = re.findall(r"filename=(\S+)",
                                           req.headers['content-disposition'])

@@ -80,8 +93,7 @@ def setup(hass, config):
                            filename = match[0].strip("'\" ")

                    if not filename:
-                        filename = os.path.basename(
-                            url).strip()
+                        filename = os.path.basename(url).strip()

                    if not filename:
                        filename = 'ha_download'
@@ -106,20 +118,21 @@ def setup(hass, config):

                    # If file exist append a number.
                    # We test filename, filename_2..
-                    tries = 1
-                    final_path = path + ext
-                    while os.path.isfile(final_path):
-                        tries += 1
+                    if not overwrite:
+                        tries = 1
+                        final_path = path + ext
+                        while os.path.isfile(final_path):
+                            tries += 1

-                        final_path = "{}_{}.{}".format(path, tries, ext)
+                            final_path = "{}_{}.{}".format(path, tries, ext)

-                    _LOGGER.info("%s -> %s", url, final_path)
+                    _LOGGER.debug("%s -> %s", url, final_path)

                    with open(final_path, 'wb') as fil:
                        for chunk in req.iter_content(1024):
                            fil.write(chunk)

-                    _LOGGER.info("Downloading of %s done", url)
+                    _LOGGER.debug("Downloading of %s done", url)

            except requests.exceptions.ConnectionError:
                _LOGGER.exception("ConnectionError occurred for %s", url)
@@ -1,4 +1,9 @@
-"""Integrate with DuckDNS."""
+"""
+Integrate with DuckDNS.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/duckdns/
+"""
 import asyncio
 from datetime import timedelta
 import logging
@@ -11,13 +16,18 @@ import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.event import async_track_time_interval
 from homeassistant.helpers.aiohttp_client import async_get_clientsession

-DOMAIN = 'duckdns'
-UPDATE_URL = 'https://www.duckdns.org/update'
-INTERVAL = timedelta(minutes=5)
 _LOGGER = logging.getLogger(__name__)
-SERVICE_SET_TXT = 'set_txt'
+
 ATTR_TXT = 'txt'

+DOMAIN = 'duckdns'
+
+INTERVAL = timedelta(minutes=5)
+
+SERVICE_SET_TXT = 'set_txt'
+
+UPDATE_URL = 'https://www.duckdns.org/update'
+
 CONFIG_SCHEMA = vol.Schema({
    DOMAIN: vol.Schema({
        vol.Required(CONF_DOMAIN): cv.string,
@@ -59,8 +69,8 @@ def async_setup(hass, config):
    @asyncio.coroutine
    def update_domain_service(call):
        """Update the DuckDNS entry."""
-        yield from _update_duckdns(session, domain, token,
-                                   txt=call.data[ATTR_TXT])
+        yield from _update_duckdns(
+            session, domain, token, txt=call.data[ATTR_TXT])

    async_track_time_interval(hass, update_domain_interval, INTERVAL)
    hass.services.async_register(
@@ -96,7 +106,7 @@ def _update_duckdns(session, domain, token, *, txt=_SENTINEL, clear=False):
    body = yield from resp.text()

    if body != 'OK':
-        _LOGGER.warning('Updating DuckDNS domain %s failed', domain)
+        _LOGGER.warning("Updating DuckDNS domain failed: %s", domain)
        return False

    return True
@@ -76,7 +76,6 @@ def setup(hass, yaml_config):

    server = HomeAssistantWSGI(
        hass,
-        development=False,
        server_host=config.host_ip_addr,
        server_port=config.listen_port,
        api_password=None,
@@ -287,6 +287,11 @@ def parse_hue_api_put_light_body(request_json, entity):
                report_brightness = True
                result = (brightness > 0)

+        elif entity.domain == "scene":
+            brightness = None
+            report_brightness = False
+            result = True
+
        elif (entity.domain == "script" or
              entity.domain == "media_player" or
              entity.domain == "fan"):
@@ -72,6 +72,7 @@ class EnOceanDongle:
        """
        from enocean.protocol.packet import RadioPacket
        if isinstance(temp, RadioPacket):
+            _LOGGER.debug("Received radio packet: %s", temp)
            rxtype = None
            value = None
            if temp.data[6] == 0x30:
@@ -94,20 +95,20 @@ class EnOceanDongle:
                value = temp.data[2]
            for device in self.__devices:
                if rxtype == "wallswitch" and device.stype == "listener":
-                    if temp.sender == self._combine_hex(device.dev_id):
+                    if temp.sender_int == self._combine_hex(device.dev_id):
                        device.value_changed(value, temp.data[1])
                if rxtype == "power" and device.stype == "powersensor":
-                    if temp.sender == self._combine_hex(device.dev_id):
+                    if temp.sender_int == self._combine_hex(device.dev_id):
                        device.value_changed(value)
                if rxtype == "power" and device.stype == "switch":
-                    if temp.sender == self._combine_hex(device.dev_id):
+                    if temp.sender_int == self._combine_hex(device.dev_id):
                        if value > 10:
                            device.value_changed(1)
                if rxtype == "switch_status" and device.stype == "switch":
-                    if temp.sender == self._combine_hex(device.dev_id):
+                    if temp.sender_int == self._combine_hex(device.dev_id):
                        device.value_changed(value)
                if rxtype == "dimmerstatus" and device.stype == "dimmer":
-                    if temp.sender == self._combine_hex(device.dev_id):
+                    if temp.sender_int == self._combine_hex(device.dev_id):
                        device.value_changed(value)


@@ -186,7 +186,7 @@ class MqttFan(FanEntity):
            yield from mqtt.async_subscribe(
                self.hass, self._topic[CONF_SPEED_STATE_TOPIC], speed_received,
                self._qos)
-        self._speed = SPEED_OFF
+            self._speed = SPEED_OFF

        @callback
        def oscillation_received(topic, payload, qos):
@@ -202,7 +202,7 @@ class MqttFan(FanEntity):
            yield from mqtt.async_subscribe(
                self.hass, self._topic[CONF_OSCILLATION_STATE_TOPIC],
                oscillation_received, self._qos)
-        self._oscillation = False
+            self._oscillation = False

    @property
    def should_poll(self):
@@ -1,60 +1,51 @@
 # Describes the format for available fan services

 set_speed:
-  description: Sets fan speed
-
+  description: Sets fan speed.
  fields:
    entity_id:
      description: Name(s) of the entities to set
      example: 'fan.living_room'
-
    speed:
      description: Speed setting
      example: 'low'

 turn_on:
-  description: Turns fan on
-
+  description: Turns fan on.
  fields:
    entity_id:
      description: Names(s) of the entities to turn on
      example: 'fan.living_room'
-
    speed:
      description: Speed setting
      example: 'high'

 turn_off:
-  description: Turns fan off
-
+  description: Turns fan off.
  fields:
    entity_id:
      description: Names(s) of the entities to turn off
      example: 'fan.living_room'

 oscillate:
-  description: Oscillates the fan
-
+  description: Oscillates the fan.
  fields:
    entity_id:
      description: Name(s) of the entities to oscillate
      example: 'fan.desk_fan'
-
    oscillating:
      description: Flag to turn on/off oscillation
      example: True

 toggle:
-  description: Toggle the fan on/off
-
+  description: Toggle the fan on/off.
  fields:
    entity_id:
      description: Name(s) of the entities to toggle
      exampl: 'fan.living_room'

 set_direction:
-  description: Set the fan rotation direction
-
+  description: Set the fan rotation.
  fields:
    entity_id:
      description: Name(s) of the entities to toggle
@@ -64,8 +55,7 @@ set_direction:
      example: 'left'

 dyson_set_night_mode:
-  description: Set the fan in night mode
-
+  description: Set the fan in night mode.
  fields:
    entity_id:
      description: Name(s) of the entities to enable/disable night mode
@@ -0,0 +1,332 @@
+"""
+Support for Xiaomi Mi Air Purifier 2.
+
+For more details about this platform, please refer to the documentation
+https://home-assistant.io/components/fan.xiaomi_miio/
+"""
+import asyncio
+from functools import partial
+import logging
+import os
+
+import voluptuous as vol
+
+from homeassistant.helpers.entity import ToggleEntity
+from homeassistant.components.fan import (FanEntity, PLATFORM_SCHEMA,
+                                          SUPPORT_SET_SPEED, DOMAIN)
+from homeassistant.config import load_yaml_config_file
+from homeassistant.const import (CONF_NAME, CONF_HOST, CONF_TOKEN,
+                                 ATTR_ENTITY_ID, )
+from homeassistant.exceptions import PlatformNotReady
+import homeassistant.helpers.config_validation as cv
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_NAME = 'Xiaomi Air Purifier'
+PLATFORM = 'xiaomi_miio'
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_HOST): cv.string,
+    vol.Required(CONF_TOKEN): vol.All(cv.string, vol.Length(min=32, max=32)),
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+})
+
+REQUIREMENTS = ['python-miio==0.3.1']
+
+ATTR_TEMPERATURE = 'temperature'
+ATTR_HUMIDITY = 'humidity'
+ATTR_AIR_QUALITY_INDEX = 'aqi'
+ATTR_MODE = 'mode'
+ATTR_FILTER_HOURS_USED = 'filter_hours_used'
+ATTR_FILTER_LIFE = 'filter_life_remaining'
+ATTR_FAVORITE_LEVEL = 'favorite_level'
+ATTR_BUZZER = 'buzzer'
+ATTR_CHILD_LOCK = 'child_lock'
+ATTR_LED = 'led'
+ATTR_LED_BRIGHTNESS = 'led_brightness'
+ATTR_MOTOR_SPEED = 'motor_speed'
+
+ATTR_BRIGHTNESS = 'brightness'
+ATTR_LEVEL = 'level'
+
+SUCCESS = ['ok']
+
+SERVICE_SET_BUZZER_ON = 'xiaomi_miio_set_buzzer_on'
+SERVICE_SET_BUZZER_OFF = 'xiaomi_miio_set_buzzer_off'
+SERVICE_SET_LED_ON = 'xiaomi_miio_set_led_on'
+SERVICE_SET_LED_OFF = 'xiaomi_miio_set_led_off'
+SERVICE_SET_FAVORITE_LEVEL = 'xiaomi_miio_set_favorite_level'
+SERVICE_SET_LED_BRIGHTNESS = 'xiaomi_miio_set_led_brightness'
+
+AIRPURIFIER_SERVICE_SCHEMA = vol.Schema({
+    vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
+})
+
+SERVICE_SCHEMA_LED_BRIGHTNESS = AIRPURIFIER_SERVICE_SCHEMA.extend({
+    vol.Required(ATTR_BRIGHTNESS):
+        vol.All(vol.Coerce(int), vol.Clamp(min=0, max=2))
+})
+
+SERVICE_SCHEMA_FAVORITE_LEVEL = AIRPURIFIER_SERVICE_SCHEMA.extend({
+    vol.Required(ATTR_LEVEL):
+        vol.All(vol.Coerce(int), vol.Clamp(min=0, max=16))
+})
+
+SERVICE_TO_METHOD = {
+    SERVICE_SET_BUZZER_ON: {'method': 'async_set_buzzer_on'},
+    SERVICE_SET_BUZZER_OFF: {'method': 'async_set_buzzer_off'},
+    SERVICE_SET_LED_ON: {'method': 'async_set_led_on'},
+    SERVICE_SET_LED_OFF: {'method': 'async_set_led_off'},
+    SERVICE_SET_FAVORITE_LEVEL: {
+        'method': 'async_set_favorite_level',
+        'schema': SERVICE_SCHEMA_FAVORITE_LEVEL},
+    SERVICE_SET_LED_BRIGHTNESS: {
+        'method': 'async_set_led_brightness',
+        'schema': SERVICE_SCHEMA_LED_BRIGHTNESS},
+}
+
+
+# pylint: disable=unused-argument
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+    """Set up the air purifier from config."""
+    from miio import AirPurifier, DeviceException
+    if PLATFORM not in hass.data:
+        hass.data[PLATFORM] = {}
+
+    host = config.get(CONF_HOST)
+    name = config.get(CONF_NAME)
+    token = config.get(CONF_TOKEN)
+
+    _LOGGER.info("Initializing with host %s (token %s...)", host, token[:5])
+
+    try:
+        air_purifier = AirPurifier(host, token)
+
+        xiaomi_air_purifier = XiaomiAirPurifier(name, air_purifier)
+        hass.data[PLATFORM][host] = xiaomi_air_purifier
+    except DeviceException:
+        raise PlatformNotReady
+
+    async_add_devices([xiaomi_air_purifier], update_before_add=True)
+
+    @asyncio.coroutine
+    def async_service_handler(service):
+        """Map services to methods on XiaomiAirPurifier."""
+        method = SERVICE_TO_METHOD.get(service.service)
+        params = {key: value for key, value in service.data.items()
+                  if key != ATTR_ENTITY_ID}
+        entity_ids = service.data.get(ATTR_ENTITY_ID)
+        if entity_ids:
+            target_air_purifiers = [air for air in hass.data[PLATFORM].values()
+                                    if air.entity_id in entity_ids]
+        else:
+            target_air_purifiers = hass.data[PLATFORM].values()
+
+        update_tasks = []
+        for air_purifier in target_air_purifiers:
+            yield from getattr(air_purifier, method['method'])(**params)
+            update_tasks.append(air_purifier.async_update_ha_state(True))
+
+        if update_tasks:
+            yield from asyncio.wait(update_tasks, loop=hass.loop)
+
+    descriptions = yield from hass.async_add_job(
+        load_yaml_config_file, os.path.join(
+            os.path.dirname(__file__), 'xiaomi_miio_services.yaml'))
+
+    for air_purifier_service in SERVICE_TO_METHOD:
+        schema = SERVICE_TO_METHOD[air_purifier_service].get(
+            'schema', AIRPURIFIER_SERVICE_SCHEMA)
+        hass.services.async_register(
+            DOMAIN, air_purifier_service, async_service_handler,
+            description=descriptions.get(air_purifier_service), schema=schema)
+
+
+class XiaomiAirPurifier(FanEntity):
+    """Representation of a Xiaomi Air Purifier."""
+
+    def __init__(self, name, air_purifier):
+        """Initialize the air purifier."""
+        self._name = name
+
+        self._air_purifier = air_purifier
+        self._state = None
+        self._state_attrs = {
+            ATTR_AIR_QUALITY_INDEX: None,
+            ATTR_TEMPERATURE: None,
+            ATTR_HUMIDITY: None,
+            ATTR_MODE: None,
+            ATTR_FILTER_HOURS_USED: None,
+            ATTR_FILTER_LIFE: None,
+            ATTR_FAVORITE_LEVEL: None,
+            ATTR_BUZZER: None,
+            ATTR_CHILD_LOCK: None,
+            ATTR_LED: None,
+            ATTR_LED_BRIGHTNESS: None,
+            ATTR_MOTOR_SPEED: None
+        }
+
+    @property
+    def supported_features(self):
+        """Flag supported features."""
+        return SUPPORT_SET_SPEED
+
+    @property
+    def should_poll(self):
+        """Poll the fan."""
+        return True
+
+    @property
+    def name(self):
+        """Return the name of the device if any."""
+        return self._name
+
+    @property
+    def available(self):
+        """Return true when state is known."""
+        return self._state is not None
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes of the device."""
+        return self._state_attrs
+
+    @property
+    def is_on(self):
+        """Return true if fan is on."""
+        return self._state
+
+    @asyncio.coroutine
+    def _try_command(self, mask_error, func, *args, **kwargs):
+        """Call a air purifier command handling error messages."""
+        from miio import DeviceException
+        try:
+            result = yield from self.hass.async_add_job(
+                partial(func, *args, **kwargs))
+
+            _LOGGER.debug("Response received from air purifier: %s", result)
+
+            return result == SUCCESS
+        except DeviceException as exc:
+            _LOGGER.error(mask_error, exc)
+            return False
+
+    @asyncio.coroutine
+    def async_turn_on(self: ToggleEntity, speed: str=None, **kwargs) -> None:
+        """Turn the fan on."""
+        if speed:
+            # If operation mode was set the device must not be turned on.
+            yield from self.async_set_speed(speed)
+            return
+
+        yield from self._try_command(
+            "Turning the air purifier on failed.", self._air_purifier.on)
+
+    @asyncio.coroutine
+    def async_turn_off(self: ToggleEntity, **kwargs) -> None:
+        """Turn the fan off."""
+        yield from self._try_command(
+            "Turning the air purifier off failed.", self._air_purifier.off)
+
+    @asyncio.coroutine
+    def async_update(self):
+        """Fetch state from the device."""
+        from miio import DeviceException
+
+        try:
+            state = yield from self.hass.async_add_job(
+                self._air_purifier.status)
+            _LOGGER.debug("Got new state: %s", state)
+
+            self._state = state.is_on
+            self._state_attrs = {
+                ATTR_TEMPERATURE: state.temperature,
+                ATTR_HUMIDITY: state.humidity,
+                ATTR_AIR_QUALITY_INDEX: state.aqi,
+                ATTR_MODE: state.mode.value,
+                ATTR_FILTER_HOURS_USED: state.filter_hours_used,
+                ATTR_FILTER_LIFE: state.filter_life_remaining,
+                ATTR_FAVORITE_LEVEL: state.favorite_level,
+                ATTR_BUZZER: state.buzzer,
+                ATTR_CHILD_LOCK: state.child_lock,
+                ATTR_LED: state.led,
+                ATTR_MOTOR_SPEED: state.motor_speed
+            }
+
+            if state.led_brightness:
+                self._state_attrs[
+                    ATTR_LED_BRIGHTNESS] = state.led_brightness.value
+
+        except DeviceException as ex:
+            _LOGGER.error("Got exception while fetching the state: %s", ex)
+
+    @property
+    def speed_list(self: ToggleEntity) -> list:
+        """Get the list of available speeds."""
+        from miio.airpurifier import OperationMode
+        return [mode.name for mode in OperationMode]
+
+    @property
+    def speed(self):
+        """Return the current speed."""
+        if self._state:
+            from miio.airpurifier import OperationMode
+
+            return OperationMode(self._state_attrs[ATTR_MODE]).name
+
+        return None
+
+    @asyncio.coroutine
+    def async_set_speed(self: ToggleEntity, speed: str) -> None:
+        """Set the speed of the fan."""
+        _LOGGER.debug("Setting the operation mode to: " + speed)
+        from miio.airpurifier import OperationMode
+
+        yield from self._try_command(
+            "Setting operation mode of the air purifier failed.",
+            self._air_purifier.set_mode, OperationMode[speed])
+
+    @asyncio.coroutine
+    def async_set_buzzer_on(self):
+        """Turn the buzzer on."""
+        yield from self._try_command(
+            "Turning the buzzer of air purifier on failed.",
+            self._air_purifier.set_buzzer, True)
+
+    @asyncio.coroutine
+    def async_set_buzzer_off(self):
+        """Turn the buzzer on."""
+        yield from self._try_command(
+            "Turning the buzzer of air purifier off failed.",
+            self._air_purifier.set_buzzer, False)
+
+    @asyncio.coroutine
+    def async_set_led_on(self):
+        """Turn the led on."""
+        yield from self._try_command(
+            "Turning the led of air purifier off failed.",
+            self._air_purifier.set_led, True)
+
+    @asyncio.coroutine
+    def async_set_led_off(self):
+        """Turn the led off."""
+        yield from self._try_command(
+            "Turning the led of air purifier off failed.",
+            self._air_purifier.set_led, False)
+
+    @asyncio.coroutine
+    def async_set_led_brightness(self, brightness: int=2):
+        """Set the led brightness."""
+        from miio.airpurifier import LedBrightness
+
+        yield from self._try_command(
+            "Setting the led brightness of the air purifier failed.",
+            self._air_purifier.set_led_brightness, LedBrightness(brightness))
+
+    @asyncio.coroutine
+    def async_set_favorite_level(self, level: int=1):
+        """Set the favorite level."""
+        yield from self._try_command(
+            "Setting the favorite level of the air purifier failed.",
+            self._air_purifier.set_favorite_level, level)
@@ -0,0 +1,56 @@
+
+xiaomi_miio_set_buzzer_on:
+  description: Turn the buzzer on.
+
+  fields:
+    entity_id:
+      description: Name of the air purifier entity.
+      example: 'fan.xiaomi_air_purifier'
+
+xiaomi_miio_set_buzzer_off:
+  description: Turn the buzzer off.
+
+  fields:
+    entity_id:
+      description: Name of the air purifier entity.
+      example: 'fan.xiaomi_air_purifier'
+
+xiaomi_miio_set_led_on:
+  description: Turn the led on.
+
+  fields:
+    entity_id:
+      description: Name of the air purifier entity.
+      example: 'fan.xiaomi_air_purifier'
+
+xiaomi_miio_set_led_off:
+  description: Turn the led off.
+
+  fields:
+    entity_id:
+      description: Name of the air purifier entity.
+      example: 'fan.xiaomi_air_purifier'
+
+xiaomi_miio_set_favorite_level:
+  description: Set the favorite level.
+
+  fields:
+    entity_id:
+      description: Name of the air purifier entity.
+      example: 'fan.xiaomi_air_purifier'
+
+    level:
+      description: Level, between 0 and 16.
+      example: '1'
+
+xiaomi_miio_set_led_brightness:
+  description: Set the led brightness.
+
+  fields:
+    entity_id:
+      description: Name of the air purifier entity.
+      example: 'fan.xiaomi_air_purifier'
+
+    brightness:
+      description: Brightness (0 = Bright, 1 = Dim, 2 = Off)
+      example: '1'
@@ -1,35 +1,44 @@
-"""Handle the frontend for Home Assistant."""
+"""
+Handle the frontend for Home Assistant.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/frontend/
+"""
 import asyncio
 import hashlib
 import json
 import logging
 import os
+from urllib.parse import urlparse

 from aiohttp import web
 import voluptuous as vol
-import homeassistant.helpers.config_validation as cv
+import jinja2

+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.http import HomeAssistantView
+from homeassistant.components.http.auth import is_trusted_ip
 from homeassistant.config import find_config_file, load_yaml_config_file
 from homeassistant.const import CONF_NAME, EVENT_THEMES_UPDATED
 from homeassistant.core import callback
 from homeassistant.loader import bind_hass
-from homeassistant.components import api
-from homeassistant.components.http import HomeAssistantView
-from homeassistant.components.http.auth import is_trusted_ip
-from homeassistant.components.http.const import KEY_DEVELOPMENT
-from .version import FINGERPRINTS
+
+REQUIREMENTS = ['home-assistant-frontend==20171118.0']

 DOMAIN = 'frontend'
-DEPENDENCIES = ['api', 'websocket_api']
+DEPENDENCIES = ['api', 'websocket_api', 'http', 'system_log']

-URL_PANEL_COMPONENT = '/frontend/panels/{}.html'
 URL_PANEL_COMPONENT_FP = '/frontend/panels/{}-{}.html'

-STATIC_PATH = os.path.join(os.path.dirname(__file__), 'www_static/')
+CONF_THEMES = 'themes'
+CONF_EXTRA_HTML_URL = 'extra_html_url'
+CONF_FRONTEND_REPO = 'development_repo'
+CONF_JS_VERSION = 'javascript_version'
+JS_DEFAULT_OPTION = 'es5'
+JS_OPTIONS = ['es5', 'latest', 'auto']

-ATTR_THEMES = 'themes'
-ATTR_EXTRA_HTML_URL = 'extra_html_url'
 DEFAULT_THEME_COLOR = '#03A9F4'
+
 MANIFEST_JSON = {
    'background_color': '#FFFFFF',
    'description': 'Open-source home automation platform running on Python 3.',
@@ -50,26 +59,28 @@ for size in (192, 384, 512, 1024):
        'type': 'image/png'
    })

+DATA_FINALIZE_PANEL = 'frontend_finalize_panel'
 DATA_PANELS = 'frontend_panels'
+DATA_JS_VERSION = 'frontend_js_version'
 DATA_EXTRA_HTML_URL = 'frontend_extra_html_url'
-DATA_INDEX_VIEW = 'frontend_index_view'
 DATA_THEMES = 'frontend_themes'
 DATA_DEFAULT_THEME = 'frontend_default_theme'
 DEFAULT_THEME = 'default'

 PRIMARY_COLOR = 'primary-color'

-# To keep track we don't register a component twice (gives a warning)
-_REGISTERED_COMPONENTS = set()
 _LOGGER = logging.getLogger(__name__)

 CONFIG_SCHEMA = vol.Schema({
    DOMAIN: vol.Schema({
-        vol.Optional(ATTR_THEMES): vol.Schema({
+        vol.Optional(CONF_FRONTEND_REPO): cv.isdir,
+        vol.Optional(CONF_THEMES): vol.Schema({
            cv.string: {cv.string: cv.string}
        }),
-        vol.Optional(ATTR_EXTRA_HTML_URL):
+        vol.Optional(CONF_EXTRA_HTML_URL):
            vol.All(cv.ensure_list, [cv.string]),
+        vol.Optional(CONF_JS_VERSION, default=JS_DEFAULT_OPTION):
+            vol.In(JS_OPTIONS)
    }),
 }, extra=vol.ALLOW_EXTRA)

@@ -80,101 +91,184 @@ SERVICE_SET_THEME_SCHEMA = vol.Schema({
 })


+class AbstractPanel:
+    """Abstract class for panels."""
+
+    # Name of the webcomponent
+    component_name = None
+
+    # Icon to show in the sidebar (optional)
+    sidebar_icon = None
+
+    # Title to show in the sidebar (optional)
+    sidebar_title = None
+
+    # Url to the webcomponent (depending on JS version)
+    webcomponent_url_es5 = None
+    webcomponent_url_latest = None
+
+    # Url to show the panel in the frontend
+    frontend_url_path = None
+
+    # Config to pass to the webcomponent
+    config = None
+
+    @asyncio.coroutine
+    def async_register(self, hass):
+        """Register panel with HASS."""
+        panels = hass.data.get(DATA_PANELS)
+        if panels is None:
+            panels = hass.data[DATA_PANELS] = {}
+
+        if self.frontend_url_path in panels:
+            _LOGGER.warning("Overwriting component %s", self.frontend_url_path)
+
+        if DATA_FINALIZE_PANEL in hass.data:
+            yield from hass.data[DATA_FINALIZE_PANEL](self)
+
+        panels[self.frontend_url_path] = self
+
+    @callback
+    def async_register_index_routes(self, router, index_view):
+        """Register routes for panel to be served by index view."""
+        router.add_route(
+            'get', '/{}'.format(self.frontend_url_path), index_view.get)
+        router.add_route(
+            'get', '/{}/{{extra:.+}}'.format(self.frontend_url_path),
+            index_view.get)
+
+    def to_response(self, hass, request):
+        """Panel as dictionary."""
+        result = {
+            'component_name': self.component_name,
+            'icon': self.sidebar_icon,
+            'title': self.sidebar_title,
+            'url_path': self.frontend_url_path,
+            'config': self.config,
+        }
+        if _is_latest(hass.data[DATA_JS_VERSION], request):
+            result['url'] = self.webcomponent_url_latest
+        else:
+            result['url'] = self.webcomponent_url_es5
+        return result
+
+
+class BuiltInPanel(AbstractPanel):
+    """Panel that is part of hass_frontend."""
+
+    def __init__(self, component_name, sidebar_title, sidebar_icon,
+                 frontend_url_path, config):
+        """Initialize a built-in panel."""
+        self.component_name = component_name
+        self.sidebar_title = sidebar_title
+        self.sidebar_icon = sidebar_icon
+        self.frontend_url_path = frontend_url_path or component_name
+        self.config = config
+
+    @asyncio.coroutine
+    def async_finalize(self, hass, frontend_repository_path):
+        """Finalize this panel for usage.
+
+        If frontend_repository_path is set, will be prepended to path of
+        built-in components.
+        """
+        if frontend_repository_path is None:
+            import hass_frontend
+            import hass_frontend_es5
+
+            self.webcomponent_url_latest = \
+                '/frontend_latest/panels/ha-panel-{}-{}.html'.format(
+                    self.component_name,
+                    hass_frontend.FINGERPRINTS[self.component_name])
+            self.webcomponent_url_es5 = \
+                '/frontend_es5/panels/ha-panel-{}-{}.html'.format(
+                    self.component_name,
+                    hass_frontend_es5.FINGERPRINTS[self.component_name])
+        else:
+            # Dev mode
+            self.webcomponent_url_es5 = self.webcomponent_url_latest = \
+                '/home-assistant-polymer/panels/{}/ha-panel-{}.html'.format(
+                    self.component_name, self.component_name)
+
+
+class ExternalPanel(AbstractPanel):
+    """Panel that is added by a custom component."""
+
+    REGISTERED_COMPONENTS = set()
+
+    def __init__(self, component_name, path, md5, sidebar_title, sidebar_icon,
+                 frontend_url_path, config):
+        """Initialize an external panel."""
+        self.component_name = component_name
+        self.path = path
+        self.md5 = md5
+        self.sidebar_title = sidebar_title
+        self.sidebar_icon = sidebar_icon
+        self.frontend_url_path = frontend_url_path or component_name
+        self.config = config
+
+    @asyncio.coroutine
+    def async_finalize(self, hass, frontend_repository_path):
+        """Finalize this panel for usage.
+
+        frontend_repository_path is set, will be prepended to path of built-in
+        components.
+        """
+        try:
+            if self.md5 is None:
+                self.md5 = yield from hass.async_add_job(
+                    _fingerprint, self.path)
+        except OSError:
+            _LOGGER.error('Cannot find or access %s at %s',
+                          self.component_name, self.path)
+            hass.data[DATA_PANELS].pop(self.frontend_url_path)
+            return
+
+        self.webcomponent_url_es5 = self.webcomponent_url_latest = \
+            URL_PANEL_COMPONENT_FP.format(self.component_name, self.md5)
+
+        if self.component_name not in self.REGISTERED_COMPONENTS:
+            hass.http.register_static_path(
+                self.webcomponent_url_latest, self.path,
+                # if path is None, we're in prod mode, so cache static assets
+                frontend_repository_path is None)
+            self.REGISTERED_COMPONENTS.add(self.component_name)
+
+
@bind_hass
-def register_built_in_panel(hass, component_name, sidebar_title=None,
-                            sidebar_icon=None, url_path=None, config=None):
+@asyncio.coroutine
+def async_register_built_in_panel(hass, component_name, sidebar_title=None,
+                                  sidebar_icon=None, frontend_url_path=None,
+                                  config=None):
    """Register a built-in panel."""
-    nondev_path = 'panels/ha-panel-{}.html'.format(component_name)
-
-    if hass.http.development:
-        url = ('/static/home-assistant-polymer/panels/'
-               '{0}/ha-panel-{0}.html'.format(component_name))
-        path = os.path.join(
-            STATIC_PATH, 'home-assistant-polymer/panels/',
-            '{0}/ha-panel-{0}.html'.format(component_name))
-    else:
-        url = None  # use default url generate mechanism
-        path = os.path.join(STATIC_PATH, nondev_path)
-
-    # Fingerprint doesn't exist when adding new built-in panel
-    register_panel(hass, component_name, path,
-                   FINGERPRINTS.get(nondev_path, 'dev'), sidebar_title,
-                   sidebar_icon, url_path, url, config)
+    panel = BuiltInPanel(component_name, sidebar_title, sidebar_icon,
+                         frontend_url_path, config)
+    yield from panel.async_register(hass)


@bind_hass
-def register_panel(hass, component_name, path, md5=None, sidebar_title=None,
-                   sidebar_icon=None, url_path=None, url=None, config=None):
+@asyncio.coroutine
+def async_register_panel(hass, component_name, path, md5=None,
+                         sidebar_title=None, sidebar_icon=None,
+                         frontend_url_path=None, config=None):
    """Register a panel for the frontend.

    component_name: name of the web component
    path: path to the HTML of the web component
          (required unless url is provided)
-    md5: the md5 hash of the web component (for versioning, optional)
+    md5: the md5 hash of the web component (for versioning in url, optional)
    sidebar_title: title to show in the sidebar (optional)
    sidebar_icon: icon to show next to title in sidebar (optional)
    url_path: name to use in the url (defaults to component_name)
-    url: for the web component (optional)
    config: config to be passed into the web component
    """
-    panels = hass.data.get(DATA_PANELS)
-    if panels is None:
-        panels = hass.data[DATA_PANELS] = {}
-
-    if url_path is None:
-        url_path = component_name
-
-    if url_path in panels:
-        _LOGGER.warning("Overwriting component %s", url_path)
-
-    if url is None:
-        if not os.path.isfile(path):
-            _LOGGER.error(
-                "Panel %s component does not exist: %s", component_name, path)
-            return
-
-        if md5 is None:
-            with open(path) as fil:
-                md5 = hashlib.md5(fil.read().encode('utf-8')).hexdigest()
-
-    data = {
-        'url_path': url_path,
-        'component_name': component_name,
-    }
-
-    if sidebar_title:
-        data['title'] = sidebar_title
-    if sidebar_icon:
-        data['icon'] = sidebar_icon
-    if config is not None:
-        data['config'] = config
-
-    if url is not None:
-        data['url'] = url
-    else:
-        url = URL_PANEL_COMPONENT.format(component_name)
-
-        if url not in _REGISTERED_COMPONENTS:
-            hass.http.register_static_path(url, path)
-            _REGISTERED_COMPONENTS.add(url)
-
-        fprinted_url = URL_PANEL_COMPONENT_FP.format(component_name, md5)
-        data['url'] = fprinted_url
-
-    panels[url_path] = data
-
-    # Register index view for this route if IndexView already loaded
-    # Otherwise it will be done during setup.
-    index_view = hass.data.get(DATA_INDEX_VIEW)
-
-    if index_view:
-        hass.http.app.router.add_route(
-            'get', '/{}'.format(url_path), index_view.get)
-        hass.http.app.router.add_route(
-            'get', '/{}/{{extra:.+}}'.format(url_path), index_view.get)
+    panel = ExternalPanel(component_name, path, md5, sidebar_title,
+                          sidebar_icon, frontend_url_path, config)
+    yield from panel.async_register(hass)


@bind_hass
+@callback
 def add_extra_html_url(hass, url):
    """Register extra html url to load."""
    url_set = hass.data.get(DATA_EXTRA_HTML_URL)
@@ -188,57 +282,93 @@ def add_manifest_json_key(key, val):
    MANIFEST_JSON[key] = val


-def setup(hass, config):
+@asyncio.coroutine
+def async_setup(hass, config):
    """Set up the serving of the frontend."""
-    hass.http.register_view(BootstrapView)
    hass.http.register_view(ManifestJSONView)

-    if hass.http.development:
-        sw_path = "home-assistant-polymer/build/service_worker.js"
-    else:
-        sw_path = "service_worker.js"
+    conf = config.get(DOMAIN, {})

-    hass.http.register_static_path("/service_worker.js",
-                                   os.path.join(STATIC_PATH, sw_path), False)
-    hass.http.register_static_path("/robots.txt",
-                                   os.path.join(STATIC_PATH, "robots.txt"))
-    hass.http.register_static_path("/static", STATIC_PATH)
+    repo_path = conf.get(CONF_FRONTEND_REPO)
+    is_dev = repo_path is not None
+    hass.data[DATA_JS_VERSION] = js_version = conf.get(CONF_JS_VERSION)
+
+    if is_dev:
+        hass.http.register_static_path(
+            "/home-assistant-polymer", repo_path, False)
+        hass.http.register_static_path(
+            "/static/translations",
+            os.path.join(repo_path, "build-translations"), False)
+        sw_path_es5 = os.path.join(repo_path, "build-es5/service_worker.js")
+        sw_path_latest = os.path.join(repo_path, "build/service_worker.js")
+        static_path = os.path.join(repo_path, 'hass_frontend')
+        frontend_es5_path = os.path.join(repo_path, 'build-es5')
+        frontend_latest_path = os.path.join(repo_path, 'build')
+    else:
+        import hass_frontend
+        import hass_frontend_es5
+        sw_path_es5 = os.path.join(hass_frontend_es5.where(),
+                                   "service_worker.js")
+        sw_path_latest = os.path.join(hass_frontend.where(),
+                                      "service_worker.js")
+        # /static points to dir with files that are JS-type agnostic.
+        # ES5 files are served from /frontend_es5.
+        # ES6 files are served from /frontend_latest.
+        static_path = hass_frontend.where()
+        frontend_es5_path = hass_frontend_es5.where()
+        frontend_latest_path = static_path
+
+    hass.http.register_static_path(
+        "/service_worker_es5.js", sw_path_es5, False)
+    hass.http.register_static_path(
+        "/service_worker.js", sw_path_latest, False)
+    hass.http.register_static_path(
+        "/robots.txt", os.path.join(static_path, "robots.txt"), not is_dev)
+    hass.http.register_static_path("/static", static_path, not is_dev)
+    hass.http.register_static_path(
+        "/frontend_latest", frontend_latest_path, not is_dev)
+    hass.http.register_static_path(
+        "/frontend_es5", frontend_es5_path, not is_dev)

    local = hass.config.path('www')
    if os.path.isdir(local):
-        hass.http.register_static_path("/local", local)
+        hass.http.register_static_path("/local", local, not is_dev)

-    index_view = hass.data[DATA_INDEX_VIEW] = IndexView()
+    index_view = IndexView(repo_path, js_version)
    hass.http.register_view(index_view)

-    # Components have registered panels before frontend got setup.
-    # Now register their urls.
-    if DATA_PANELS in hass.data:
-        for url_path in hass.data[DATA_PANELS]:
-            hass.http.app.router.add_route(
-                'get', '/{}'.format(url_path), index_view.get)
-            hass.http.app.router.add_route(
-                'get', '/{}/{{extra:.+}}'.format(url_path), index_view.get)
-    else:
-        hass.data[DATA_PANELS] = {}
+    @asyncio.coroutine
+    def finalize_panel(panel):
+        """Finalize setup of a panel."""
+        yield from panel.async_finalize(hass, repo_path)
+        panel.async_register_index_routes(hass.http.app.router, index_view)
+
+    yield from asyncio.wait([
+        async_register_built_in_panel(hass, panel)
+        for panel in ('dev-event', 'dev-info', 'dev-service', 'dev-state',
+                      'dev-template', 'dev-mqtt', 'kiosk')], loop=hass.loop)
+
+    hass.data[DATA_FINALIZE_PANEL] = finalize_panel
+
+    # Finalize registration of panels that registered before frontend was setup
+    # This includes the built-in panels from line above.
+    yield from asyncio.wait(
+        [finalize_panel(panel) for panel in hass.data[DATA_PANELS].values()],
+        loop=hass.loop)

    if DATA_EXTRA_HTML_URL not in hass.data:
        hass.data[DATA_EXTRA_HTML_URL] = set()

-    for panel in ('dev-event', 'dev-info', 'dev-service', 'dev-state',
-                  'dev-template', 'dev-mqtt', 'kiosk'):
-        register_built_in_panel(hass, panel)
-
-    themes = config.get(DOMAIN, {}).get(ATTR_THEMES)
-    setup_themes(hass, themes)
-
-    for url in config.get(DOMAIN, {}).get(ATTR_EXTRA_HTML_URL, []):
+    for url in conf.get(CONF_EXTRA_HTML_URL, []):
        add_extra_html_url(hass, url)

+    yield from async_setup_themes(hass, conf.get(CONF_THEMES))
+
    return True


-def setup_themes(hass, themes):
+@asyncio.coroutine
+def async_setup_themes(hass, themes):
    """Set up themes data and services."""
    hass.http.register_view(ThemesView)
    hass.data[DATA_DEFAULT_THEME] = DEFAULT_THEME
@@ -278,40 +408,22 @@ def setup_themes(hass, themes):
    def reload_themes(_):
        """Reload themes."""
        path = find_config_file(hass.config.config_dir)
-        new_themes = load_yaml_config_file(path)[DOMAIN].get(ATTR_THEMES, {})
+        new_themes = load_yaml_config_file(path)[DOMAIN].get(CONF_THEMES, {})
        hass.data[DATA_THEMES] = new_themes
        if hass.data[DATA_DEFAULT_THEME] not in new_themes:
            hass.data[DATA_DEFAULT_THEME] = DEFAULT_THEME
        update_theme_and_fire_event()

-    descriptions = load_yaml_config_file(
+    descriptions = yield from hass.async_add_job(
+        load_yaml_config_file,
        os.path.join(os.path.dirname(__file__), 'services.yaml'))
-    hass.services.register(DOMAIN, SERVICE_SET_THEME,
-                           set_theme,
-                           descriptions[SERVICE_SET_THEME],
-                           SERVICE_SET_THEME_SCHEMA)
-    hass.services.register(DOMAIN, SERVICE_RELOAD_THEMES, reload_themes,
-                           descriptions[SERVICE_RELOAD_THEMES])

-
-class BootstrapView(HomeAssistantView):
-    """View to bootstrap frontend with all needed data."""
-
-    url = '/api/bootstrap'
-    name = 'api:bootstrap'
-
-    @callback
-    def get(self, request):
-        """Return all data needed to bootstrap Home Assistant."""
-        hass = request.app['hass']
-
-        return self.json({
-            'config': hass.config.as_dict(),
-            'states': hass.states.async_all(),
-            'events': api.async_events_json(hass),
-            'services': api.async_services_json(hass),
-            'panels': hass.data[DATA_PANELS],
-        })
+    hass.services.async_register(DOMAIN, SERVICE_SET_THEME,
+                                 set_theme,
+                                 descriptions[SERVICE_SET_THEME],
+                                 SERVICE_SET_THEME_SCHEMA)
+    hass.services.async_register(DOMAIN, SERVICE_RELOAD_THEMES, reload_themes,
+                                 descriptions[SERVICE_RELOAD_THEMES])


 class IndexView(HomeAssistantView):
@@ -322,34 +434,40 @@ class IndexView(HomeAssistantView):
    requires_auth = False
    extra_urls = ['/states', '/states/{extra}']

-    def __init__(self):
+    def __init__(self, repo_path, js_option):
        """Initialize the frontend view."""
-        from jinja2 import FileSystemLoader, Environment
+        self.repo_path = repo_path
+        self.js_option = js_option
+        self._template_cache = {}

-        self.templates = Environment(
-            autoescape=True,
-            loader=FileSystemLoader(
-                os.path.join(os.path.dirname(__file__), 'templates/')
-            )
-        )
+    def get_template(self, latest):
+        """Get template."""
+        if self.repo_path is not None:
+            root = self.repo_path
+        elif latest:
+            import hass_frontend
+            root = hass_frontend.where()
+        else:
+            import hass_frontend_es5
+            root = hass_frontend_es5.where()
+
+        tpl = self._template_cache.get(root)
+
+        if tpl is None:
+            with open(os.path.join(root, 'index.html')) as file:
+                tpl = jinja2.Template(file.read())
+
+            # Cache template if not running from repository
+            if self.repo_path is None:
+                self._template_cache[root] = tpl
+
+        return tpl

    @asyncio.coroutine
    def get(self, request, extra=None):
        """Serve the index view."""
        hass = request.app['hass']
-
-        if request.app[KEY_DEVELOPMENT]:
-            core_url = '/static/home-assistant-polymer/build/core.js'
-            compatibility_url = \
-                '/static/home-assistant-polymer/build/compatibility.js'
-            ui_url = '/static/home-assistant-polymer/src/home-assistant.html'
-        else:
-            core_url = '/static/core-{}.js'.format(
-                FINGERPRINTS['core.js'])
-            compatibility_url = '/static/compatibility-{}.js'.format(
-                FINGERPRINTS['compatibility.js'])
-            ui_url = '/static/frontend-{}.html'.format(
-                FINGERPRINTS['frontend.html'])
+        latest = _is_latest(self.js_option, request)

        if request.path == '/':
            panel = 'states'
@@ -358,32 +476,27 @@ class IndexView(HomeAssistantView):

        if panel == 'states':
            panel_url = ''
+        elif latest:
+            panel_url = hass.data[DATA_PANELS][panel].webcomponent_url_latest
        else:
-            panel_url = hass.data[DATA_PANELS][panel]['url']
+            panel_url = hass.data[DATA_PANELS][panel].webcomponent_url_es5

        no_auth = 'true'
-        if hass.config.api.api_password:
-            # require password if set
+        if hass.config.api.api_password and not is_trusted_ip(request):
+            # do not try to auto connect on load
            no_auth = 'false'
-            if is_trusted_ip(request):
-                # bypass for trusted networks
-                no_auth = 'true'

-        icons_url = '/static/mdi-{}.html'.format(FINGERPRINTS['mdi.html'])
-        template = yield from hass.async_add_job(
-            self.templates.get_template, 'index.html')
+        template = yield from hass.async_add_job(self.get_template, latest)

-        # pylint is wrong
-        # pylint: disable=no-member
-        # This is a jinja2 template, not a HA template so we call 'render'.
        resp = template.render(
-            core_url=core_url, ui_url=ui_url,
-            compatibility_url=compatibility_url, no_auth=no_auth,
-            icons_url=icons_url, icons=FINGERPRINTS['mdi.html'],
-            panel_url=panel_url, panels=hass.data[DATA_PANELS],
-            dev_mode=request.app[KEY_DEVELOPMENT],
+            no_auth=no_auth,
+            panel_url=panel_url,
+            panels=hass.data[DATA_PANELS],
+            dev_mode=self.repo_path is not None,
            theme_color=MANIFEST_JSON['theme_color'],
-            extra_urls=hass.data[DATA_EXTRA_HTML_URL])
+            extra_urls=hass.data[DATA_EXTRA_HTML_URL],
+            latest=latest,
+        )

        return web.Response(text=resp, content_type='text/html')

@@ -398,8 +511,8 @@ class ManifestJSONView(HomeAssistantView):
    @asyncio.coroutine
    def get(self, request):    # pylint: disable=no-self-use
        """Return the manifest.json."""
-        msg = json.dumps(MANIFEST_JSON, sort_keys=True).encode('UTF-8')
-        return web.Response(body=msg, content_type="application/manifest+json")
+        msg = json.dumps(MANIFEST_JSON, sort_keys=True)
+        return web.Response(text=msg, content_type="application/manifest+json")


 class ThemesView(HomeAssistantView):
@@ -418,3 +531,26 @@ class ThemesView(HomeAssistantView):
            'themes': hass.data[DATA_THEMES],
            'default_theme': hass.data[DATA_DEFAULT_THEME],
        })
+
+
+def _fingerprint(path):
+    """Fingerprint a file."""
+    with open(path) as fil:
+        return hashlib.md5(fil.read().encode('utf-8')).hexdigest()
+
+
+def _is_latest(js_option, request):
+    """
+    Return whether we should serve latest untranspiled code.
+
+    Set according to user's preference and URL override.
+    """
+    if request is None:
+        return js_option == 'latest'
+    latest_in_query = 'latest' in request.query or (
+        request.headers.get('Referer') and
+        'latest' in urlparse(request.headers['Referer']).query)
+    es5_in_query = 'es5' in request.query or (
+        request.headers.get('Referer') and
+        'es5' in urlparse(request.headers['Referer']).query)
+    return latest_in_query or (not es5_in_query and js_option == 'latest')
@@ -8,4 +8,4 @@ set_theme:
      example: 'light'

 reload_themes:
-  description: Reload themes from yaml config.
+  description: Reload themes from yaml configuration.
@@ -1,116 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8">
-    <title>Home Assistant</title>
-
-    <link rel='manifest' href='/manifest.json'>
-    <link rel='icon' href='/static/icons/favicon.ico'>
-    <link rel='apple-touch-icon' sizes='180x180'
-          href='/static/icons/favicon-apple-180x180.png'>
-    <link rel="mask-icon" href="/static/icons/home-assistant-icon.svg" color="#3fbbf4">
-    <link rel='preload' href='{{ core_url }}' as='script'/>
-    {% for panel in panels.values() -%}
-      <link rel='prefetch' href='{{ panel.url }}'>
-    {% endfor -%}
-    <meta name='apple-mobile-web-app-capable' content='yes'>
-    <meta name="msapplication-square70x70logo" content="/static/icons/tile-win-70x70.png"/>
-    <meta name="msapplication-square150x150logo" content="/static/icons/tile-win-150x150.png"/>
-    <meta name="msapplication-wide310x150logo" content="/static/icons/tile-win-310x150.png"/>
-    <meta name="msapplication-square310x310logo" content="/static/icons/tile-win-310x310.png"/>
-    <meta name="msapplication-TileColor" content="#3fbbf4ff"/>
-    <meta name='mobile-web-app-capable' content='yes'>
-    <meta name='viewport' content='width=device-width, user-scalable=no'>
-    <meta name='theme-color' content='{{ theme_color }}'>
-    <style>
-      body {
-        font-family: 'Roboto', 'Noto', sans-serif;
-        font-weight: 400;
-        -webkit-font-smoothing: antialiased;
-        text-rendering: optimizeLegibility;
-        margin: 0;
-        padding: 0;
-      }
-
-      #ha-init-skeleton::before {
-        display: block;
-        content: "";
-        height: 48px;
-        background-color: #03A9F4;
-      }
-
-      #ha-init-skeleton .message {
-        transition: font-size 2s;
-        font-size: 0;
-        padding: 24px;
-      }
-
-      #ha-init-skeleton.error .message {
-        font-size: 16px;
-      }
-
-      #ha-init-skeleton a {
-        color: #03A9F4;
-        text-decoration: none;
-        font-weight: bold;
-      }
-    </style>
-    <script>
-      function initError() {
-        document.getElementById('ha-init-skeleton').classList.add('error');
-      };
-      window.noAuth = {{ no_auth }};
-      window.Polymer = {
-        lazyRegister: true,
-        useNativeCSSProperties: true,
-        dom: 'shadow',
-        suppressTemplateNotifications: true,
-        suppressBindingNotifications: true,
-      };
-    </script>
-  </head>
-  <body>
-    <div id='ha-init-skeleton'>
-      <div class='message'>
-        Home Assistant had trouble<br>connecting to the server.<br><br>
-        <a href='/'>TRY AGAIN</a>
-      </div>
-    </div>
-    <home-assistant icons='{{ icons }}'></home-assistant>
-    {# <script src='/static/home-assistant-polymer/build/_demo_data_compiled.js'></script> #}
-    <script>
-      var compatibilityRequired = (
-        typeof Object.assign != 'function');
-      if (compatibilityRequired) {
-        var e = document.createElement('script');
-        e.onerror = initError;
-        e.src = '{{ compatibility_url }}';
-        document.head.appendChild(e);
-      }
-    </script>
-    <script src='{{ core_url }}'></script>
-    {% if not dev_mode %}
-    <script src='/static/custom-elements-es5-adapter.js'></script>
-    {% endif %}
-    <script>
-      var webComponentsSupported = (
-        'customElements' in window &&
-        'import' in document.createElement('link') &&
-        'content' in document.createElement('template'));
-      if (!webComponentsSupported) {
-        var e = document.createElement('script');
-        e.onerror = initError;
-        e.src = '/static/webcomponents-lite.js';
-        document.head.appendChild(e);
-      }
-    </script>
-    <link rel='import' href='{{ ui_url }}' onerror='initError()'>
-    {% if panel_url -%}
-      <link rel='import' href='{{ panel_url }}' onerror='initError()' async>
-    {% endif -%}
-    <link rel='import' href='{{ icons_url }}' async>
-    {% for extra_url in extra_urls -%}
-      <link rel='import' href='{{ extra_url }}' async>
-    {% endfor -%}
-  </body>
-</html>
@@ -1,24 +0,0 @@
-"""DO NOT MODIFY. Auto-generated by script/fingerprint_frontend."""
-
-FINGERPRINTS = {
-    "compatibility.js": "1686167ff210e001f063f5c606b2e74b",
-    "core.js": "2a7d01e45187c7d4635da05065b5e54e",
-    "frontend.html": "2de1bde3b4a6c6c47dd95504fc098906",
-    "mdi.html": "2e848b4da029bf73d426d5ba058a088d",
-    "micromarkdown-js.html": "93b5ec4016f0bba585521cf4d18dec1a",
-    "panels/ha-panel-config.html": "52e2e1d477bfd6dc3708d65b8337f0af",
-    "panels/ha-panel-dev-event.html": "d409e7ab537d9fe629126d122345279c",
-    "panels/ha-panel-dev-info.html": "b0e55eb657fd75f21aba2426ac0cedc0",
-    "panels/ha-panel-dev-mqtt.html": "94b222b013a98583842de3e72d5888c6",
-    "panels/ha-panel-dev-service.html": "422b2c181ee0713fa31d45a64e605baf",
-    "panels/ha-panel-dev-state.html": "7948d3dba058f31517d880df8ed0e857",
-    "panels/ha-panel-dev-template.html": "928e7b81b9c113b70edc9f4a1d051827",
-    "panels/ha-panel-hassio.html": "b46e7619f3c355f872d5370741d89f6a",
-    "panels/ha-panel-history.html": "fe2daac10a14f51fa3eb7d23978df1f7",
-    "panels/ha-panel-iframe.html": "56930204d6e067a3d600cf030f4b34c8",
-    "panels/ha-panel-kiosk.html": "b40aa5cb52dd7675bea744afcf9eebf8",
-    "panels/ha-panel-logbook.html": "771afdcf48dc7e308b0282417d2e02d8",
-    "panels/ha-panel-mailbox.html": "a8cca44ca36553e91565e3c894ea6323",
-    "panels/ha-panel-map.html": "565db019147162080c21af962afc097f",
-    "panels/ha-panel-shopping-list.html": "d8cfd0ecdb3aa6214c0f6908c34c7141"
-}
@@ -1 +0,0 @@
-!function(){"use strict";function e(e,t){if(void 0===e||null===e)throw new TypeError("Cannot convert first argument to object");for(var r=Object(e),n=1;n<arguments.length;n++){var o=arguments[n];if(void 0!==o&&null!==o)for(var i=Object.keys(Object(o)),l=0,c=i.length;l<c;l++){var a=i[l],b=Object.getOwnPropertyDescriptor(o,a);void 0!==b&&b.enumerable&&(r[a]=o[a])}}return r}({assign:e,polyfill:function(){Object.assign||Object.defineProperty(Object,"assign",{enumerable:!1,configurable:!0,writable:!0,value:e})}}).polyfill()}();
--- a/Show More
+++ b/Show More
				`@@ -1 +0,0 @@`
				!function(){"use strict";function e(e,t){if(void 0===e\|\|null===e)throw new TypeError("Cannot convert first argument to object");for(var r=Object(e),n=1;n<arguments.length;n++){var o=arguments[n];if(void 0!==o&&null!==o)for(var i=Object.keys(Object(o)),l=0,c=i.length;l<c;l++){var a=i[l],b=Object.getOwnPropertyDescriptor(o,a);void 0!==b&&b.enumerable&&(r[a]=o[a])}}return r}({assign:e,polyfill:function(){Object.assign\|\|Object.defineProperty(Object,"assign",{enumerable:!1,configurable:!0,writable:!0,value:e})}}).polyfill()}();