Merge pull request #10898 from home-assistant/release-0-59

0.59

.coveragerc

@@ -53,6 +53,8 @@ omit =
     homeassistant/components/digital_ocean.py
     homeassistant/components/*/digital_ocean.py
 
+    homeassistant/components/dominos.py
+
 	homeassistant/components/doorbird.py
 	homeassistant/components/*/doorbird.py
 
@@ -80,6 +82,9 @@ omit =
     homeassistant/components/hdmi_cec.py
     homeassistant/components/*/hdmi_cec.py
 
+    homeassistant/components/hive.py
+    homeassistant/components/*/hive.py
+
     homeassistant/components/homematic.py
     homeassistant/components/*/homematic.py
 
@@ -182,6 +187,9 @@ omit =
     homeassistant/components/tado.py
     homeassistant/components/*/tado.py
 
+    homeassistant/components/tahoma.py
+    homeassistant/components/*/tahoma.py
+
     homeassistant/components/tellduslive.py
     homeassistant/components/*/tellduslive.py
 
@@ -309,6 +317,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
@@ -325,6 +334,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
@@ -424,7 +434,6 @@ omit =
     homeassistant/components/notify/clicksend.py
     homeassistant/components/notify/clicksend_tts.py
     homeassistant/components/notify/discord.py
-    homeassistant/components/notify/facebook.py
     homeassistant/components/notify/free_mobile.py
     homeassistant/components/notify/gntp.py
     homeassistant/components/notify/group.py
@@ -517,6 +526,7 @@ omit =
     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
@@ -545,6 +555,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
@@ -579,12 +590,12 @@ 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
-    homeassistant/components/sensor/yweather.py
     homeassistant/components/sensor/zamg.py
     homeassistant/components/shiftr.py
     homeassistant/components/spc.py
@@ -617,6 +628,7 @@ omit =
     homeassistant/components/telegram_bot/*
     homeassistant/components/thingspeak.py
     homeassistant/components/tts/amazon_polly.py
+    homeassistant/components/tts/baidu.py
     homeassistant/components/tts/microsoft.py
     homeassistant/components/tts/picotts.py
     homeassistant/components/vacuum/roomba.py
@@ -630,7 +642,6 @@ omit =
     homeassistant/components/zwave/util.py
     homeassistant/components/vacuum/mqtt.py
 
-
 [report]
 # Regexes for lines to exclude from consideration
 exclude_lines =

.gitignore

@@ -96,4 +96,4 @@ docs/build
 desktop.ini
 /home-assistant.pyproj
 /home-assistant.sln
-/.vs/home-assistant/v14
+/.vs/*

.travis.yml

@@ -8,18 +8,18 @@ matrix:
   include:
     - python: "3.4.2"
       env: TOXENV=lint
+    - python: "3.4.2"
+      env: TOXENV=pylint
     - python: "3.4.2"
       env: TOXENV=py34
     # - python: "3.5"
     #   env: TOXENV=typing
-    - python: "3.5"
+    - python: "3.5.3"
       env: TOXENV=py35
     - python: "3.6"
       env: TOXENV=py36
     # - python: "3.6-dev"
     #   env: TOXENV=py36
-    - python: "3.4.2"
-      env: TOXENV=requirements
   # allow_failures:
   #   - python: "3.5"
   #     env: TOXENV=typing
@@ -29,5 +29,5 @@ cache:
     - $HOME/.cache/pip
 install: pip install -U tox coveralls
 language: python
-script: travis_wait tox
+script: travis_wait 30 tox --develop
 after_success: coveralls

CODEOWNERS

@@ -46,6 +46,7 @@ homeassistant/components/climate/eq3btsmart.py @rytilahti
 homeassistant/components/climate/sensibo.py @andrey-git
 homeassistant/components/cover/template.py @PhracturedBlue
 homeassistant/components/device_tracker/automatic.py @armills
+homeassistant/components/device_tracker/tile.py @bachya
 homeassistant/components/history_graph.py @andrey-git
 homeassistant/components/light/tplink.py @rytilahti
 homeassistant/components/light/yeelight.py @rytilahti
@@ -63,9 +64,19 @@ homeassistant/components/switch/tplink.py @rytilahti
 homeassistant/components/xiaomi_aqara.py @danielhiversen @syssi
 
 homeassistant/components/*/broadlink.py @danielhiversen
+homeassistant/components/hive.py @Rendili @KJonline
+homeassistant/components/*/hive.py @Rendili @KJonline
 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/tahoma.py @philklei
+homeassistant/components/*/tahoma.py @philklei
 homeassistant/components/tesla.py @zabuldon
 homeassistant/components/*/tesla.py @zabuldon
+homeassistant/components/tellduslive.py @molobrakos @fredrike
+homeassistant/components/*/tellduslive.py @molobrakos @fredrike
 homeassistant/components/*/tradfri.py @ggravlingen
 homeassistant/components/*/xiaomi_aqara.py @danielhiversen @syssi
 homeassistant/components/*/xiaomi_miio.py @rytilahti @syssi

docs/source/conf.py

@@ -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']

homeassistant/bootstrap.py

@@ -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],

homeassistant/components/abode.py

@@ -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__)
 

homeassistant/components/alarm_control_panel/__init__.py

@@ -14,7 +14,7 @@ import voluptuous as vol
 from homeassistant.const import (
     ATTR_CODE, ATTR_CODE_FORMAT, ATTR_ENTITY_ID, SERVICE_ALARM_TRIGGER,
     SERVICE_ALARM_DISARM, SERVICE_ALARM_ARM_HOME, SERVICE_ALARM_ARM_AWAY,
-    SERVICE_ALARM_ARM_NIGHT)
+    SERVICE_ALARM_ARM_NIGHT, SERVICE_ALARM_ARM_CUSTOM_BYPASS)
 from homeassistant.config import load_yaml_config_file
 from homeassistant.loader import bind_hass
 from homeassistant.helpers.config_validation import PLATFORM_SCHEMA  # noqa
@@ -33,6 +33,7 @@ SERVICE_TO_METHOD = {
     SERVICE_ALARM_ARM_HOME: 'alarm_arm_home',
     SERVICE_ALARM_ARM_AWAY: 'alarm_arm_away',
     SERVICE_ALARM_ARM_NIGHT: 'alarm_arm_night',
+    SERVICE_ALARM_ARM_CUSTOM_BYPASS: 'alarm_arm_custom_bypass',
     SERVICE_ALARM_TRIGGER: 'alarm_trigger'
 }
 
@@ -107,6 +108,18 @@ def alarm_trigger(hass, code=None, entity_id=None):
     hass.services.call(DOMAIN, SERVICE_ALARM_TRIGGER, data)
 
 
+@bind_hass
+def alarm_arm_custom_bypass(hass, code=None, entity_id=None):
+    """Send the alarm the command for arm custom bypass."""
+    data = {}
+    if code:
+        data[ATTR_CODE] = code
+    if entity_id:
+        data[ATTR_ENTITY_ID] = entity_id
+
+    hass.services.call(DOMAIN, SERVICE_ALARM_ARM_CUSTOM_BYPASS, data)
+
+
 @asyncio.coroutine
 def async_setup(hass, config):
     """Track states and offer events for sensors."""
@@ -216,6 +229,17 @@ class AlarmControlPanel(Entity):
         """
         return self.hass.async_add_job(self.alarm_trigger, code)
 
+    def alarm_arm_custom_bypass(self, code=None):
+        """Send arm custom bypass command."""
+        raise NotImplementedError()
+
+    def async_alarm_arm_custom_bypass(self, code=None):
+        """Send arm custom bypass command.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.async_add_job(self.alarm_arm_custom_bypass, code)
+
     @property
     def state_attributes(self):
         """Return the state attributes."""

homeassistant/components/alarm_control_panel/arlo.py

@@ -22,6 +22,7 @@ _LOGGER = logging.getLogger(__name__)
 ARMED = 'armed'
 
 CONF_HOME_MODE_NAME = 'home_mode_name'
+CONF_AWAY_MODE_NAME = 'away_mode_name'
 
 DEPENDENCIES = ['arlo']
 
@@ -31,6 +32,7 @@ ICON = 'mdi:security'
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_HOME_MODE_NAME, default=ARMED): cv.string,
+    vol.Optional(CONF_AWAY_MODE_NAME, default=ARMED): cv.string,
 })
 
 
@@ -43,19 +45,22 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
         return
 
     home_mode_name = config.get(CONF_HOME_MODE_NAME)
+    away_mode_name = config.get(CONF_AWAY_MODE_NAME)
     base_stations = []
     for base_station in data.base_stations:
-        base_stations.append(ArloBaseStation(base_station, home_mode_name))
+        base_stations.append(ArloBaseStation(base_station, home_mode_name,
+                                             away_mode_name))
     async_add_devices(base_stations, True)
 
 
 class ArloBaseStation(AlarmControlPanel):
     """Representation of an Arlo Alarm Control Panel."""
 
-    def __init__(self, data, home_mode_name):
+    def __init__(self, data, home_mode_name, away_mode_name):
         """Initialize the alarm control panel."""
         self._base_station = data
         self._home_mode_name = home_mode_name
+        self._away_mode_name = away_mode_name
         self._state = None
 
     @property
@@ -89,8 +94,8 @@ class ArloBaseStation(AlarmControlPanel):
 
     @asyncio.coroutine
     def async_alarm_arm_away(self, code=None):
-        """Send arm away command."""
-        self._base_station.mode = ARMED
+        """Send arm away command. Uses custom mode."""
+        self._base_station.mode = self._away_mode_name
 
     @asyncio.coroutine
     def async_alarm_arm_home(self, code=None):
@@ -118,4 +123,6 @@ class ArloBaseStation(AlarmControlPanel):
             return STATE_ALARM_DISARMED
         elif mode == self._home_mode_name:
             return STATE_ALARM_ARMED_HOME
+        elif mode == self._away_mode_name:
+            return STATE_ALARM_ARMED_AWAY
         return None

homeassistant/components/alarm_control_panel/demo.py

@@ -7,7 +7,7 @@ https://home-assistant.io/components/demo/
 import homeassistant.components.alarm_control_panel.manual as manual
 from homeassistant.const import (
     STATE_ALARM_ARMED_AWAY, STATE_ALARM_ARMED_HOME, STATE_ALARM_ARMED_NIGHT,
-    STATE_ALARM_TRIGGERED, CONF_PENDING_TIME)
+    STATE_ALARM_ARMED_CUSTOM_BYPASS, STATE_ALARM_TRIGGERED, CONF_PENDING_TIME)
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
@@ -23,6 +23,9 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
             STATE_ALARM_ARMED_NIGHT: {
                 CONF_PENDING_TIME: 5
             },
+            STATE_ALARM_ARMED_CUSTOM_BYPASS: {
+                CONF_PENDING_TIME: 5
+            },
             STATE_ALARM_TRIGGERED: {
                 CONF_PENDING_TIME: 5
             },

homeassistant/components/alarm_control_panel/manual.py

@@ -14,9 +14,9 @@ import homeassistant.components.alarm_control_panel as alarm
 import homeassistant.util.dt as dt_util
 from homeassistant.const import (
     STATE_ALARM_ARMED_AWAY, STATE_ALARM_ARMED_HOME, STATE_ALARM_ARMED_NIGHT,
-    STATE_ALARM_DISARMED, STATE_ALARM_PENDING, STATE_ALARM_TRIGGERED,
-    CONF_PLATFORM, CONF_NAME, CONF_CODE, CONF_PENDING_TIME, CONF_TRIGGER_TIME,
-    CONF_DISARM_AFTER_TRIGGER)
+    STATE_ALARM_ARMED_CUSTOM_BYPASS, STATE_ALARM_DISARMED, STATE_ALARM_PENDING,
+    STATE_ALARM_TRIGGERED, CONF_PLATFORM, CONF_NAME, CONF_CODE,
+    CONF_PENDING_TIME, CONF_TRIGGER_TIME, CONF_DISARM_AFTER_TRIGGER)
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.event import track_point_in_time
 
@@ -26,7 +26,8 @@ DEFAULT_TRIGGER_TIME = 120
 DEFAULT_DISARM_AFTER_TRIGGER = False
 
 SUPPORTED_PENDING_STATES = [STATE_ALARM_ARMED_AWAY, STATE_ALARM_ARMED_HOME,
-                            STATE_ALARM_ARMED_NIGHT, STATE_ALARM_TRIGGERED]
+                            STATE_ALARM_ARMED_NIGHT, STATE_ALARM_TRIGGERED,
+                            STATE_ALARM_ARMED_CUSTOM_BYPASS]
 
 ATTR_POST_PENDING_STATE = 'post_pending_state'
 
@@ -59,6 +60,8 @@ PLATFORM_SCHEMA = vol.Schema(vol.All({
     vol.Optional(STATE_ALARM_ARMED_AWAY, default={}): STATE_SETTING_SCHEMA,
     vol.Optional(STATE_ALARM_ARMED_HOME, default={}): STATE_SETTING_SCHEMA,
     vol.Optional(STATE_ALARM_ARMED_NIGHT, default={}): STATE_SETTING_SCHEMA,
+    vol.Optional(STATE_ALARM_ARMED_CUSTOM_BYPASS,
+                 default={}): STATE_SETTING_SCHEMA,
     vol.Optional(STATE_ALARM_TRIGGERED, default={}): STATE_SETTING_SCHEMA,
 }, _state_validator))
 
@@ -174,6 +177,13 @@ class ManualAlarm(alarm.AlarmControlPanel):
 
         self._update_state(STATE_ALARM_ARMED_NIGHT)
 
+    def alarm_arm_custom_bypass(self, code=None):
+        """Send arm custom bypass command."""
+        if not self._validate_code(code, STATE_ALARM_ARMED_CUSTOM_BYPASS):
+            return
+
+        self._update_state(STATE_ALARM_ARMED_CUSTOM_BYPASS)
+
     def alarm_trigger(self, code=None):
         """Send alarm trigger command. No code needed."""
         self._pre_trigger_state = self._state

homeassistant/components/alarm_control_panel/spc.py

@@ -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."""

homeassistant/components/alarm_control_panel/totalconnect.py

@@ -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.12']
+REQUIREMENTS = ['total_connect_client==0.16']
 
 _LOGGER = logging.getLogger(__name__)
 

homeassistant/components/alexa/const.py

@@ -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'

homeassistant/components/alexa/intent.py

@@ -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."""

homeassistant/components/alexa/smart_home.py

@@ -1,12 +1,20 @@
 """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
 
@@ -14,14 +22,32 @@ 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],
+    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',
@@ -30,11 +56,28 @@ MAPPING_COMPONENT = {
             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'
 
@@ -50,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):
@@ -99,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.
@@ -107,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 = '{} (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()
 
@@ -153,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('#', '.')
 
@@ -164,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
 
@@ -172,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)
 
@@ -184,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)
 
@@ -196,7 +269,7 @@ 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 = int(request[API_PAYLOAD]['brightness'])
 
@@ -211,7 +284,7 @@ def async_api_set_brightness(hass, request, entity):
 @HANDLERS.register(('Alexa.BrightnessController', 'AdjustBrightness'))
 @extract_entity
 @asyncio.coroutine
-def async_api_adjust_brightness(hass, request, entity):
+def async_api_adjust_brightness(hass, config, request, entity):
     """Process a adjust brightness request."""
     brightness_delta = int(request[API_PAYLOAD]['brightnessDelta'])
 
@@ -235,7 +308,7 @@ def async_api_adjust_brightness(hass, request, entity):
 @HANDLERS.register(('Alexa.ColorController', 'SetColor'))
 @extract_entity
 @asyncio.coroutine
-def async_api_set_color(hass, request, entity):
+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(
@@ -263,7 +336,7 @@ def async_api_set_color(hass, request, entity):
 @HANDLERS.register(('Alexa.ColorTemperatureController', 'SetColorTemperature'))
 @extract_entity
 @asyncio.coroutine
-def async_api_set_color_temperature(hass, request, entity):
+def async_api_set_color_temperature(hass, config, request, entity):
     """Process a set color temperature request."""
     kelvin = int(request[API_PAYLOAD]['colorTemperatureInKelvin'])
 
@@ -279,7 +352,7 @@ def async_api_set_color_temperature(hass, request, entity):
     ('Alexa.ColorTemperatureController', 'DecreaseColorTemperature'))
 @extract_entity
 @asyncio.coroutine
-def async_api_decrease_color_temp(hass, request, entity):
+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))
@@ -297,7 +370,7 @@ def async_api_decrease_color_temp(hass, request, entity):
     ('Alexa.ColorTemperatureController', 'IncreaseColorTemperature'))
 @extract_entity
 @asyncio.coroutine
-def async_api_increase_color_temp(hass, request, entity):
+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))
@@ -309,3 +382,262 @@ def async_api_increase_color_temp(hass, request, entity):
     }, 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)

homeassistant/components/amcrest.py

@@ -89,6 +89,7 @@ def setup(hass, config):
     """Set up the Amcrest IP Camera component."""
     from amcrest import AmcrestCamera
 
+    hass.data[DATA_AMCREST] = {}
     amcrest_cams = config[DOMAIN]
 
     for device in amcrest_cams:
@@ -126,22 +127,34 @@ def setup(hass, config):
             else:
                 authentication = None
 
+        hass.data[DATA_AMCREST][name] = AmcrestDevice(
+            camera, name, authentication, ffmpeg_arguments, stream_source,
+            resolution)
+
         discovery.load_platform(
             hass, 'camera', DOMAIN, {
-                'device': camera,
-                CONF_AUTHENTICATION: authentication,
-                CONF_FFMPEG_ARGUMENTS: ffmpeg_arguments,
                 CONF_NAME: name,
-                CONF_RESOLUTION: resolution,
-                CONF_STREAM_SOURCE: stream_source,
             }, config)
 
         if sensors:
             discovery.load_platform(
                 hass, 'sensor', DOMAIN, {
-                    'device': camera,
                     CONF_NAME: name,
                     CONF_SENSORS: sensors,
                 }, config)
 
     return True
+
+
+class AmcrestDevice(object):
+    """Representation of a base Amcrest discovery device."""
+
+    def __init__(self, camera, name, authentication, ffmpeg_arguments,
+                 stream_source, resolution):
+        """Initialize the entity."""
+        self.device = camera
+        self.name = name
+        self.authentication = authentication
+        self.ffmpeg_arguments = ffmpeg_arguments
+        self.stream_source = stream_source
+        self.resolution = resolution

homeassistant/components/apple_tv.py

@@ -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__)
 

homeassistant/components/arlo.py

@@ -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__)
 

homeassistant/components/automation/numeric_state.py

@@ -37,8 +37,8 @@ def async_trigger(hass, config, action):
     above = config.get(CONF_ABOVE)
     time_delta = config.get(CONF_FOR)
     value_template = config.get(CONF_VALUE_TEMPLATE)
-    async_remove_track_same = None
-    already_triggered = False
+    unsub_track_same = {}
+    entities_triggered = set()
 
     if value_template is not None:
         value_template.hass = hass
@@ -63,8 +63,6 @@ def async_trigger(hass, config, action):
     @callback
     def state_automation_listener(entity, from_s, to_s):
         """Listen for state changes and calls action."""
-        nonlocal already_triggered, async_remove_track_same
-
         @callback
         def call_action():
             """Call action with right context."""
@@ -81,16 +79,18 @@ def async_trigger(hass, config, action):
 
         matching = check_numeric_state(entity, from_s, to_s)
 
-        if matching and not already_triggered:
+        if not matching:
+            entities_triggered.discard(entity)
+        elif entity not in entities_triggered:
+            entities_triggered.add(entity)
+
             if time_delta:
-                async_remove_track_same = async_track_same_state(
+                unsub_track_same[entity] = 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)
 
@@ -98,7 +98,8 @@ def async_trigger(hass, config, action):
     def async_remove():
         """Remove state listeners async."""
         unsub()
-        if async_remove_track_same:
-            async_remove_track_same()  # pylint: disable=not-callable
+        for async_remove in unsub_track_same.values():
+            async_remove()
+        unsub_track_same.clear()
 
     return async_remove

homeassistant/components/automation/state.py

@@ -35,13 +35,11 @@ def async_trigger(hass, config, action):
     to_state = config.get(CONF_TO, MATCH_ALL)
     time_delta = config.get(CONF_FOR)
     match_all = (from_state == MATCH_ALL and to_state == MATCH_ALL)
-    async_remove_track_same = None
+    unsub_track_same = {}
 
     @callback
     def state_automation_listener(entity, from_s, to_s):
         """Listen for state changes and calls action."""
-        nonlocal async_remove_track_same
-
         @callback
         def call_action():
             """Call action with right context."""
@@ -64,7 +62,7 @@ def async_trigger(hass, config, action):
             call_action()
             return
 
-        async_remove_track_same = async_track_same_state(
+        unsub_track_same[entity] = async_track_same_state(
             hass, time_delta, call_action,
             lambda _, _2, to_state: to_state.state == to_s.state,
             entity_ids=entity_id)
@@ -76,7 +74,8 @@ def async_trigger(hass, config, action):
     def async_remove():
         """Remove state listeners async."""
         unsub()
-        if async_remove_track_same:
-            async_remove_track_same()  # pylint: disable=not-callable
+        for async_remove in unsub_track_same.values():
+            async_remove()
+        unsub_track_same.clear()
 
     return async_remove

homeassistant/components/axis.py

@@ -5,7 +5,6 @@ For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/axis/
 """
 
-import json
 import logging
 import os
 
@@ -22,6 +21,7 @@ from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers import discovery
 from homeassistant.helpers.dispatcher import dispatcher_send
 from homeassistant.helpers.entity import Entity
+from homeassistant.util.json import load_json, save_json
 
 
 REQUIREMENTS = ['axis==14']
@@ -103,9 +103,9 @@ def request_configuration(hass, config, name, host, serialnumber):
             return False
 
         if setup_device(hass, config, device_config):
-            config_file = _read_config(hass)
+            config_file = load_json(hass.config.path(CONFIG_FILE))
             config_file[serialnumber] = dict(device_config)
-            _write_config(hass, config_file)
+            save_json(hass.config.path(CONFIG_FILE), config_file)
             configurator.request_done(request_id)
         else:
             configurator.notify_errors(request_id,
@@ -163,7 +163,7 @@ def setup(hass, config):
         serialnumber = discovery_info['properties']['macaddress']
 
         if serialnumber not in AXIS_DEVICES:
-            config_file = _read_config(hass)
+            config_file = load_json(hass.config.path(CONFIG_FILE))
             if serialnumber in config_file:
                 # Device config previously saved to file
                 try:
@@ -269,29 +269,11 @@ def setup_device(hass, config, device_config):
                                     config)
 
     AXIS_DEVICES[device.serial_number] = device
-    hass.add_job(device.start)
+    if event_types:
+        hass.add_job(device.start)
     return True
 
 
-def _read_config(hass):
-    """Read Axis config."""
-    path = hass.config.path(CONFIG_FILE)
-
-    if not os.path.isfile(path):
-        return {}
-
-    with open(path) as f_handle:
-        # Guard against empty file
-        return json.loads(f_handle.read() or '{}')
-
-
-def _write_config(hass, config):
-    """Write Axis config."""
-    data = json.dumps(config)
-    with open(hass.config.path(CONFIG_FILE), 'w', encoding='utf-8') as outfile:
-        outfile.write(data)
-
-
 class AxisDeviceEvent(Entity):
     """Representation of a Axis device event."""
 

homeassistant/components/binary_sensor/__init__.py

@@ -20,6 +20,7 @@ SCAN_INTERVAL = timedelta(seconds=30)
 
 ENTITY_ID_FORMAT = DOMAIN + '.{}'
 DEVICE_CLASSES = [
+    'battery',       # On means low, Off means normal
     'cold',          # On means cold (or too cold)
     'connectivity',  # On means connection present, Off = no connection
     'gas',           # CO, CO2, etc.
@@ -30,7 +31,9 @@ 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
+    'presence',      # On means home, Off means away
     'safety',        # Generic on=unsafe, off=safe
     'smoke',         # Smoke detector
     'sound',         # On means sound detected, Off means no sound

homeassistant/components/binary_sensor/aurora.py

@@ -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)

homeassistant/components/binary_sensor/hive.py

@@ -0,0 +1,63 @@
+"""
+Support for the Hive devices.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.hive/
+"""
+from homeassistant.components.binary_sensor import BinarySensorDevice
+from homeassistant.components.hive import DATA_HIVE
+
+DEPENDENCIES = ['hive']
+
+DEVICETYPE_DEVICE_CLASS = {'motionsensor': 'motion',
+                           'contactsensor': 'opening'}
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up Hive sensor devices."""
+    if discovery_info is None:
+        return
+    session = hass.data.get(DATA_HIVE)
+
+    add_devices([HiveBinarySensorEntity(session, discovery_info)])
+
+
+class HiveBinarySensorEntity(BinarySensorDevice):
+    """Representation of a Hive binary sensor."""
+
+    def __init__(self, hivesession, hivedevice):
+        """Initialize the hive sensor."""
+        self.node_id = hivedevice["Hive_NodeID"]
+        self.node_name = hivedevice["Hive_NodeName"]
+        self.device_type = hivedevice["HA_DeviceType"]
+        self.node_device_type = hivedevice["Hive_DeviceType"]
+        self.session = hivesession
+        self.data_updatesource = '{}.{}'.format(self.device_type,
+                                                self.node_id)
+
+        self.session.entities.append(self)
+
+    def handle_update(self, updatesource):
+        """Handle the new update request."""
+        if '{}.{}'.format(self.device_type, self.node_id) not in updatesource:
+            self.schedule_update_ha_state()
+
+    @property
+    def device_class(self):
+        """Return the class of this sensor."""
+        return DEVICETYPE_DEVICE_CLASS.get(self.node_device_type)
+
+    @property
+    def name(self):
+        """Return the name of the binary sensor."""
+        return self.node_name
+
+    @property
+    def is_on(self):
+        """Return true if the binary sensor is on."""
+        return self.session.sensor.get_state(self.node_id,
+                                             self.node_device_type)
+
+    def update(self):
+        """Update all Node data frome Hive."""
+        self.session.core.update_data(self.node_id)

homeassistant/components/binary_sensor/homematic.py

@@ -25,6 +25,7 @@ SENSOR_TYPES_CLASS = {
     'RemoteMotion': None,
     'WeatherSensor': None,
     'TiltSensor': None,
+    'PresenceIP': 'motion',
 }
 
 

homeassistant/components/binary_sensor/ring.py

@@ -27,7 +27,7 @@ SCAN_INTERVAL = timedelta(seconds=5)
 
 # Sensor types: Name, category, device_class
 SENSOR_TYPES = {
-    'ding': ['Ding', ['doorbell', 'stickup_cams'], 'occupancy'],
+    'ding': ['Ding', ['doorbell'], 'occupancy'],
     'motion': ['Motion', ['doorbell', 'stickup_cams'], 'motion'],
 }
 

homeassistant/components/binary_sensor/spc.py

@@ -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()

homeassistant/components/binary_sensor/vultr.py

@@ -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]

homeassistant/components/bloomsky.py

@@ -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:

homeassistant/components/camera/amcrest.py

@@ -8,9 +8,10 @@ import asyncio
 import logging
 
 from homeassistant.components.amcrest import (
-    STREAM_SOURCE_LIST, TIMEOUT)
+    DATA_AMCREST, STREAM_SOURCE_LIST, TIMEOUT)
 from homeassistant.components.camera import Camera
 from homeassistant.components.ffmpeg import DATA_FFMPEG
+from homeassistant.const import CONF_NAME
 from homeassistant.helpers.aiohttp_client import (
     async_get_clientsession, async_aiohttp_proxy_web,
     async_aiohttp_proxy_stream)
@@ -26,21 +27,10 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
     if discovery_info is None:
         return
 
-    device = discovery_info['device']
-    authentication = discovery_info['authentication']
-    ffmpeg_arguments = discovery_info['ffmpeg_arguments']
-    name = discovery_info['name']
-    resolution = discovery_info['resolution']
-    stream_source = discovery_info['stream_source']
+    device_name = discovery_info[CONF_NAME]
+    amcrest = hass.data[DATA_AMCREST][device_name]
 
-    async_add_devices([
-        AmcrestCam(hass,
-                   name,
-                   device,
-                   authentication,
-                   ffmpeg_arguments,
-                   stream_source,
-                   resolution)], True)
+    async_add_devices([AmcrestCam(hass, amcrest)], True)
 
     return True
 
@@ -48,18 +38,17 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
 class AmcrestCam(Camera):
     """An implementation of an Amcrest IP camera."""
 
-    def __init__(self, hass, name, camera, authentication,
-                 ffmpeg_arguments, stream_source, resolution):
+    def __init__(self, hass, amcrest):
         """Initialize an Amcrest camera."""
         super(AmcrestCam, self).__init__()
-        self._name = name
-        self._camera = camera
+        self._name = amcrest.name
+        self._camera = amcrest.device
         self._base_url = self._camera.get_base_url()
         self._ffmpeg = hass.data[DATA_FFMPEG]
-        self._ffmpeg_arguments = ffmpeg_arguments
-        self._stream_source = stream_source
-        self._resolution = resolution
-        self._token = self._auth = authentication
+        self._ffmpeg_arguments = amcrest.ffmpeg_arguments
+        self._stream_source = amcrest.stream_source
+        self._resolution = amcrest.resolution
+        self._token = self._auth = amcrest.authentication
 
     def camera_image(self):
         """Return a still image response from the camera."""

homeassistant/components/camera/arlo.py

@@ -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()

homeassistant/components/camera/ring.py

@@ -7,12 +7,13 @@ https://home-assistant.io/components/camera.ring/
 import asyncio
 import logging
 
-from datetime import datetime, timedelta
+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.ring import (
+    DATA_RING, CONF_ATTRIBUTION, NOTIFICATION_ID)
 from homeassistant.components.camera import Camera, PLATFORM_SCHEMA
 from homeassistant.components.ffmpeg import DATA_FFMPEG
 from homeassistant.const import ATTR_ATTRIBUTION, CONF_SCAN_INTERVAL
@@ -23,8 +24,12 @@ CONF_FFMPEG_ARGUMENTS = 'ffmpeg_arguments'
 
 DEPENDENCIES = ['ring', 'ffmpeg']
 
+FORCE_REFRESH_INTERVAL = timedelta(minutes=45)
+
 _LOGGER = logging.getLogger(__name__)
 
+NOTIFICATION_TITLE = 'Ring Camera Setup'
+
 SCAN_INTERVAL = timedelta(seconds=90)
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
@@ -40,11 +45,33 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
     ring = hass.data[DATA_RING]
 
     cams = []
+    cams_no_plan = []
     for camera in ring.doorbells:
-        cams.append(RingCam(hass, camera, config))
+        if camera.has_subscription:
+            cams.append(RingCam(hass, camera, config))
+        else:
+            cams_no_plan.append(camera)
 
     for camera in ring.stickup_cams:
-        cams.append(RingCam(hass, camera, config))
+        if camera.has_subscription:
+            cams.append(RingCam(hass, camera, config))
+        else:
+            cams_no_plan.append(camera)
+
+    # show notification for all cameras without an active subscription
+    if cams_no_plan:
+        cameras = str(', '.join([camera.name for camera in cams_no_plan]))
+
+        err_msg = '''A Ring Protect Plan is required for the''' \
+                  ''' following cameras: {}.'''.format(cameras)
+
+        _LOGGER.error(err_msg)
+        hass.components.persistent_notification.async_create(
+            'Error: {}<br />'
+            'You will need to restart hass after fixing.'
+            ''.format(err_msg),
+            title=NOTIFICATION_TITLE,
+            notification_id=NOTIFICATION_ID)
 
     async_add_devices(cams, True)
     return True
@@ -63,8 +90,8 @@ class RingCam(Camera):
         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._expires_at = None
-        self._utcnow = None
+        self._utcnow = dt_util.utcnow()
+        self._expires_at = FORCE_REFRESH_INTERVAL + self._utcnow
 
     @property
     def name(self):
@@ -82,7 +109,6 @@ class RingCam(Camera):
             'timezone': self._camera.timezone,
             'type': self._camera.family,
             'video_url': self._video_url,
-            'video_id': self._last_video_id
         }
 
     @asyncio.coroutine
@@ -123,19 +149,19 @@ class RingCam(Camera):
 
     def update(self):
         """Update camera entity and refresh attributes."""
-        # extract the video expiration from URL
-        x_amz_expires = int(self._video_url.split('&')[0].split('=')[-1])
-        x_amz_date = self._video_url.split('&')[1].split('=')[-1]
+        _LOGGER.debug("Checking if Ring DoorBell needs to refresh video_url")
 
+        self._camera.update()
         self._utcnow = dt_util.utcnow()
-        self._expires_at = \
-            timedelta(seconds=x_amz_expires) + \
-            dt_util.as_utc(datetime.strptime(x_amz_date, "%Y%m%dT%H%M%SZ"))
 
-        if self._last_video_id != self._camera.last_recording_id:
-            _LOGGER.debug("Updated Ring DoorBell last_video_id")
+        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
-
-        if self._utcnow >= self._expires_at:
-            _LOGGER.debug("Updated Ring DoorBell video_url")
             self._video_url = self._camera.recording_url(self._last_video_id)
+            self._expires_at = FORCE_REFRESH_INTERVAL + self._utcnow

homeassistant/components/climate/__init__.py

@@ -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'
 
@@ -51,6 +51,19 @@ STATE_HIGH_DEMAND = 'high_demand'
 STATE_HEAT_PUMP = 'heat_pump'
 STATE_GAS = 'gas'
 
+SUPPORT_TARGET_TEMPERATURE = 1
+SUPPORT_TARGET_TEMPERATURE_HIGH = 2
+SUPPORT_TARGET_TEMPERATURE_LOW = 4
+SUPPORT_TARGET_HUMIDITY = 8
+SUPPORT_TARGET_HUMIDITY_HIGH = 16
+SUPPORT_TARGET_HUMIDITY_LOW = 32
+SUPPORT_FAN_MODE = 64
+SUPPORT_OPERATION_MODE = 128
+SUPPORT_HOLD_MODE = 256
+SUPPORT_SWING_MODE = 512
+SUPPORT_AWAY_MODE = 1024
+SUPPORT_AUX_HEAT = 2048
+
 ATTR_CURRENT_TEMPERATURE = 'current_temperature'
 ATTR_MAX_TEMP = 'max_temp'
 ATTR_MIN_TEMP = 'min_temp'
@@ -71,11 +84,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 +464,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 +483,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:
@@ -714,6 +730,11 @@ class ClimateDevice(Entity):
         """
         return self.hass.async_add_job(self.turn_aux_heat_off)
 
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        raise NotImplementedError()
+
     @property
     def min_temp(self):
         """Return the minimum temperature."""
@@ -733,24 +754,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)

homeassistant/components/climate/demo.py

@@ -5,9 +5,19 @@ For more details about this platform, please refer to the documentation
 https://home-assistant.io/components/demo/
 """
 from homeassistant.components.climate import (
-    ClimateDevice, ATTR_TARGET_TEMP_HIGH, ATTR_TARGET_TEMP_LOW)
+    ClimateDevice, ATTR_TARGET_TEMP_HIGH, ATTR_TARGET_TEMP_LOW,
+    SUPPORT_TARGET_TEMPERATURE, SUPPORT_TARGET_HUMIDITY,
+    SUPPORT_AWAY_MODE, SUPPORT_HOLD_MODE, SUPPORT_FAN_MODE,
+    SUPPORT_OPERATION_MODE, SUPPORT_AUX_HEAT, SUPPORT_SWING_MODE,
+    SUPPORT_TARGET_TEMPERATURE_HIGH, SUPPORT_TARGET_TEMPERATURE_LOW)
 from homeassistant.const import TEMP_CELSIUS, TEMP_FAHRENHEIT, ATTR_TEMPERATURE
 
+SUPPORT_FLAGS = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_TARGET_HUMIDITY |
+                 SUPPORT_AWAY_MODE | SUPPORT_HOLD_MODE | SUPPORT_FAN_MODE |
+                 SUPPORT_OPERATION_MODE | SUPPORT_AUX_HEAT |
+                 SUPPORT_SWING_MODE | SUPPORT_TARGET_TEMPERATURE_HIGH |
+                 SUPPORT_TARGET_TEMPERATURE_LOW)
+
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Set up the Demo climate devices."""
@@ -47,6 +57,11 @@ class DemoClimate(ClimateDevice):
         self._target_temperature_high = target_temp_high
         self._target_temperature_low = target_temp_low
 
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
     @property
     def should_poll(self):
         """Return the polling state."""

homeassistant/components/climate/ecobee.py

@@ -12,7 +12,9 @@ import voluptuous as vol
 from homeassistant.components import ecobee
 from homeassistant.components.climate import (
     DOMAIN, STATE_COOL, STATE_HEAT, STATE_AUTO, STATE_IDLE, ClimateDevice,
-    ATTR_TARGET_TEMP_LOW, ATTR_TARGET_TEMP_HIGH)
+    ATTR_TARGET_TEMP_LOW, ATTR_TARGET_TEMP_HIGH, SUPPORT_TARGET_TEMPERATURE,
+    SUPPORT_AWAY_MODE, SUPPORT_HOLD_MODE, SUPPORT_OPERATION_MODE,
+    SUPPORT_TARGET_HUMIDITY_LOW, SUPPORT_TARGET_HUMIDITY_HIGH)
 from homeassistant.const import (
     ATTR_ENTITY_ID, STATE_OFF, STATE_ON, ATTR_TEMPERATURE, TEMP_FAHRENHEIT)
 from homeassistant.config import load_yaml_config_file
@@ -44,6 +46,10 @@ RESUME_PROGRAM_SCHEMA = vol.Schema({
     vol.Optional(ATTR_RESUME_ALL, default=DEFAULT_RESUME_ALL): cv.boolean,
 })
 
+SUPPORT_FLAGS = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_AWAY_MODE |
+                 SUPPORT_HOLD_MODE | SUPPORT_OPERATION_MODE |
+                 SUPPORT_TARGET_HUMIDITY_LOW | SUPPORT_TARGET_HUMIDITY_HIGH)
+
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Set up the Ecobee Thermostat Platform."""
@@ -132,6 +138,11 @@ class Thermostat(ClimateDevice):
         self.thermostat = self.data.ecobee.get_thermostat(
             self.thermostat_index)
 
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
     @property
     def name(self):
         """Return the name of the Ecobee Thermostat."""
@@ -318,8 +329,21 @@ class Thermostat(ClimateDevice):
 
     def set_auto_temp_hold(self, heat_temp, cool_temp):
         """Set temperature hold in auto mode."""
-        self.data.ecobee.set_hold_temp(self.thermostat_index, cool_temp,
-                                       heat_temp, self.hold_preference())
+        if cool_temp is not None:
+            cool_temp_setpoint = cool_temp
+        else:
+            cool_temp_setpoint = (
+                self.thermostat['runtime']['desiredCool'] / 10.0)
+
+        if heat_temp is not None:
+            heat_temp_setpoint = heat_temp
+        else:
+            heat_temp_setpoint = (
+                self.thermostat['runtime']['desiredCool'] / 10.0)
+
+        self.data.ecobee.set_hold_temp(self.thermostat_index,
+                                       cool_temp_setpoint, heat_temp_setpoint,
+                                       self.hold_preference())
         _LOGGER.debug("Setting ecobee hold_temp to: heat=%s, is=%s, "
                       "cool=%s, is=%s", heat_temp, isinstance(
                           heat_temp, (int, float)), cool_temp,
@@ -348,8 +372,8 @@ class Thermostat(ClimateDevice):
         high_temp = kwargs.get(ATTR_TARGET_TEMP_HIGH)
         temp = kwargs.get(ATTR_TEMPERATURE)
 
-        if self.current_operation == STATE_AUTO and low_temp is not None \
-           and high_temp is not None:
+        if self.current_operation == STATE_AUTO and (low_temp is not None or
+                                                     high_temp is not None):
             self.set_auto_temp_hold(low_temp, high_temp)
         elif temp is not None:
             self.set_temp_hold(temp)
@@ -357,6 +381,10 @@ class Thermostat(ClimateDevice):
             _LOGGER.error(
                 "Missing valid arguments for set_temperature in %s", kwargs)
 
+    def set_humidity(self, humidity):
+        """Set the humidity level."""
+        self.data.ecobee.set_humidity(self.thermostat_index, humidity)
+
     def set_operation_mode(self, operation_mode):
         """Set HVAC mode (auto, auxHeatOnly, cool, heat, off)."""
         self.data.ecobee.set_hvac_mode(self.thermostat_index, operation_mode)

homeassistant/components/climate/ephember.py

@@ -9,7 +9,7 @@ from datetime import timedelta
 import voluptuous as vol
 
 from homeassistant.components.climate import (
-    ClimateDevice, PLATFORM_SCHEMA, STATE_HEAT, STATE_IDLE)
+    ClimateDevice, PLATFORM_SCHEMA, STATE_HEAT, STATE_IDLE, SUPPORT_AUX_HEAT)
 from homeassistant.const import (
     TEMP_CELSIUS, CONF_USERNAME, CONF_PASSWORD)
 import homeassistant.helpers.config_validation as cv
@@ -56,6 +56,11 @@ class EphEmberThermostat(ClimateDevice):
         self._zone = zone
         self._hot_water = zone['isHotWater']
 
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_AUX_HEAT
+
     @property
     def name(self):
         """Return the name of the thermostat, if any."""

homeassistant/components/climate/eq3btsmart.py

@@ -9,12 +9,10 @@ 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,
+    SUPPORT_TARGET_TEMPERATURE, SUPPORT_OPERATION_MODE, SUPPORT_AWAY_MODE)
 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']
@@ -40,6 +38,9 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
         vol.Schema({cv.string: DEVICE_SCHEMA}),
 })
 
+SUPPORT_FLAGS = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE |
+                 SUPPORT_AWAY_MODE)
+
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Set up the eQ-3 BLE thermostats."""
@@ -58,21 +59,28 @@ 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()}
 
         self._name = _name
         self._thermostat = eq3.Thermostat(_mac)
 
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
     @property
     def available(self) -> bool:
         """Return if thermostat is available."""
@@ -153,11 +161,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

homeassistant/components/climate/flexit.py

@@ -17,7 +17,9 @@ import voluptuous as vol
 from homeassistant.const import (
     CONF_NAME, CONF_SLAVE, TEMP_CELSIUS,
     ATTR_TEMPERATURE, DEVICE_DEFAULT_NAME)
-from homeassistant.components.climate import (ClimateDevice, PLATFORM_SCHEMA)
+from homeassistant.components.climate import (
+    ClimateDevice, PLATFORM_SCHEMA, SUPPORT_TARGET_TEMPERATURE,
+    SUPPORT_FAN_MODE)
 import homeassistant.components.modbus as modbus
 import homeassistant.helpers.config_validation as cv
 
@@ -31,6 +33,8 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 _LOGGER = logging.getLogger(__name__)
 
+SUPPORT_FLAGS = SUPPORT_TARGET_TEMPERATURE | SUPPORT_FAN_MODE
+
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Set up the Flexit Platform."""
@@ -62,6 +66,11 @@ class Flexit(ClimateDevice):
         self._alarm = False
         self.unit = pyflexit.pyflexit(modbus.HUB, modbus_slave)
 
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
     def update(self):
         """Update unit attributes."""
         if not self.unit.update():

homeassistant/components/climate/generic_thermostat.py

@@ -10,17 +10,18 @@ import logging
 import voluptuous as vol
 
 from homeassistant.core import callback
-from homeassistant.components import switch
+from homeassistant.core import DOMAIN as HA_DOMAIN
 from homeassistant.components.climate import (
     STATE_HEAT, STATE_COOL, STATE_IDLE, ClimateDevice, PLATFORM_SCHEMA,
-    STATE_AUTO)
+    STATE_AUTO, SUPPORT_OPERATION_MODE, SUPPORT_TARGET_TEMPERATURE)
 from homeassistant.const import (
     ATTR_UNIT_OF_MEASUREMENT, STATE_ON, STATE_OFF, ATTR_TEMPERATURE,
-    CONF_NAME)
+    CONF_NAME, ATTR_ENTITY_ID, SERVICE_TURN_ON, SERVICE_TURN_OFF)
 from homeassistant.helpers import condition
 from homeassistant.helpers.event import (
     async_track_state_change, async_track_time_interval)
 import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers.restore_state import async_get_last_state
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -40,6 +41,7 @@ CONF_COLD_TOLERANCE = 'cold_tolerance'
 CONF_HOT_TOLERANCE = 'hot_tolerance'
 CONF_KEEP_ALIVE = 'keep_alive'
 
+SUPPORT_FLAGS = SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_HEATER): cv.entity_id,
@@ -117,6 +119,17 @@ class GenericThermostat(ClimateDevice):
         if sensor_state:
             self._async_update_temp(sensor_state)
 
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Run when entity about to be added."""
+        # If we have an old state and no target temp, restore
+        if self._target_temp is None:
+            old_state = yield from async_get_last_state(self.hass,
+                                                        self.entity_id)
+            if old_state is not None:
+                self._target_temp = float(
+                    old_state.attributes[ATTR_TEMPERATURE])
+
     @property
     def should_poll(self):
         """Return the polling state."""
@@ -163,10 +176,11 @@ 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:
-                switch.async_turn_off(self.hass, self.heater_entity_id)
+                self._heater_turn_off()
         else:
             _LOGGER.error('Unrecognized operation mode: %s', operation_mode)
             return
@@ -224,9 +238,9 @@ class GenericThermostat(ClimateDevice):
     def _async_keep_alive(self, time):
         """Call at constant intervals for keep-alive purposes."""
         if self.current_operation in [STATE_COOL, STATE_HEAT]:
-            switch.async_turn_on(self.hass, self.heater_entity_id)
+            self._heater_turn_on()
         else:
-            switch.async_turn_off(self.hass, self.heater_entity_id)
+            self._heater_turn_off()
 
     @callback
     def _async_update_temp(self, state):
@@ -272,13 +286,13 @@ class GenericThermostat(ClimateDevice):
                     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)
+                    self._heater_turn_off()
             else:
                 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)
+                    self._heater_turn_on()
         else:
             is_heating = self._is_device_active
             if is_heating:
@@ -287,15 +301,34 @@ class GenericThermostat(ClimateDevice):
                 if too_hot:
                     _LOGGER.info('Turning off heater %s',
                                  self.heater_entity_id)
-                    switch.async_turn_off(self.hass, self.heater_entity_id)
+                    self._heater_turn_off()
             else:
                 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)
+                    self._heater_turn_on()
 
     @property
     def _is_device_active(self):
         """If the toggleable device is currently active."""
-        return switch.is_on(self.hass, self.heater_entity_id)
+        return self.hass.states.is_state(self.heater_entity_id, STATE_ON)
+
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
+    @callback
+    def _heater_turn_on(self):
+        """Turn heater toggleable device on."""
+        data = {ATTR_ENTITY_ID: self.heater_entity_id}
+        self.hass.async_add_job(
+            self.hass.services.async_call(HA_DOMAIN, SERVICE_TURN_ON, data))
+
+    @callback
+    def _heater_turn_off(self):
+        """Turn heater toggleable device off."""
+        data = {ATTR_ENTITY_ID: self.heater_entity_id}
+        self.hass.async_add_job(
+            self.hass.services.async_call(HA_DOMAIN, SERVICE_TURN_OFF, data))

homeassistant/components/climate/heatmiser.py

@@ -8,7 +8,8 @@ import logging
 
 import voluptuous as vol
 
-from homeassistant.components.climate import ClimateDevice, PLATFORM_SCHEMA
+from homeassistant.components.climate import (
+    ClimateDevice, PLATFORM_SCHEMA, SUPPORT_TARGET_TEMPERATURE)
 from homeassistant.const import (
     TEMP_CELSIUS, ATTR_TEMPERATURE, CONF_PORT, CONF_NAME, CONF_ID)
 import homeassistant.helpers.config_validation as cv
@@ -68,6 +69,11 @@ class HeatmiserV3Thermostat(ClimateDevice):
         self.update()
         self._target_temperature = int(self.dcb.get('roomset'))
 
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_TARGET_TEMPERATURE
+
     @property
     def name(self):
         """Return the name of the thermostat, if any."""

homeassistant/components/climate/hive.py

@@ -0,0 +1,139 @@
+"""
+Support for the Hive devices.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/climate.hive/
+"""
+from homeassistant.components.climate import (
+    ClimateDevice, STATE_AUTO, STATE_HEAT, STATE_OFF, STATE_ON,
+    SUPPORT_TARGET_TEMPERATURE, SUPPORT_OPERATION_MODE)
+from homeassistant.const import ATTR_TEMPERATURE, TEMP_CELSIUS
+from homeassistant.components.hive import DATA_HIVE
+
+DEPENDENCIES = ['hive']
+HIVE_TO_HASS_STATE = {'SCHEDULE': STATE_AUTO, 'MANUAL': STATE_HEAT,
+                      'ON': STATE_ON, 'OFF': STATE_OFF}
+HASS_TO_HIVE_STATE = {STATE_AUTO: 'SCHEDULE', STATE_HEAT: 'MANUAL',
+                      STATE_ON: 'ON', STATE_OFF: 'OFF'}
+
+SUPPORT_FLAGS = SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up Hive climate devices."""
+    if discovery_info is None:
+        return
+    session = hass.data.get(DATA_HIVE)
+
+    add_devices([HiveClimateEntity(session, discovery_info)])
+
+
+class HiveClimateEntity(ClimateDevice):
+    """Hive Climate Device."""
+
+    def __init__(self, hivesession, hivedevice):
+        """Initialize the Climate device."""
+        self.node_id = hivedevice["Hive_NodeID"]
+        self.node_name = hivedevice["Hive_NodeName"]
+        self.device_type = hivedevice["HA_DeviceType"]
+        self.session = hivesession
+        self.data_updatesource = '{}.{}'.format(self.device_type,
+                                                self.node_id)
+
+        if self.device_type == "Heating":
+            self.modes = [STATE_AUTO, STATE_HEAT, STATE_OFF]
+        elif self.device_type == "HotWater":
+            self.modes = [STATE_AUTO, STATE_ON, STATE_OFF]
+
+        self.session.entities.append(self)
+
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
+    def handle_update(self, updatesource):
+        """Handle the new update request."""
+        if '{}.{}'.format(self.device_type, self.node_id) not in updatesource:
+            self.schedule_update_ha_state()
+
+    @property
+    def name(self):
+        """Return the name of the Climate device."""
+        friendly_name = "Climate Device"
+        if self.device_type == "Heating":
+            friendly_name = "Heating"
+            if self.node_name is not None:
+                friendly_name = '{} {}'.format(self.node_name, friendly_name)
+        elif self.device_type == "HotWater":
+            friendly_name = "Hot Water"
+        return friendly_name
+
+    @property
+    def temperature_unit(self):
+        """Return the unit of measurement."""
+        return TEMP_CELSIUS
+
+    @property
+    def current_temperature(self):
+        """Return the current temperature."""
+        if self.device_type == "Heating":
+            return self.session.heating.current_temperature(self.node_id)
+
+    @property
+    def target_temperature(self):
+        """Return the target temperature."""
+        if self.device_type == "Heating":
+            return self.session.heating.get_target_temperature(self.node_id)
+
+    @property
+    def min_temp(self):
+        """Return minimum temperature."""
+        if self.device_type == "Heating":
+            return self.session.heating.min_temperature(self.node_id)
+
+    @property
+    def max_temp(self):
+        """Return the maximum temperature."""
+        if self.device_type == "Heating":
+            return self.session.heating.max_temperature(self.node_id)
+
+    @property
+    def operation_list(self):
+        """List of the operation modes."""
+        return self.modes
+
+    @property
+    def current_operation(self):
+        """Return current mode."""
+        if self.device_type == "Heating":
+            currentmode = self.session.heating.get_mode(self.node_id)
+        elif self.device_type == "HotWater":
+            currentmode = self.session.hotwater.get_mode(self.node_id)
+        return HIVE_TO_HASS_STATE.get(currentmode)
+
+    def set_operation_mode(self, operation_mode):
+        """Set new Heating mode."""
+        new_mode = HASS_TO_HIVE_STATE.get(operation_mode)
+        if self.device_type == "Heating":
+            self.session.heating.set_mode(self.node_id, new_mode)
+        elif self.device_type == "HotWater":
+            self.session.hotwater.set_mode(self.node_id, new_mode)
+
+        for entity in self.session.entities:
+            entity.handle_update(self.data_updatesource)
+
+    def set_temperature(self, **kwargs):
+        """Set new target temperature."""
+        new_temperature = kwargs.get(ATTR_TEMPERATURE)
+        if new_temperature is not None:
+            if self.device_type == "Heating":
+                self.session.heating.set_target_temperature(self.node_id,
+                                                            new_temperature)
+
+            for entity in self.session.entities:
+                entity.handle_update(self.data_updatesource)
+
+    def update(self):
+        """Update all Node data frome Hive."""
+        self.session.core.update_data(self.node_id)

homeassistant/components/climate/homematic.py

@@ -5,9 +5,10 @@ For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/climate.homematic/
 """
 import logging
-from homeassistant.components.climate import ClimateDevice, STATE_AUTO
+from homeassistant.components.climate import (
+    ClimateDevice, STATE_AUTO, SUPPORT_TARGET_TEMPERATURE,
+    SUPPORT_OPERATION_MODE)
 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']
@@ -39,6 +40,8 @@ HM_HUMI_MAP = [
 
 HM_CONTROL_MODE = 'CONTROL_MODE'
 
+SUPPORT_FLAGS = SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE
+
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Set up the Homematic thermostat platform."""
@@ -56,6 +59,11 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 class HMThermostat(HMDevice, ClimateDevice):
     """Representation of a Homematic thermostat."""
 
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
     @property
     def temperature_unit(self):
         """Return the unit of measurement that is used."""
@@ -121,12 +129,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."""

homeassistant/components/climate/honeywell.py

@@ -14,12 +14,13 @@ 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)
+    ATTR_OPERATION_MODE, ATTR_OPERATION_LIST, SUPPORT_TARGET_TEMPERATURE,
+    SUPPORT_AWAY_MODE, SUPPORT_OPERATION_MODE)
 from homeassistant.const import (
     CONF_PASSWORD, CONF_USERNAME, TEMP_CELSIUS, TEMP_FAHRENHEIT,
     ATTR_TEMPERATURE, CONF_REGION)
 
-REQUIREMENTS = ['evohomeclient==0.2.5', 'somecomfort==0.4.1']
+REQUIREMENTS = ['evohomeclient==0.2.5', 'somecomfort==0.5.0']
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -126,6 +127,14 @@ class RoundThermostat(ClimateDevice):
         self._away_temp = away_temp
         self._away = False
 
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        supported = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_AWAY_MODE)
+        if hasattr(self.client, ATTR_SYSTEM_MODE):
+            supported |= SUPPORT_OPERATION_MODE
+        return supported
+
     @property
     def name(self):
         """Return the name of the honeywell, if any."""
@@ -234,6 +243,14 @@ class HoneywellUSThermostat(ClimateDevice):
         self._username = username
         self._password = password
 
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        supported = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_AWAY_MODE)
+        if hasattr(self._device, ATTR_SYSTEM_MODE):
+            supported |= SUPPORT_OPERATION_MODE
+        return supported
+
     @property
     def is_fan_on(self):
         """Return true if fan is on."""

homeassistant/components/climate/knx.py

@@ -8,14 +8,18 @@ import asyncio
 import voluptuous as vol
 
 from homeassistant.components.knx import DATA_KNX, ATTR_DISCOVER_DEVICES
-from homeassistant.components.climate import PLATFORM_SCHEMA, ClimateDevice
+from homeassistant.components.climate import (
+    PLATFORM_SCHEMA, ClimateDevice, SUPPORT_TARGET_TEMPERATURE,
+    SUPPORT_OPERATION_MODE)
 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 +32,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 +90,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 +98,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 +136,14 @@ 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
+
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        support = SUPPORT_TARGET_TEMPERATURE
+        if self.device.supports_operation_mode:
+            support |= SUPPORT_OPERATION_MODE
+        return support
 
     def async_register_callbacks(self):
         """Register callbacks to update hass after device was changed."""
@@ -150,28 +174,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 +200,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

homeassistant/components/climate/maxcube.py

@@ -7,7 +7,9 @@ https://home-assistant.io/components/maxcube/
 import socket
 import logging
 
-from homeassistant.components.climate import ClimateDevice, STATE_AUTO
+from homeassistant.components.climate import (
+    ClimateDevice, STATE_AUTO, SUPPORT_TARGET_TEMPERATURE,
+    SUPPORT_OPERATION_MODE)
 from homeassistant.components.maxcube import MAXCUBE_HANDLE
 from homeassistant.const import TEMP_CELSIUS, ATTR_TEMPERATURE
 
@@ -17,6 +19,8 @@ STATE_MANUAL = 'manual'
 STATE_BOOST = 'boost'
 STATE_VACATION = 'vacation'
 
+SUPPORT_FLAGS = SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE
+
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Iterate through all MAX! Devices and add thermostats."""
@@ -47,6 +51,11 @@ class MaxCubeClimate(ClimateDevice):
         self._rf_address = rf_address
         self._cubehandle = hass.data[MAXCUBE_HANDLE]
 
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
     @property
     def should_poll(self):
         """Return the polling state."""

homeassistant/components/climate/mqtt.py

@@ -15,7 +15,9 @@ import homeassistant.components.mqtt as mqtt
 from homeassistant.components.climate import (
     STATE_HEAT, STATE_COOL, STATE_DRY, STATE_FAN_ONLY, ClimateDevice,
     PLATFORM_SCHEMA as CLIMATE_PLATFORM_SCHEMA, STATE_AUTO,
-    ATTR_OPERATION_MODE)
+    ATTR_OPERATION_MODE, SUPPORT_TARGET_TEMPERATURE, SUPPORT_OPERATION_MODE,
+    SUPPORT_SWING_MODE, SUPPORT_FAN_MODE, SUPPORT_AWAY_MODE, SUPPORT_HOLD_MODE,
+    SUPPORT_AUX_HEAT)
 from homeassistant.const import (
     STATE_ON, STATE_OFF, ATTR_TEMPERATURE, CONF_NAME)
 from homeassistant.components.mqtt import (CONF_QOS, CONF_RETAIN,
@@ -483,3 +485,38 @@ class MqttClimate(ClimateDevice):
         if self._topic[CONF_AUX_STATE_TOPIC] is None:
             self._aux = False
             self.async_schedule_update_ha_state()
+
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        support = 0
+
+        if (self._topic[CONF_TEMPERATURE_STATE_TOPIC] is not None) or \
+           (self._topic[CONF_TEMPERATURE_COMMAND_TOPIC] is not None):
+            support |= SUPPORT_TARGET_TEMPERATURE
+
+        if (self._topic[CONF_MODE_COMMAND_TOPIC] is not None) or \
+           (self._topic[CONF_MODE_STATE_TOPIC] is not None):
+            support |= SUPPORT_OPERATION_MODE
+
+        if (self._topic[CONF_FAN_MODE_STATE_TOPIC] is not None) or \
+           (self._topic[CONF_FAN_MODE_COMMAND_TOPIC] is not None):
+            support |= SUPPORT_FAN_MODE
+
+        if (self._topic[CONF_SWING_MODE_STATE_TOPIC] is not None) or \
+           (self._topic[CONF_SWING_MODE_COMMAND_TOPIC] is not None):
+            support |= SUPPORT_SWING_MODE
+
+        if (self._topic[CONF_AWAY_MODE_STATE_TOPIC] is not None) or \
+           (self._topic[CONF_AWAY_MODE_COMMAND_TOPIC] is not None):
+            support |= SUPPORT_AWAY_MODE
+
+        if (self._topic[CONF_HOLD_STATE_TOPIC] is not None) or \
+           (self._topic[CONF_HOLD_COMMAND_TOPIC] is not None):
+            support |= SUPPORT_HOLD_MODE
+
+        if (self._topic[CONF_AUX_STATE_TOPIC] is not None) or \
+           (self._topic[CONF_AUX_COMMAND_TOPIC] is not None):
+            support |= SUPPORT_AUX_HEAT
+
+        return support

homeassistant/components/climate/mysensors.py

@@ -7,7 +7,9 @@ https://home-assistant.io/components/climate.mysensors/
 from homeassistant.components import mysensors
 from homeassistant.components.climate import (
     ATTR_TARGET_TEMP_HIGH, ATTR_TARGET_TEMP_LOW, DOMAIN, STATE_AUTO,
-    STATE_COOL, STATE_HEAT, STATE_OFF, ClimateDevice)
+    STATE_COOL, STATE_HEAT, STATE_OFF, ClimateDevice,
+    SUPPORT_TARGET_TEMPERATURE, SUPPORT_TARGET_TEMPERATURE_HIGH,
+    SUPPORT_TARGET_TEMPERATURE_LOW, SUPPORT_FAN_MODE, SUPPORT_OPERATION_MODE)
 from homeassistant.const import ATTR_TEMPERATURE, TEMP_CELSIUS, TEMP_FAHRENHEIT
 
 DICT_HA_TO_MYS = {
@@ -23,6 +25,10 @@ DICT_MYS_TO_HA = {
     'Off': STATE_OFF,
 }
 
+SUPPORT_FLAGS = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_TARGET_TEMPERATURE_HIGH |
+                 SUPPORT_TARGET_TEMPERATURE_LOW | SUPPORT_FAN_MODE |
+                 SUPPORT_OPERATION_MODE)
+
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Setup the mysensors climate."""
@@ -33,6 +39,11 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 class MySensorsHVAC(mysensors.MySensorsEntity, ClimateDevice):
     """Representation of a MySensors HVAC."""
 
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
     @property
     def assumed_state(self):
         """Return True if unable to access real state of entity."""

homeassistant/components/climate/nest.py

@@ -12,7 +12,9 @@ from homeassistant.components.nest import DATA_NEST
 from homeassistant.components.climate import (
     STATE_AUTO, STATE_COOL, STATE_HEAT, ClimateDevice,
     PLATFORM_SCHEMA, ATTR_TARGET_TEMP_HIGH, ATTR_TARGET_TEMP_LOW,
-    ATTR_TEMPERATURE)
+    ATTR_TEMPERATURE, SUPPORT_TARGET_TEMPERATURE,
+    SUPPORT_TARGET_TEMPERATURE_HIGH, SUPPORT_TARGET_TEMPERATURE_LOW,
+    SUPPORT_OPERATION_MODE, SUPPORT_AWAY_MODE, SUPPORT_FAN_MODE)
 from homeassistant.const import (
     TEMP_CELSIUS, TEMP_FAHRENHEIT,
     CONF_SCAN_INTERVAL, STATE_ON, STATE_OFF, STATE_UNKNOWN)
@@ -28,6 +30,10 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 STATE_ECO = 'eco'
 STATE_HEAT_COOL = 'heat-cool'
 
+SUPPORT_FLAGS = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_TARGET_TEMPERATURE_HIGH |
+                 SUPPORT_TARGET_TEMPERATURE_LOW | SUPPORT_OPERATION_MODE |
+                 SUPPORT_AWAY_MODE | SUPPORT_FAN_MODE)
+
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Set up the Nest thermostat."""
@@ -87,6 +93,11 @@ class NestThermostat(ClimateDevice):
         self._min_temperature = None
         self._max_temperature = None
 
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
     @property
     def name(self):
         """Return the name of the nest, if any."""

homeassistant/components/climate/netatmo.py

@@ -10,7 +10,8 @@ import voluptuous as vol
 
 from homeassistant.const import TEMP_CELSIUS, ATTR_TEMPERATURE
 from homeassistant.components.climate import (
-    STATE_HEAT, STATE_IDLE, ClimateDevice, PLATFORM_SCHEMA)
+    STATE_HEAT, STATE_IDLE, ClimateDevice, PLATFORM_SCHEMA,
+    SUPPORT_TARGET_TEMPERATURE, SUPPORT_OPERATION_MODE, SUPPORT_AWAY_MODE)
 from homeassistant.util import Throttle
 from homeassistant.loader import get_component
 import homeassistant.helpers.config_validation as cv
@@ -35,6 +36,9 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
         vol.All(cv.ensure_list, [cv.string]),
 })
 
+SUPPORT_FLAGS = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE |
+                 SUPPORT_AWAY_MODE)
+
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Set up the NetAtmo Thermostat."""
@@ -65,6 +69,11 @@ class NetatmoThermostat(ClimateDevice):
         self._target_temperature = None
         self._away = None
 
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
     @property
     def name(self):
         """Return the name of the sensor."""

homeassistant/components/climate/oem.py

@@ -14,7 +14,8 @@ import voluptuous as vol
 
 # Import the device class from the component that you want to support
 from homeassistant.components.climate import (
-    ClimateDevice, PLATFORM_SCHEMA, STATE_HEAT, STATE_IDLE, ATTR_TEMPERATURE)
+    ClimateDevice, PLATFORM_SCHEMA, STATE_HEAT, STATE_IDLE, ATTR_TEMPERATURE,
+    SUPPORT_TARGET_TEMPERATURE, SUPPORT_AWAY_MODE)
 from homeassistant.const import (CONF_HOST, CONF_USERNAME, CONF_PASSWORD,
                                  CONF_PORT, TEMP_CELSIUS, CONF_NAME)
 import homeassistant.helpers.config_validation as cv
@@ -34,6 +35,8 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_AWAY_TEMP, default=14): vol.Coerce(float)
 })
 
+SUPPORT_FLAGS = SUPPORT_TARGET_TEMPERATURE | SUPPORT_AWAY_MODE
+
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Set up the oemthermostat platform."""
@@ -77,6 +80,11 @@ class ThermostatDevice(ClimateDevice):
         self._temperature = None
         self._setpoint = None
 
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
     @property
     def name(self):
         """Return the name of this Thermostat."""

homeassistant/components/climate/proliphix.py

@@ -8,7 +8,7 @@ import voluptuous as vol
 
 from homeassistant.components.climate import (
     PRECISION_TENTHS, STATE_COOL, STATE_HEAT, STATE_IDLE,
-    ClimateDevice, PLATFORM_SCHEMA)
+    ClimateDevice, PLATFORM_SCHEMA, SUPPORT_TARGET_TEMPERATURE)
 from homeassistant.const import (
     CONF_HOST, CONF_PASSWORD, CONF_USERNAME, TEMP_FAHRENHEIT, ATTR_TEMPERATURE)
 import homeassistant.helpers.config_validation as cv
@@ -46,6 +46,11 @@ class ProliphixThermostat(ClimateDevice):
         self._pdp.update()
         self._name = self._pdp.name
 
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_TARGET_TEMPERATURE
+
     @property
     def should_poll(self):
         """Set up polling needed for thermostat."""

homeassistant/components/climate/radiotherm.py

@@ -4,15 +4,18 @@ Support for Radio Thermostat wifi-enabled home thermostats.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/climate.radiotherm/
 """
+import asyncio
 import datetime
 import logging
 
 import voluptuous as vol
 
 from homeassistant.components.climate import (
-    STATE_AUTO, STATE_COOL, STATE_HEAT, STATE_IDLE, STATE_OFF,
-    ClimateDevice, PLATFORM_SCHEMA)
-from homeassistant.const import CONF_HOST, TEMP_FAHRENHEIT, ATTR_TEMPERATURE
+    STATE_AUTO, STATE_COOL, STATE_HEAT, STATE_IDLE, STATE_ON, STATE_OFF,
+    ClimateDevice, PLATFORM_SCHEMA, SUPPORT_TARGET_TEMPERATURE,
+    SUPPORT_OPERATION_MODE, SUPPORT_FAN_MODE, SUPPORT_AWAY_MODE)
+from homeassistant.const import (
+    CONF_HOST, TEMP_FAHRENHEIT, ATTR_TEMPERATURE, PRECISION_HALVES)
 import homeassistant.helpers.config_validation as cv
 
 REQUIREMENTS = ['radiotherm==1.3']
@@ -29,15 +32,56 @@ CONF_AWAY_TEMPERATURE_COOL = 'away_temperature_cool'
 DEFAULT_AWAY_TEMPERATURE_HEAT = 60
 DEFAULT_AWAY_TEMPERATURE_COOL = 85
 
+STATE_CIRCULATE = "circulate"
+
+OPERATION_LIST = [STATE_AUTO, STATE_COOL, STATE_HEAT, STATE_OFF]
+CT30_FAN_OPERATION_LIST = [STATE_ON, STATE_AUTO]
+CT80_FAN_OPERATION_LIST = [STATE_ON, STATE_CIRCULATE, STATE_AUTO]
+
+# Mappings from radiotherm json data codes to and from HASS state
+# flags.  CODE is the thermostat integer code and these map to and
+# from HASS state flags.
+
+# Programmed temperature mode of the thermostat.
+CODE_TO_TEMP_MODE = {0: STATE_OFF, 1: STATE_HEAT, 2: STATE_COOL, 3: STATE_AUTO}
+TEMP_MODE_TO_CODE = {v: k for k, v in CODE_TO_TEMP_MODE.items()}
+
+# Programmed fan mode (circulate is supported by CT80 models)
+CODE_TO_FAN_MODE = {0: STATE_AUTO, 1: STATE_CIRCULATE, 2: STATE_ON}
+FAN_MODE_TO_CODE = {v: k for k, v in CODE_TO_FAN_MODE.items()}
+
+# Active thermostat state (is it heating or cooling?).  In the future
+# this should probably made into heat and cool binary sensors.
+CODE_TO_TEMP_STATE = {0: STATE_IDLE, 1: STATE_HEAT, 2: STATE_COOL}
+
+# Active fan state.  This is if the fan is actually on or not.  In the
+# future this should probably made into a binary sensor for the fan.
+CODE_TO_FAN_STATE = {0: STATE_OFF, 1: STATE_ON}
+
+
+def round_temp(temperature):
+    """Round a temperature to the resolution of the thermostat.
+
+    RadioThermostats can handle 0.5 degree temps so the input
+    temperature is rounded to that value and returned.
+    """
+    return round(temperature * 2.0) / 2.0
+
+
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_HOST): vol.All(cv.ensure_list, [cv.string]),
     vol.Optional(CONF_HOLD_TEMP, default=False): cv.boolean,
     vol.Optional(CONF_AWAY_TEMPERATURE_HEAT,
-                 default=DEFAULT_AWAY_TEMPERATURE_HEAT): vol.Coerce(float),
+                 default=DEFAULT_AWAY_TEMPERATURE_HEAT):
+    vol.All(vol.Coerce(float), round_temp),
     vol.Optional(CONF_AWAY_TEMPERATURE_COOL,
-                 default=DEFAULT_AWAY_TEMPERATURE_COOL): vol.Coerce(float),
+                 default=DEFAULT_AWAY_TEMPERATURE_COOL):
+    vol.All(vol.Coerce(float), round_temp),
 })
 
+SUPPORT_FLAGS = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE |
+                 SUPPORT_FAN_MODE | SUPPORT_AWAY_MODE)
+
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Set up the Radio Thermostat."""
@@ -77,19 +121,39 @@ class RadioThermostat(ClimateDevice):
     def __init__(self, device, hold_temp, away_temps):
         """Initialize the thermostat."""
         self.device = device
-        self.set_time()
         self._target_temperature = None
         self._current_temperature = None
         self._current_operation = STATE_IDLE
         self._name = None
         self._fmode = None
+        self._fstate = None
         self._tmode = None
         self._tstate = None
         self._hold_temp = hold_temp
+        self._hold_set = False
         self._away = False
         self._away_temps = away_temps
         self._prev_temp = None
-        self._operation_list = [STATE_AUTO, STATE_COOL, STATE_HEAT, STATE_OFF]
+
+        # Fan circulate mode is only supported by the CT80 models.
+        import radiotherm
+        self._is_model_ct80 = isinstance(self.device,
+                                         radiotherm.thermostat.CT80)
+
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Register callbacks."""
+        # Set the time on the device.  This shouldn't be in the
+        # constructor because it's a network call.  We can't put it in
+        # update() because calling it will clear any temporary mode or
+        # temperature in the thermostat.  So add it as a future job
+        # for the event loop to run.
+        self.hass.async_add_job(self.set_time)
 
     @property
     def name(self):
@@ -101,6 +165,11 @@ class RadioThermostat(ClimateDevice):
         """Return the unit of measurement."""
         return TEMP_FAHRENHEIT
 
+    @property
+    def precision(self):
+        """Return the precision of the system."""
+        return PRECISION_HALVES
+
     @property
     def device_state_attributes(self):
         """Return the device specific state attributes."""
@@ -109,6 +178,25 @@ class RadioThermostat(ClimateDevice):
             ATTR_MODE: self._tmode,
         }
 
+    @property
+    def fan_list(self):
+        """List of available fan modes."""
+        if self._is_model_ct80:
+            return CT80_FAN_OPERATION_LIST
+        else:
+            return CT30_FAN_OPERATION_LIST
+
+    @property
+    def current_fan_mode(self):
+        """Return whether the fan is on."""
+        return self._fmode
+
+    def set_fan_mode(self, fan):
+        """Turn fan on/off."""
+        code = FAN_MODE_TO_CODE.get(fan, None)
+        if code is not None:
+            self.device.fmode = code
+
     @property
     def current_temperature(self):
         """Return the current temperature."""
@@ -122,7 +210,7 @@ class RadioThermostat(ClimateDevice):
     @property
     def operation_list(self):
         """Return the operation modes list."""
-        return self._operation_list
+        return OPERATION_LIST
 
     @property
     def target_temperature(self):
@@ -136,53 +224,48 @@ class RadioThermostat(ClimateDevice):
 
     def update(self):
         """Update and validate the data from the thermostat."""
-        current_temp = self.device.temp['raw']
-        if current_temp == -1:
-            _LOGGER.error("Couldn't get valid temperature reading")
-            return
-        self._current_temperature = current_temp
-        self._name = self.device.name['raw']
-        try:
-            self._fmode = self.device.fmode['human']
-        except AttributeError:
-            _LOGGER.error("Couldn't get valid fan mode reading")
-        try:
-            self._tmode = self.device.tmode['human']
-        except AttributeError:
-            _LOGGER.error("Couldn't get valid thermostat mode reading")
-        try:
-            self._tstate = self.device.tstate['human']
-        except AttributeError:
-            _LOGGER.error("Couldn't get valid thermostat state reading")
+        # Radio thermostats are very slow, and sometimes don't respond
+        # very quickly.  So we need to keep the number of calls to them
+        # to a bare minimum or we'll hit the HASS 10 sec warning.  We
+        # have to make one call to /tstat to get temps but we'll try and
+        # keep the other calls to a minimum.  Even with this, these
+        # thermostats tend to time out sometimes when they're actively
+        # heating or cooling.
 
-        if self._tmode == 'Cool':
-            target_temp = self.device.t_cool['raw']
-            if target_temp == -1:
-                _LOGGER.error("Couldn't get target reading")
-                return
-            self._target_temperature = target_temp
-            self._current_operation = STATE_COOL
-        elif self._tmode == 'Heat':
-            target_temp = self.device.t_heat['raw']
-            if target_temp == -1:
-                _LOGGER.error("Couldn't get valid target reading")
-                return
-            self._target_temperature = target_temp
-            self._current_operation = STATE_HEAT
-        elif self._tmode == 'Auto':
-            if self._tstate == 'Cool':
-                target_temp = self.device.t_cool['raw']
-                if target_temp == -1:
-                    _LOGGER.error("Couldn't get valid target reading")
-                    return
-                self._target_temperature = target_temp
-            elif self._tstate == 'Heat':
-                target_temp = self.device.t_heat['raw']
-                if target_temp == -1:
-                    _LOGGER.error("Couldn't get valid target reading")
-                    return
-                self._target_temperature = target_temp
-            self._current_operation = STATE_AUTO
+        # First time - get the name from the thermostat.  This is
+        # normally set in the radio thermostat web app.
+        if self._name is None:
+            self._name = self.device.name['raw']
+
+        # Request the current state from the thermostat.
+        data = self.device.tstat['raw']
+
+        current_temp = data['temp']
+        if current_temp == -1:
+            _LOGGER.error('%s (%s) was busy (temp == -1)', self._name,
+                          self.device.host)
+            return
+
+        # Map thermostat values into various STATE_ flags.
+        self._current_temperature = current_temp
+        self._fmode = CODE_TO_FAN_MODE[data['fmode']]
+        self._fstate = CODE_TO_FAN_STATE[data['fstate']]
+        self._tmode = CODE_TO_TEMP_MODE[data['tmode']]
+        self._tstate = CODE_TO_TEMP_STATE[data['tstate']]
+
+        self._current_operation = self._tmode
+        if self._tmode == STATE_COOL:
+            self._target_temperature = data['t_cool']
+        elif self._tmode == STATE_HEAT:
+            self._target_temperature = data['t_heat']
+        elif self._tmode == STATE_AUTO:
+            # This doesn't really work - tstate is only set if the HVAC is
+            # active. If it's idle, we don't know what to do with the target
+            # temperature.
+            if self._tstate == STATE_COOL:
+                self._target_temperature = data['t_cool']
+            elif self._tstate == STATE_HEAT:
+                self._target_temperature = data['t_heat']
         else:
             self._current_operation = STATE_IDLE
 
@@ -191,23 +274,32 @@ class RadioThermostat(ClimateDevice):
         temperature = kwargs.get(ATTR_TEMPERATURE)
         if temperature is None:
             return
-        if self._current_operation == STATE_COOL:
-            self.device.t_cool = round(temperature * 2.0) / 2.0
-        elif self._current_operation == STATE_HEAT:
-            self.device.t_heat = round(temperature * 2.0) / 2.0
-        elif self._current_operation == STATE_AUTO:
-            if self._tstate == 'Cool':
-                self.device.t_cool = round(temperature * 2.0) / 2.0
-            elif self._tstate == 'Heat':
-                self.device.t_heat = round(temperature * 2.0) / 2.0
 
-        if self._hold_temp or self._away:
-            self.device.hold = 1
-        else:
-            self.device.hold = 0
+        temperature = round_temp(temperature)
+
+        if self._current_operation == STATE_COOL:
+            self.device.t_cool = temperature
+        elif self._current_operation == STATE_HEAT:
+            self.device.t_heat = temperature
+        elif self._current_operation == STATE_AUTO:
+            if self._tstate == STATE_COOL:
+                self.device.t_cool = temperature
+            elif self._tstate == STATE_HEAT:
+                self.device.t_heat = temperature
+
+        # Only change the hold if requested or if hold mode was turned
+        # on and we haven't set it yet.
+        if kwargs.get('hold_changed', False) or not self._hold_set:
+            if self._hold_temp or self._away:
+                self.device.hold = 1
+                self._hold_set = True
+            else:
+                self.device.hold = 0
 
     def set_time(self):
         """Set device time."""
+        # Calling this clears any local temperature override and
+        # reverts to the scheduled temperature.
         now = datetime.datetime.now()
         self.device.time = {
             'day': now.weekday(),
@@ -217,14 +309,14 @@ class RadioThermostat(ClimateDevice):
 
     def set_operation_mode(self, operation_mode):
         """Set operation mode (auto, cool, heat, off)."""
-        if operation_mode == STATE_OFF:
-            self.device.tmode = 0
-        elif operation_mode == STATE_AUTO:
-            self.device.tmode = 3
+        if operation_mode == STATE_OFF or operation_mode == STATE_AUTO:
+            self.device.tmode = TEMP_MODE_TO_CODE[operation_mode]
+
+        # Setting t_cool or t_heat automatically changes tmode.
         elif operation_mode == STATE_COOL:
-            self.device.t_cool = round(self._target_temperature * 2.0) / 2.0
+            self.device.t_cool = self._target_temperature
         elif operation_mode == STATE_HEAT:
-            self.device.t_heat = round(self._target_temperature * 2.0) / 2.0
+            self.device.t_heat = self._target_temperature
 
     def turn_away_mode_on(self):
         """Turn away on.
@@ -238,10 +330,11 @@ class RadioThermostat(ClimateDevice):
                 away_temp = self._away_temps[0]
             elif self._current_operation == STATE_COOL:
                 away_temp = self._away_temps[1]
+
         self._away = True
-        self.set_temperature(temperature=away_temp)
+        self.set_temperature(temperature=away_temp, hold_changed=True)
 
     def turn_away_mode_off(self):
         """Turn away off."""
         self._away = False
-        self.set_temperature(temperature=self._prev_temp)
+        self.set_temperature(temperature=self._prev_temp, hold_changed=True)

homeassistant/components/climate/sensibo.py

@@ -15,7 +15,10 @@ import voluptuous as vol
 from homeassistant.const import (
     ATTR_TEMPERATURE, CONF_API_KEY, CONF_ID, TEMP_CELSIUS, TEMP_FAHRENHEIT)
 from homeassistant.components.climate import (
-    ATTR_CURRENT_HUMIDITY, ClimateDevice, PLATFORM_SCHEMA)
+    ATTR_CURRENT_HUMIDITY, ClimateDevice, PLATFORM_SCHEMA,
+    SUPPORT_TARGET_TEMPERATURE, SUPPORT_OPERATION_MODE,
+    SUPPORT_FAN_MODE, SUPPORT_AWAY_MODE, SUPPORT_SWING_MODE,
+    SUPPORT_AUX_HEAT)
 from homeassistant.exceptions import PlatformNotReady
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
@@ -35,9 +38,13 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 _FETCH_FIELDS = ','.join([
     'room{name}', 'measurements', 'remoteCapabilities',
-    'acState', 'connectionStatus{isAlive}'])
+    'acState', 'connectionStatus{isAlive}', 'temperatureUnit'])
 _INITIAL_FETCH_FIELDS = 'id,' + _FETCH_FIELDS
 
+SUPPORT_FLAGS = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE |
+                 SUPPORT_FAN_MODE | SUPPORT_AWAY_MODE | SUPPORT_SWING_MODE |
+                 SUPPORT_AUX_HEAT)
+
 
 @asyncio.coroutine
 def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
@@ -55,7 +62,7 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
                 devices.append(SensiboClimate(client, dev))
     except (aiohttp.client_exceptions.ClientConnectorError,
             asyncio.TimeoutError):
-        _LOGGER.exception('Failed to connct to Sensibo servers.')
+        _LOGGER.exception('Failed to connect to Sensibo servers.')
         raise PlatformNotReady
 
     if devices:
@@ -63,7 +70,7 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
 
 
 class SensiboClimate(ClimateDevice):
-    """Representation os a Sensibo device."""
+    """Representation of a Sensibo device."""
 
     def __init__(self, client, data):
         """Build SensiboClimate.
@@ -75,6 +82,11 @@ class SensiboClimate(ClimateDevice):
         self._id = data['id']
         self._do_update(data)
 
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
     def _do_update(self, data):
         self._name = data['room']['name']
         self._measurements = data['measurements']
@@ -84,11 +96,16 @@ class SensiboClimate(ClimateDevice):
         self._operations = sorted(capabilities['modes'].keys())
         self._current_capabilities = capabilities[
             'modes'][self.current_operation]
-        temperature_unit_key = self._ac_states['temperatureUnit']
-        self._temperature_unit = \
-            TEMP_CELSIUS if temperature_unit_key == 'C' else TEMP_FAHRENHEIT
-        self._temperatures_list = self._current_capabilities[
-            'temperatures'][temperature_unit_key]['values']
+        temperature_unit_key = data.get('temperatureUnit') or \
+            self._ac_states.get('temperatureUnit')
+        if temperature_unit_key:
+            self._temperature_unit = TEMP_CELSIUS if \
+                temperature_unit_key == 'C' else TEMP_FAHRENHEIT
+            self._temperatures_list = self._current_capabilities[
+                'temperatures'].get(temperature_unit_key, {}).get('values', [])
+        else:
+            self._temperature_unit = self.unit_of_measurement
+            self._temperatures_list = []
 
     @property
     def device_state_attributes(self):
@@ -108,7 +125,7 @@ class SensiboClimate(ClimateDevice):
     @property
     def target_temperature(self):
         """Return the temperature we try to reach."""
-        return self._ac_states['targetTemperature']
+        return self._ac_states.get('targetTemperature')
 
     @property
     def target_temperature_step(self):
@@ -133,10 +150,8 @@ class SensiboClimate(ClimateDevice):
     @property
     def current_temperature(self):
         """Return the current temperature."""
-        # This field is not affected by temperature_unit.
-        # It is always in C / nativeTemperatureUnit
-        if 'nativeTemperatureUnit' not in self._ac_states:
-            return self._measurements['temperature']
+        # This field is not affected by temperatureUnit.
+        # It is always in C
         return convert_temperature(
             self._measurements['temperature'],
             TEMP_CELSIUS,
@@ -180,12 +195,14 @@ class SensiboClimate(ClimateDevice):
     @property
     def min_temp(self):
         """Return the minimum temperature."""
-        return self._temperatures_list[0]
+        return self._temperatures_list[0] \
+            if len(self._temperatures_list) else super.min_temp()
 
     @property
     def max_temp(self):
         """Return the maximum temperature."""
-        return self._temperatures_list[-1]
+        return self._temperatures_list[-1] \
+            if len(self._temperatures_list) else super.max_temp()
 
     @asyncio.coroutine
     def async_set_temperature(self, **kwargs):

homeassistant/components/climate/tado.py

@@ -7,7 +7,8 @@ https://home-assistant.io/components/climate.tado/
 import logging
 
 from homeassistant.const import TEMP_CELSIUS
-from homeassistant.components.climate import ClimateDevice
+from homeassistant.components.climate import (
+    ClimateDevice, SUPPORT_TARGET_TEMPERATURE, SUPPORT_OPERATION_MODE)
 from homeassistant.const import ATTR_TEMPERATURE
 from homeassistant.components.tado import DATA_TADO
 
@@ -43,6 +44,8 @@ OPERATION_LIST = {
     CONST_MODE_OFF: 'Off',
 }
 
+SUPPORT_FLAGS = SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE
+
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Set up the Tado climate platform."""
@@ -127,6 +130,11 @@ class TadoClimate(ClimateDevice):
         self._current_operation = CONST_MODE_SMART_SCHEDULE
         self._overlay_mode = CONST_MODE_SMART_SCHEDULE
 
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
     @property
     def name(self):
         """Return the name of the device."""

homeassistant/components/climate/tesla.py

@@ -7,7 +7,9 @@ https://home-assistant.io/components/climate.tesla/
 import logging
 
 from homeassistant.const import STATE_ON, STATE_OFF
-from homeassistant.components.climate import ClimateDevice, ENTITY_ID_FORMAT
+from homeassistant.components.climate import (
+    ClimateDevice, ENTITY_ID_FORMAT, SUPPORT_TARGET_TEMPERATURE,
+    SUPPORT_OPERATION_MODE)
 from homeassistant.components.tesla import DOMAIN as TESLA_DOMAIN, TeslaDevice
 from homeassistant.const import (
     TEMP_FAHRENHEIT, TEMP_CELSIUS, ATTR_TEMPERATURE)
@@ -18,6 +20,8 @@ DEPENDENCIES = ['tesla']
 
 OPERATION_LIST = [STATE_ON, STATE_OFF]
 
+SUPPORT_FLAGS = SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE
+
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Set up the Tesla climate platform."""
@@ -36,6 +40,11 @@ class TeslaThermostat(TeslaDevice, ClimateDevice):
         self._target_temperature = None
         self._temperature = None
 
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
     @property
     def current_operation(self):
         """Return current operation ie. On or Off."""

homeassistant/components/climate/toon.py

@@ -10,9 +10,11 @@ https://home-assistant.io/components/climate.toon/
 import homeassistant.components.toon as toon_main
 from homeassistant.components.climate import (
     ClimateDevice, ATTR_TEMPERATURE, STATE_PERFORMANCE, STATE_HEAT, STATE_ECO,
-    STATE_COOL)
+    STATE_COOL, SUPPORT_TARGET_TEMPERATURE, SUPPORT_OPERATION_MODE)
 from homeassistant.const import TEMP_CELSIUS
 
+SUPPORT_FLAGS = SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE
+
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Set up the Toon thermostat."""
@@ -38,6 +40,11 @@ class ThermostatDevice(ClimateDevice):
             STATE_COOL,
         ]
 
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
     @property
     def name(self):
         """Name of this Thermostat."""

homeassistant/components/climate/vera.py

@@ -7,7 +7,9 @@ https://home-assistant.io/components/switch.vera/
 import logging
 
 from homeassistant.util import convert
-from homeassistant.components.climate import ClimateDevice, ENTITY_ID_FORMAT
+from homeassistant.components.climate import (
+    ClimateDevice, ENTITY_ID_FORMAT, SUPPORT_TARGET_TEMPERATURE,
+    SUPPORT_OPERATION_MODE, SUPPORT_FAN_MODE)
 from homeassistant.const import (
     TEMP_FAHRENHEIT,
     TEMP_CELSIUS,
@@ -23,6 +25,9 @@ _LOGGER = logging.getLogger(__name__)
 OPERATION_LIST = ['Heat', 'Cool', 'Auto Changeover', 'Off']
 FAN_OPERATION_LIST = ['On', 'Auto', 'Cycle']
 
+SUPPORT_FLAGS = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE |
+                 SUPPORT_FAN_MODE)
+
 
 def setup_platform(hass, config, add_devices_callback, discovery_info=None):
     """Set up of Vera thermostats."""
@@ -39,6 +44,11 @@ class VeraThermostat(VeraDevice, ClimateDevice):
         VeraDevice.__init__(self, vera_device, controller)
         self.entity_id = ENTITY_ID_FORMAT.format(self.vera_id)
 
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
     @property
     def current_operation(self):
         """Return current operation ie. heat, cool, idle."""

homeassistant/components/climate/wink.py

@@ -4,46 +4,65 @@ 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, SUPPORT_TARGET_TEMPERATURE,
+    SUPPORT_TARGET_TEMPERATURE_HIGH, SUPPORT_TARGET_TEMPERATURE_LOW,
+    SUPPORT_OPERATION_MODE, SUPPORT_AWAY_MODE, SUPPORT_FAN_MODE,
+    SUPPORT_AUX_HEAT)
+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'}
+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',
+}
+
 WINK_STATE_TO_HA = {value: key for key, value in HA_STATE_TO_WINK.items()}
 
-ATTR_EXTERNAL_TEMPERATURE = "external_temperature"
-ATTR_SMART_TEMPERATURE = "smart_temperature"
-ATTR_ECO_TARGET = "eco_target"
-ATTR_OCCUPIED = "occupied"
+SUPPORT_FLAGS_THERMOSTAT = (
+    SUPPORT_TARGET_TEMPERATURE | SUPPORT_TARGET_TEMPERATURE_HIGH |
+    SUPPORT_TARGET_TEMPERATURE_LOW | SUPPORT_OPERATION_MODE |
+    SUPPORT_AWAY_MODE | SUPPORT_FAN_MODE | SUPPORT_AUX_HEAT)
+
+SUPPORT_FLAGS_AC = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE |
+                    SUPPORT_FAN_MODE)
+
+SUPPORT_FLAGS_HEATER = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE |
+                        SUPPORT_AWAY_MODE)
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
@@ -67,6 +86,11 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 class WinkThermostat(WinkDevice, ClimateDevice):
     """Representation of a Wink thermostat."""
 
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS_THERMOSTAT
+
     @asyncio.coroutine
     def async_added_to_hass(self):
         """Callback when entity is added to hass."""
@@ -85,15 +109,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 +166,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 +276,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 +324,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 +349,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
@@ -347,6 +372,11 @@ class WinkThermostat(WinkDevice, ClimateDevice):
 class WinkAC(WinkDevice, ClimateDevice):
     """Representation of a Wink air conditioner."""
 
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS_AC
+
     @property
     def temperature_unit(self):
         """Return the unit of measurement."""
@@ -360,13 +390,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 +409,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 +427,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 +457,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 +477,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)
@@ -449,6 +495,11 @@ class WinkAC(WinkDevice, ClimateDevice):
 class WinkWaterHeater(WinkDevice, ClimateDevice):
     """Representation of a Wink water heater."""
 
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS_HEATER
+
     @property
     def temperature_unit(self):
         """Return the unit of measurement."""
@@ -459,8 +510,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 +543,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

homeassistant/components/climate/zwave.py

@@ -7,8 +7,9 @@ https://home-assistant.io/components/climate.zwave/
 # Because we do not compile openzwave on CI
 # pylint: disable=import-error
 import logging
-from homeassistant.components.climate import DOMAIN
-from homeassistant.components.climate import ClimateDevice
+from homeassistant.components.climate import (
+    DOMAIN, ClimateDevice, SUPPORT_TARGET_TEMPERATURE, SUPPORT_FAN_MODE,
+    SUPPORT_OPERATION_MODE, SUPPORT_SWING_MODE)
 from homeassistant.components.zwave import ZWaveDeviceEntity
 from homeassistant.components.zwave import async_setup_platform  # noqa # pylint: disable=unused-import
 from homeassistant.const import (
@@ -70,6 +71,18 @@ class ZWaveClimate(ZWaveDeviceEntity, ClimateDevice):
                     self._zxt_120 = 1
         self.update_properties()
 
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        support = SUPPORT_TARGET_TEMPERATURE
+        if self.values.fan_mode:
+            support |= SUPPORT_FAN_MODE
+        if self.values.mode:
+            support |= SUPPORT_OPERATION_MODE
+        if self._zxt_120 == 1 and self.values.zxt_120_swing_mode:
+            support |= SUPPORT_SWING_MODE
+        return support
+
     def update_properties(self):
         """Handle the data changes for node values."""
         # Operation Mode

homeassistant/components/cloud/__init__.py

@@ -1,5 +1,6 @@
 """Component to integrate the Home Assistant cloud."""
 import asyncio
+from datetime import datetime
 import json
 import logging
 import os
@@ -8,6 +9,9 @@ import voluptuous as vol
 
 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
@@ -16,6 +20,8 @@ REQUIREMENTS = ['warrant==0.5.0']
 
 _LOGGER = logging.getLogger(__name__)
 
+CONF_ALEXA = 'alexa'
+CONF_ALEXA_FILTER = 'filter'
 CONF_COGNITO_CLIENT_ID = 'cognito_client_id'
 CONF_RELAYER = 'relayer'
 CONF_USER_POOL_ID = 'user_pool_id'
@@ -24,6 +30,13 @@ MODE_DEV = 'development'
 DEFAULT_MODE = MODE_DEV
 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({
         vol.Optional(CONF_MODE, default=DEFAULT_MODE):
@@ -33,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)
 
@@ -45,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
@@ -62,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
@@ -86,10 +104,37 @@ class Cloud:
             self.region = info['region']
             self.relayer = info['relayer']
 
+    @property
+    def cognito_email_based(self):
+        """Return if cognito is email based."""
+        return not self.user_pool_id.endswith('GmV')
+
     @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):
@@ -110,18 +155,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
@@ -129,7 +176,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
@@ -141,7 +187,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,

homeassistant/components/cloud/auth_api.py

@@ -69,7 +69,10 @@ def register(cloud, email, password):
 
     cognito = _cognito(cloud)
     try:
-        cognito.register(_generate_username(email), password, email=email)
+        if cloud.cognito_email_based:
+            cognito.register(email, password, email=email)
+        else:
+            cognito.register(_generate_username(email), password, email=email)
     except ClientError as err:
         raise _map_aws_exception(err)
 
@@ -80,7 +83,11 @@ def confirm_register(cloud, confirmation_code, email):
 
     cognito = _cognito(cloud)
     try:
-        cognito.confirm_sign_up(confirmation_code, _generate_username(email))
+        if cloud.cognito_email_based:
+            cognito.confirm_sign_up(confirmation_code, email)
+        else:
+            cognito.confirm_sign_up(confirmation_code,
+                                    _generate_username(email))
     except ClientError as err:
         raise _map_aws_exception(err)
 
@@ -89,7 +96,11 @@ def forgot_password(cloud, email):
     """Initiate forgotten password flow."""
     from botocore.exceptions import ClientError
 
-    cognito = _cognito(cloud, username=_generate_username(email))
+    if cloud.cognito_email_based:
+        cognito = _cognito(cloud, username=email)
+    else:
+        cognito = _cognito(cloud, username=_generate_username(email))
+
     try:
         cognito.initiate_forgot_password()
     except ClientError as err:
@@ -100,7 +111,11 @@ def confirm_forgot_password(cloud, confirmation_code, email, new_password):
     """Confirm forgotten password code and change password."""
     from botocore.exceptions import ClientError
 
-    cognito = _cognito(cloud, username=_generate_username(email))
+    if cloud.cognito_email_based:
+        cognito = _cognito(cloud, username=email)
+    else:
+        cognito = _cognito(cloud, username=_generate_username(email))
+
     try:
         cognito.confirm_forgot_password(confirmation_code, new_password)
     except ClientError as err:
@@ -113,7 +128,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()
 
 

homeassistant/components/cloud/const.py

@@ -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.
+"""

homeassistant/components/cloud/http_api.py

@@ -65,12 +65,12 @@ class CloudLoginView(HomeAssistantView):
     url = '/api/cloud/login'
     name = 'api:cloud:login'
 
-    @asyncio.coroutine
     @_handle_cloud_errors
     @RequestDataValidator(vol.Schema({
         vol.Required('email'): str,
         vol.Required('password'): str,
     }))
+    @asyncio.coroutine
     def post(self, request, data):
         """Handle login request."""
         hass = request.app['hass']
@@ -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))
 
 
@@ -90,8 +92,8 @@ class CloudLogoutView(HomeAssistantView):
     url = '/api/cloud/logout'
     name = 'api:cloud:logout'
 
-    @asyncio.coroutine
     @_handle_cloud_errors
+    @asyncio.coroutine
     def post(self, request):
         """Handle logout request."""
         hass = request.app['hass']
@@ -127,12 +129,12 @@ class CloudRegisterView(HomeAssistantView):
     url = '/api/cloud/register'
     name = 'api:cloud:register'
 
-    @asyncio.coroutine
     @_handle_cloud_errors
     @RequestDataValidator(vol.Schema({
         vol.Required('email'): str,
         vol.Required('password'): vol.All(str, vol.Length(min=6)),
     }))
+    @asyncio.coroutine
     def post(self, request, data):
         """Handle registration request."""
         hass = request.app['hass']
@@ -151,12 +153,12 @@ class CloudConfirmRegisterView(HomeAssistantView):
     url = '/api/cloud/confirm_register'
     name = 'api:cloud:confirm_register'
 
-    @asyncio.coroutine
     @_handle_cloud_errors
     @RequestDataValidator(vol.Schema({
         vol.Required('confirmation_code'): str,
         vol.Required('email'): str,
     }))
+    @asyncio.coroutine
     def post(self, request, data):
         """Handle registration confirmation request."""
         hass = request.app['hass']
@@ -176,11 +178,11 @@ class CloudForgotPasswordView(HomeAssistantView):
     url = '/api/cloud/forgot_password'
     name = 'api:cloud:forgot_password'
 
-    @asyncio.coroutine
     @_handle_cloud_errors
     @RequestDataValidator(vol.Schema({
         vol.Required('email'): str,
     }))
+    @asyncio.coroutine
     def post(self, request, data):
         """Handle forgot password request."""
         hass = request.app['hass']
@@ -199,13 +201,13 @@ class CloudConfirmForgotPasswordView(HomeAssistantView):
     url = '/api/cloud/confirm_forgot_password'
     name = 'api:cloud:confirm_forgot_password'
 
-    @asyncio.coroutine
     @_handle_cloud_errors
     @RequestDataValidator(vol.Schema({
         vol.Required('confirmation_code'): str,
         vol.Required('email'): str,
         vol.Required('new_password'): vol.All(str, vol.Length(min=6))
     }))
+    @asyncio.coroutine
     def post(self, request, data):
         """Handle forgot password confirm request."""
         hass = request.app['hass']
@@ -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,
     }

homeassistant/components/cloud/iot.py

@@ -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,34 @@ 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)
 
-        session = async_get_clientsession(self.cloud.hass)
+            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')
 
         @asyncio.coroutine
         def _handle_hass_stop(event):
@@ -54,8 +66,14 @@ class CloudIoT:
             remove_hass_stop_listener = None
             yield from self.disconnect()
 
+        self.state = STATE_CONNECTING
+        self.close_requested = False
+        remove_hass_stop_listener = hass.bus.async_listen_once(
+            EVENT_HOMEASSISTANT_STOP, _handle_hass_stop)
+        session = async_get_clientsession(self.cloud.hass)
         client = None
         disconnect_warn = None
+
         try:
             yield from hass.async_add_job(auth_api.check_token, self.cloud)
 
@@ -66,17 +84,15 @@ class CloudIoT:
                 })
             self.tries = 0
 
-            remove_hass_stop_listener = hass.bus.async_listen_once(
-                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 +160,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 +204,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')

homeassistant/components/config/group.py

@@ -1,8 +1,8 @@
 """Provide configuration end points for Groups."""
 import asyncio
-
+from homeassistant.const import SERVICE_RELOAD
 from homeassistant.components.config import EditKeyBasedConfigView
-from homeassistant.components.group import GROUP_SCHEMA
+from homeassistant.components.group import DOMAIN, GROUP_SCHEMA
 import homeassistant.helpers.config_validation as cv
 
 
@@ -12,7 +12,13 @@ CONFIG_PATH = 'groups.yaml'
 @asyncio.coroutine
 def async_setup(hass):
     """Set up the Group config API."""
+    @asyncio.coroutine
+    def hook(hass):
+        """post_write_hook for Config View that reloads groups."""
+        yield from hass.services.async_call(DOMAIN, SERVICE_RELOAD)
+
     hass.http.register_view(EditKeyBasedConfigView(
-        'group', 'config', CONFIG_PATH, cv.slug, GROUP_SCHEMA
+        'group', 'config', CONFIG_PATH, cv.slug, GROUP_SCHEMA,
+        post_write_hook=hook
     ))
     return True

homeassistant/components/config/zwave.py

@@ -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."""
 

homeassistant/components/configurator.py

@@ -50,15 +50,19 @@ def async_request_config(
 
     Will return an ID to be used for sequent calls.
     """
+    if link_name is not None and link_url is not None:
+        description += '\n\n[{}]({})'.format(link_name, link_url)
+
+    if description_image is not None:
+        description += '\n\n![Description image]({})'.format(description_image)
+
     instance = hass.data.get(_KEY_INSTANCE)
 
     if instance is None:
         instance = hass.data[_KEY_INSTANCE] = Configurator(hass)
 
     request_id = instance.async_request_config(
-        name, callback,
-        description, description_image, submit_caption,
-        fields, link_name, link_url, entity_picture)
+        name, callback, description, submit_caption, fields, entity_picture)
 
     if DATA_REQUESTS not in hass.data:
         hass.data[DATA_REQUESTS] = {}
@@ -137,9 +141,8 @@ class Configurator(object):
 
     @async_callback
     def async_request_config(
-            self, name, callback,
-            description, description_image, submit_caption,
-            fields, link_name, link_url, entity_picture):
+            self, name, callback, description, submit_caption, fields,
+            entity_picture):
         """Set up a request for configuration."""
         entity_id = async_generate_entity_id(
             ENTITY_ID_FORMAT, name, hass=self.hass)
@@ -161,10 +164,7 @@ class Configurator(object):
         data.update({
             key: value for key, value in [
                 (ATTR_DESCRIPTION, description),
-                (ATTR_DESCRIPTION_IMAGE, description_image),
                 (ATTR_SUBMIT_CAPTION, submit_caption),
-                (ATTR_LINK_NAME, link_name),
-                (ATTR_LINK_URL, link_url),
             ] if value is not None
         })
 
@@ -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."""

homeassistant/components/conversation.py

@@ -14,7 +14,7 @@ import voluptuous as vol
 from homeassistant import core
 from homeassistant.loader import bind_hass
 from homeassistant.const import (
-    ATTR_ENTITY_ID, SERVICE_TURN_OFF, SERVICE_TURN_ON, HTTP_BAD_REQUEST)
+    ATTR_ENTITY_ID, SERVICE_TURN_OFF, SERVICE_TURN_ON)
 from homeassistant.helpers import intent, config_validation as cv
 from homeassistant.components import http
 
@@ -39,6 +39,10 @@ CONFIG_SCHEMA = vol.Schema({DOMAIN: vol.Schema({
     })
 })}, extra=vol.ALLOW_EXTRA)
 
+INTENT_TURN_ON = 'HassTurnOn'
+INTENT_TURN_OFF = 'HassTurnOff'
+REGEX_TYPE = type(re.compile(''))
+
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -60,7 +64,11 @@ def async_register(hass, intent_type, utterances):
     if conf is None:
         conf = intents[intent_type] = []
 
-    conf.extend(_create_matcher(utterance) for utterance in utterances)
+    for utterance in utterances:
+        if isinstance(utterance, REGEX_TYPE):
+            conf.append(utterance)
+        else:
+            conf.append(_create_matcher(utterance))
 
 
 @asyncio.coroutine
@@ -93,6 +101,13 @@ def async_setup(hass, config):
 
     hass.http.register_view(ConversationProcessView)
 
+    hass.helpers.intent.async_register(TurnOnIntent())
+    hass.helpers.intent.async_register(TurnOffIntent())
+    async_register(hass, INTENT_TURN_ON,
+                   ['Turn {name} on', 'Turn on {name}'])
+    async_register(hass, INTENT_TURN_OFF, [
+        'Turn {name} off', 'Turn off {name}'])
+
     return True
 
 
@@ -128,48 +143,84 @@ def _process(hass, text):
             if not match:
                 continue
 
-            response = yield from intent.async_handle(
-                hass, DOMAIN, intent_type,
+            response = yield from hass.helpers.intent.async_handle(
+                DOMAIN, intent_type,
                 {key: {'value': value} for key, value
                  in match.groupdict().items()}, text)
             return response
 
+
+@core.callback
+def _match_entity(hass, name):
+    """Match a name to an entity."""
     from fuzzywuzzy import process as fuzzyExtract
-    text = text.lower()
-    match = REGEX_TURN_COMMAND.match(text)
-
-    if not match:
-        _LOGGER.error("Unable to process: %s", text)
-        return None
-
-    name, command = match.groups()
     entities = {state.entity_id: state.name for state
                 in hass.states.async_all()}
-    entity_ids = fuzzyExtract.extractOne(
+    entity_id = fuzzyExtract.extractOne(
         name, entities, score_cutoff=65)[2]
+    return hass.states.get(entity_id) if entity_id else None
 
-    if not entity_ids:
-        _LOGGER.error(
-            "Could not find entity id %s from text %s", name, text)
-        return None
 
-    if command == 'on':
+class TurnOnIntent(intent.IntentHandler):
+    """Handle turning item on intents."""
+
+    intent_type = INTENT_TURN_ON
+    slot_schema = {
+        'name': cv.string,
+    }
+
+    @asyncio.coroutine
+    def async_handle(self, intent_obj):
+        """Handle turn on intent."""
+        hass = intent_obj.hass
+        slots = self.async_validate_slots(intent_obj.slots)
+        name = slots['name']['value']
+        entity = _match_entity(hass, name)
+
+        if not entity:
+            _LOGGER.error("Could not find entity id for %s", name)
+            return None
+
         yield from hass.services.async_call(
             core.DOMAIN, SERVICE_TURN_ON, {
-                ATTR_ENTITY_ID: entity_ids,
+                ATTR_ENTITY_ID: entity.entity_id,
             }, blocking=True)
 
-    elif command == 'off':
+        response = intent_obj.create_response()
+        response.async_set_speech(
+            'Turned on {}'.format(entity.name))
+        return response
+
+
+class TurnOffIntent(intent.IntentHandler):
+    """Handle turning item off intents."""
+
+    intent_type = INTENT_TURN_OFF
+    slot_schema = {
+        'name': cv.string,
+    }
+
+    @asyncio.coroutine
+    def async_handle(self, intent_obj):
+        """Handle turn off intent."""
+        hass = intent_obj.hass
+        slots = self.async_validate_slots(intent_obj.slots)
+        name = slots['name']['value']
+        entity = _match_entity(hass, name)
+
+        if not entity:
+            _LOGGER.error("Could not find entity id for %s", name)
+            return None
+
         yield from hass.services.async_call(
             core.DOMAIN, SERVICE_TURN_OFF, {
-                ATTR_ENTITY_ID: entity_ids,
+                ATTR_ENTITY_ID: entity.entity_id,
             }, blocking=True)
 
-    else:
-        _LOGGER.error('Got unsupported command %s from text %s',
-                      command, text)
-
-    return None
+        response = intent_obj.create_response()
+        response.async_set_speech(
+            'Turned off {}'.format(entity.name))
+        return response
 
 
 class ConversationProcessView(http.HomeAssistantView):
@@ -178,23 +229,15 @@ class ConversationProcessView(http.HomeAssistantView):
     url = '/api/conversation/process'
     name = "api:conversation:process"
 
+    @http.RequestDataValidator(vol.Schema({
+        vol.Required('text'): str,
+    }))
     @asyncio.coroutine
-    def post(self, request):
+    def post(self, request, data):
         """Send a request for processing."""
         hass = request.app['hass']
-        try:
-            data = yield from request.json()
-        except ValueError:
-            return self.json_message('Invalid JSON specified',
-                                     HTTP_BAD_REQUEST)
 
-        text = data.get('text')
-
-        if text is None:
-            return self.json_message('Missing "text" key in JSON.',
-                                     HTTP_BAD_REQUEST)
-
-        intent_result = yield from _process(hass, text)
+        intent_result = yield from _process(hass, data['text'])
 
         if intent_result is None:
             intent_result = intent.IntentResponse()

homeassistant/components/counter/__init__.py

@@ -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

homeassistant/components/counter/services.yaml

@@ -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'

homeassistant/components/cover/lutron_caseta.py

@@ -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)

homeassistant/components/cover/mqtt.py

@@ -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

homeassistant/components/cover/tahoma.py

@@ -0,0 +1,73 @@
+"""
+Support for Tahoma cover - shutters etc.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/cover.tahoma/
+"""
+import logging
+
+from homeassistant.components.cover import CoverDevice, ENTITY_ID_FORMAT
+from homeassistant.components.tahoma import (
+    DOMAIN as TAHOMA_DOMAIN, TahomaDevice)
+
+DEPENDENCIES = ['tahoma']
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up Tahoma covers."""
+    controller = hass.data[TAHOMA_DOMAIN]['controller']
+    devices = []
+    for device in hass.data[TAHOMA_DOMAIN]['devices']['cover']:
+        devices.append(TahomaCover(device, controller))
+    add_devices(devices, True)
+
+
+class TahomaCover(TahomaDevice, CoverDevice):
+    """Representation a Tahoma Cover."""
+
+    def __init__(self, tahoma_device, controller):
+        """Initialize the Tahoma device."""
+        super().__init__(tahoma_device, controller)
+        self.entity_id = ENTITY_ID_FORMAT.format(self.unique_id)
+
+    def update(self):
+        """Update method."""
+        self.controller.get_states([self.tahoma_device])
+
+    @property
+    def current_cover_position(self):
+        """
+        Return current position of cover.
+
+        0 is closed, 100 is fully open.
+        """
+        position = 100 - self.tahoma_device.active_states['core:ClosureState']
+        if position <= 5:
+            return 0
+        if position >= 95:
+            return 100
+        return position
+
+    def set_cover_position(self, position, **kwargs):
+        """Move the cover to a specific position."""
+        self.apply_action('setPosition', 100 - position)
+
+    @property
+    def is_closed(self):
+        """Return if the cover is closed."""
+        if self.current_cover_position is not None:
+            return self.current_cover_position == 0
+
+    def open_cover(self, **kwargs):
+        """Open the cover."""
+        self.apply_action('open')
+
+    def close_cover(self, **kwargs):
+        """Close the cover."""
+        self.apply_action('close')
+
+    def stop_cover(self, **kwargs):
+        """Stop the cover."""
+        self.apply_action('stopIdentify')

homeassistant/components/device_tracker/__init__.py

@@ -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'
@@ -285,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(
@@ -299,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(

homeassistant/components/device_tracker/hitron_coda.py

@@ -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

homeassistant/components/device_tracker/owntracks.py

@@ -367,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):
@@ -380,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')
@@ -423,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
@@ -434,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)

homeassistant/components/device_tracker/snmp.py

@@ -14,14 +14,14 @@ 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.4.1']
-
-CONF_COMMUNITY = 'community'
 CONF_AUTHKEY = 'authkey'
-CONF_PRIVKEY = 'privkey'
 CONF_BASEOID = 'baseoid'
+CONF_COMMUNITY = 'community'
+CONF_PRIVKEY = 'privkey'
 
 DEFAULT_COMMUNITY = 'public'
 

homeassistant/components/device_tracker/swisscom.py

@@ -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"}}"""

homeassistant/components/device_tracker/tile.py

@@ -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
+            )

homeassistant/components/device_tracker/tplink.py

@@ -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:

homeassistant/components/device_tracker/unifi_direct.py

@@ -0,0 +1,134 @@
+"""
+Support for Unifi AP direct access.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.unifi_direct/
+"""
+import logging
+import json
+
+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)
+
+REQUIREMENTS = ['pexpect==4.0.1']
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_SSH_PORT = 22
+UNIFI_COMMAND = 'mca-dump | tr -d "\n"'
+UNIFI_SSID_TABLE = "vap_table"
+UNIFI_CLIENT_TABLE = "sta_table"
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_HOST): cv.string,
+    vol.Required(CONF_PASSWORD): cv.string,
+    vol.Required(CONF_USERNAME): cv.string,
+    vol.Optional(CONF_PORT, default=DEFAULT_SSH_PORT): cv.port
+})
+
+
+# pylint: disable=unused-argument
+def get_scanner(hass, config):
+    """Validate the configuration and return a Unifi direct scanner."""
+    scanner = UnifiDeviceScanner(config[DOMAIN])
+    if not scanner.connected:
+        return False
+    return scanner
+
+
+class UnifiDeviceScanner(DeviceScanner):
+    """This class queries Unifi wireless access point."""
+
+    def __init__(self, config):
+        """Initialize the scanner."""
+        self.host = config[CONF_HOST]
+        self.username = config[CONF_USERNAME]
+        self.password = config[CONF_PASSWORD]
+        self.port = config[CONF_PORT]
+        self.ssh = None
+        self.connected = False
+        self.last_results = {}
+        self._connect()
+
+    def scan_devices(self):
+        """Scan for new devices and return a list with found device IDs."""
+        result = _response_to_json(self._get_update())
+        if result:
+            self.last_results = result
+        return self.last_results.keys()
+
+    def get_device_name(self, device):
+        """Return the name of the given device or None if we don't know."""
+        hostname = next((
+            value.get('hostname') for key, value in self.last_results.items()
+            if key.upper() == device.upper()), None)
+        if hostname is not None:
+            hostname = str(hostname)
+        return hostname
+
+    def _connect(self):
+        """Connect to the Unifi AP SSH server."""
+        from pexpect import pxssh, exceptions
+
+        self.ssh = pxssh.pxssh()
+        try:
+            self.ssh.login(self.host, self.username,
+                           password=self.password, port=self.port)
+            self.connected = True
+        except exceptions.EOF:
+            _LOGGER.error("Connection refused. SSH enabled?")
+            self._disconnect()
+
+    def _disconnect(self):
+        """Disconnect the current SSH connection."""
+        # pylint: disable=broad-except
+        try:
+            self.ssh.logout()
+        except Exception:
+            pass
+        finally:
+            self.ssh = None
+
+        self.connected = False
+
+    def _get_update(self):
+        from pexpect import pxssh
+
+        try:
+            if not self.connected:
+                self._connect()
+            self.ssh.sendline(UNIFI_COMMAND)
+            self.ssh.prompt()
+            return self.ssh.before
+        except pxssh.ExceptionPxssh as err:
+            _LOGGER.error("Unexpected SSH error: %s", str(err))
+            self._disconnect()
+            return None
+        except AssertionError as err:
+            _LOGGER.error("Connection to AP unavailable: %s", str(err))
+            self._disconnect()
+            return None
+
+
+def _response_to_json(response):
+    try:
+        json_response = json.loads(str(response)[31:-1].replace("\\", ""))
+        _LOGGER.debug(str(json_response))
+        ssid_table = json_response.get(UNIFI_SSID_TABLE)
+        active_clients = {}
+
+        for ssid in ssid_table:
+            client_table = ssid.get(UNIFI_CLIENT_TABLE)
+            for client in client_table:
+                active_clients[client.get("mac")] = client
+
+        return active_clients
+    except ValueError:
+        _LOGGER.error("Failed to decode response from AP.")
+        return {}

homeassistant/components/device_tracker/upc_connect.py

@@ -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())
 

homeassistant/components/dialogflow.py

@@ -9,7 +9,7 @@ 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
 
@@ -26,6 +26,8 @@ DOMAIN = 'dialogflow'
 
 INTENTS_API_ENDPOINT = '/api/dialogflow'
 
+SOURCE = "Home Assistant Dialogflow"
+
 CONFIG_SCHEMA = vol.Schema({
     DOMAIN: {}
 }, extra=vol.ALLOW_EXTRA)
@@ -128,5 +130,5 @@ class DialogflowResponse(object):
         return {
             'speech': self.speech,
             'displayText': self.speech,
-            'source': PROJECT_NAME,
+            'source': SOURCE,
         }

homeassistant/components/discovery.py

@@ -35,6 +35,7 @@ SERVICE_AXIS = 'axis'
 SERVICE_APPLE_TV = 'apple_tv'
 SERVICE_WINK = 'wink'
 SERVICE_XIAOMI_GW = 'xiaomi_gw'
+SERVICE_TELLDUSLIVE = 'tellstick'
 
 SERVICE_HANDLERS = {
     SERVICE_HASS_IOS_APP: ('ios', None),
@@ -46,6 +47,7 @@ SERVICE_HANDLERS = {
     SERVICE_APPLE_TV: ('apple_tv', None),
     SERVICE_WINK: ('wink', None),
     SERVICE_XIAOMI_GW: ('xiaomi_aqara', None),
+    SERVICE_TELLDUSLIVE: ('tellduslive', None),
     'philips_hue': ('light', 'hue'),
     'google_cast': ('media_player', 'cast'),
     'panasonic_viera': ('media_player', 'panasonic_viera'),

homeassistant/components/dominos.py

@@ -0,0 +1,240 @@
+"""
+Support for Dominos Pizza ordering.
+
+The Dominos Pizza component ceates a service which can be invoked to order
+from their menu
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/dominos/.
+"""
+import logging
+from datetime import timedelta
+
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components import http
+from homeassistant.core import callback
+from homeassistant.helpers.entity import Entity
+from homeassistant.helpers.entity_component import EntityComponent
+from homeassistant.util import Throttle
+
+_LOGGER = logging.getLogger(__name__)
+
+# The domain of your component. Should be equal to the name of your component.
+DOMAIN = 'dominos'
+ENTITY_ID_FORMAT = DOMAIN + '.{}'
+
+ATTR_COUNTRY = 'country_code'
+ATTR_FIRST_NAME = 'first_name'
+ATTR_LAST_NAME = 'last_name'
+ATTR_EMAIL = 'email'
+ATTR_PHONE = 'phone'
+ATTR_ADDRESS = 'address'
+ATTR_ORDERS = 'orders'
+ATTR_SHOW_MENU = 'show_menu'
+ATTR_ORDER_ENTITY = 'order_entity_id'
+ATTR_ORDER_NAME = 'name'
+ATTR_ORDER_CODES = 'codes'
+
+MIN_TIME_BETWEEN_UPDATES = timedelta(minutes=10)
+MIN_TIME_BETWEEN_STORE_UPDATES = timedelta(minutes=3330)
+
+REQUIREMENTS = ['pizzapi==0.0.3']
+
+DEPENDENCIES = ['http']
+
+_ORDERS_SCHEMA = vol.Schema({
+    vol.Required(ATTR_ORDER_NAME): cv.string,
+    vol.Required(ATTR_ORDER_CODES): vol.All(cv.ensure_list, [cv.string]),
+})
+
+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: vol.Schema({
+        vol.Required(ATTR_COUNTRY): cv.string,
+        vol.Required(ATTR_FIRST_NAME): cv.string,
+        vol.Required(ATTR_LAST_NAME): cv.string,
+        vol.Required(ATTR_EMAIL): cv.string,
+        vol.Required(ATTR_PHONE): cv.string,
+        vol.Required(ATTR_ADDRESS): cv.string,
+        vol.Optional(ATTR_SHOW_MENU): cv.boolean,
+        vol.Optional(ATTR_ORDERS): vol.All(cv.ensure_list, [_ORDERS_SCHEMA]),
+    }),
+}, extra=vol.ALLOW_EXTRA)
+
+
+def setup(hass, config):
+    """Set up is called when Home Assistant is loading our component."""
+    dominos = Dominos(hass, config)
+
+    component = EntityComponent(_LOGGER, DOMAIN, hass)
+    hass.data[DOMAIN] = {}
+    entities = []
+    conf = config[DOMAIN]
+
+    hass.services.register(DOMAIN, 'order', dominos.handle_order)
+
+    if conf.get(ATTR_SHOW_MENU):
+        hass.http.register_view(DominosProductListView(dominos))
+
+    for order_info in conf.get(ATTR_ORDERS):
+        order = DominosOrder(order_info, dominos)
+        entities.append(order)
+
+    component.add_entities(entities)
+
+    # Return boolean to indicate that initialization was successfully.
+    return True
+
+
+class Dominos():
+    """Main Dominos service."""
+
+    def __init__(self, hass, config):
+        """Set up main service."""
+        conf = config[DOMAIN]
+        from pizzapi import Address, Customer, Store
+        self.hass = hass
+        self.customer = Customer(
+            conf.get(ATTR_FIRST_NAME),
+            conf.get(ATTR_LAST_NAME),
+            conf.get(ATTR_EMAIL),
+            conf.get(ATTR_PHONE),
+            conf.get(ATTR_ADDRESS))
+        self.address = Address(
+            *self.customer.address.split(','),
+            country=conf.get(ATTR_COUNTRY))
+        self.country = conf.get(ATTR_COUNTRY)
+        self.closest_store = Store()
+
+    def handle_order(self, call):
+        """Handle ordering pizza."""
+        entity_ids = call.data.get(ATTR_ORDER_ENTITY, None)
+
+        target_orders = [order for order in self.hass.data[DOMAIN]['entities']
+                         if order.entity_id in entity_ids]
+
+        for order in target_orders:
+            order.place()
+
+    @Throttle(MIN_TIME_BETWEEN_STORE_UPDATES)
+    def update_closest_store(self):
+        """Update the shared closest store (if open)."""
+        from pizzapi.address import StoreException
+        try:
+            self.closest_store = self.address.closest_store()
+        except StoreException:
+            self.closest_store = False
+
+    def get_menu(self):
+        """Return the products from the closest stores menu."""
+        if self.closest_store is False:
+            _LOGGER.warning('Cannot get menu. Store may be closed')
+            return
+
+        menu = self.closest_store.get_menu()
+        product_entries = []
+
+        for product in menu.products:
+            item = {}
+            if isinstance(product.menu_data['Variants'], list):
+                variants = ', '.join(product.menu_data['Variants'])
+            else:
+                variants = product.menu_data['Variants']
+            item['name'] = product.name
+            item['variants'] = variants
+            product_entries.append(item)
+
+        return product_entries
+
+
+class DominosProductListView(http.HomeAssistantView):
+    """View to retrieve product list content."""
+
+    url = '/api/dominos'
+    name = "api:dominos"
+
+    def __init__(self, dominos):
+        """Initialize suite view."""
+        self.dominos = dominos
+
+    @callback
+    def get(self, request):
+        """Retrieve if API is running."""
+        return self.json(self.dominos.get_menu())
+
+
+class DominosOrder(Entity):
+    """Represents a Dominos order entity."""
+
+    def __init__(self, order_info, dominos):
+        """Set up the entity."""
+        self._name = order_info['name']
+        self._product_codes = order_info['codes']
+        self._orderable = False
+        self.dominos = dominos
+
+    @property
+    def name(self):
+        """Return the orders name."""
+        return self._name
+
+    @property
+    def product_codes(self):
+        """Return the orders product codes."""
+        return self._product_codes
+
+    @property
+    def orderable(self):
+        """Return the true if orderable."""
+        return self._orderable
+
+    @property
+    def state(self):
+        """Return the state either closed, orderable or unorderable."""
+        if self.dominos.closest_store is False:
+            return 'closed'
+        else:
+            return 'orderable' if self._orderable else 'unorderable'
+
+    @Throttle(MIN_TIME_BETWEEN_UPDATES)
+    def update(self):
+        """Update the order state and refreshes the store."""
+        from pizzapi.address import StoreException
+        try:
+            self.dominos.update_closest_store()
+        except StoreException:
+            self._orderable = False
+            return
+
+        try:
+            order = self.order()
+            order.pay_with()
+            self._orderable = True
+        except StoreException:
+            self._orderable = False
+
+    def order(self):
+        """Create the order object."""
+        from pizzapi import Order
+        order = Order(
+            self.dominos.closest_store,
+            self.dominos.customer,
+            self.dominos.address,
+            self.dominos.country)
+
+        for code in self._product_codes:
+            order.add_item(code)
+
+        return order
+
+    def place(self):
+        """Place the order."""
+        from pizzapi.address import StoreException
+        try:
+            order = self.order()
+            order.place()
+        except StoreException:
+            self._orderable = False
+            _LOGGER.warning(
+                'Attempted to order Dominos - Order invalid or store closed')

homeassistant/components/doorbird.py

@@ -6,7 +6,7 @@ import voluptuous as vol
 from homeassistant.const import CONF_HOST, CONF_USERNAME, CONF_PASSWORD
 import homeassistant.helpers.config_validation as cv
 
-REQUIREMENTS = ['DoorBirdPy==0.0.4']
+REQUIREMENTS = ['DoorBirdPy==0.1.0']
 
 _LOGGER = logging.getLogger(__name__)
 

homeassistant/components/downloader.py

@@ -20,6 +20,7 @@ _LOGGER = logging.getLogger(__name__)
 ATTR_FILENAME = 'filename'
 ATTR_SUBDIR = 'subdir'
 ATTR_URL = 'url'
+ATTR_OVERWRITE = 'overwrite'
 
 CONF_DOWNLOAD_DIR = 'download_dir'
 
@@ -31,6 +32,7 @@ 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({
@@ -66,6 +68,8 @@ def setup(hass, config):
 
                 filename = service.data.get(ATTR_FILENAME)
 
+                overwrite = service.data.get(ATTR_OVERWRITE)
+
                 if subdir:
                     subdir = sanitize_filename(subdir)
 
@@ -73,8 +77,13 @@ def setup(hass, config):
 
                 req = requests.get(url, stream=True, timeout=10)
 
-                if req.status_code == 200:
+                if req.status_code != 200:
+                    _LOGGER.warning(
+                        "downloading '%s' failed, stauts_code=%d",
+                        url,
+                        req.status_code)
 
+                else:
                     if filename is None and \
                        'content-disposition' in req.headers:
                         match = re.findall(r"filename=(\S+)",
@@ -109,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)

homeassistant/components/ecobee.py

@@ -14,8 +14,9 @@ import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers import discovery
 from homeassistant.const import CONF_API_KEY
 from homeassistant.util import Throttle
+from homeassistant.util.json import save_json
 
-REQUIREMENTS = ['python-ecobee-api==0.0.10']
+REQUIREMENTS = ['python-ecobee-api==0.0.12']
 
 _CONFIGURING = {}
 _LOGGER = logging.getLogger(__name__)
@@ -81,6 +82,7 @@ def setup_ecobee(hass, network, config):
         hass, 'climate', DOMAIN, {'hold_temp': hold_temp}, config)
     discovery.load_platform(hass, 'sensor', DOMAIN, {}, config)
     discovery.load_platform(hass, 'binary_sensor', DOMAIN, {}, config)
+    discovery.load_platform(hass, 'weather', DOMAIN, {}, config)
 
 
 class EcobeeData(object):
@@ -110,12 +112,10 @@ def setup(hass, config):
     if 'ecobee' in _CONFIGURING:
         return
 
-    from pyecobee import config_from_file
-
     # Create ecobee.conf if it doesn't exist
     if not os.path.isfile(hass.config.path(ECOBEE_CONFIG_FILE)):
         jsonconfig = {"API_KEY": config[DOMAIN].get(CONF_API_KEY)}
-        config_from_file(hass.config.path(ECOBEE_CONFIG_FILE), jsonconfig)
+        save_json(hass.config.path(ECOBEE_CONFIG_FILE), jsonconfig)
 
     NETWORK = EcobeeData(hass.config.path(ECOBEE_CONFIG_FILE))
 

homeassistant/components/emulated_hue/__init__.py

@@ -5,7 +5,6 @@ For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/emulated_hue/
 """
 import asyncio
-import json
 import logging
 
 import voluptuous as vol
@@ -16,8 +15,10 @@ from homeassistant.const import (
 )
 from homeassistant.components.http import REQUIREMENTS  # NOQA
 from homeassistant.components.http import HomeAssistantWSGI
+from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.deprecation import get_deprecated
 import homeassistant.helpers.config_validation as cv
+from homeassistant.util.json import load_json, save_json
 from .hue_api import (
     HueUsernameView, HueAllLightsStateView, HueOneLightStateView,
     HueOneLightChangeView)
@@ -136,7 +137,7 @@ class Config(object):
         self.host_ip_addr = conf.get(CONF_HOST_IP)
         if self.host_ip_addr is None:
             self.host_ip_addr = util.get_local_ip()
-            _LOGGER.warning(
+            _LOGGER.info(
                 "Listen IP address not specified, auto-detected address is %s",
                 self.host_ip_addr)
 
@@ -144,7 +145,7 @@ class Config(object):
         self.listen_port = conf.get(CONF_LISTEN_PORT)
         if not isinstance(self.listen_port, int):
             self.listen_port = DEFAULT_LISTEN_PORT
-            _LOGGER.warning(
+            _LOGGER.info(
                 "Listen port not specified, defaulting to %s",
                 self.listen_port)
 
@@ -187,7 +188,7 @@ class Config(object):
             return entity_id
 
         if self.numbers is None:
-            self.numbers = self._load_numbers_json()
+            self.numbers = _load_json(self.hass.config.path(NUMBERS_FILE))
 
         # Google Home
         for number, ent_id in self.numbers.items():
@@ -198,7 +199,7 @@ class Config(object):
         if self.numbers:
             number = str(max(int(k) for k in self.numbers) + 1)
         self.numbers[number] = entity_id
-        self._save_numbers_json()
+        save_json(self.hass.config.path(NUMBERS_FILE), self.numbers)
         return number
 
     def number_to_entity_id(self, number):
@@ -207,7 +208,7 @@ class Config(object):
             return number
 
         if self.numbers is None:
-            self.numbers = self._load_numbers_json()
+            self.numbers = _load_json(self.hass.config.path(NUMBERS_FILE))
 
         # Google Home
         assert isinstance(number, str)
@@ -244,25 +245,11 @@ class Config(object):
 
         return is_default_exposed or expose
 
-    def _load_numbers_json(self):
-        """Set up helper method to load numbers json."""
-        try:
-            with open(self.hass.config.path(NUMBERS_FILE),
-                      encoding='utf-8') as fil:
-                return json.loads(fil.read())
-        except (OSError, ValueError) as err:
-            # OSError if file not found or unaccessible/no permissions
-            # ValueError if could not parse JSON
-            if not isinstance(err, FileNotFoundError):
-                _LOGGER.warning("Failed to open %s: %s", NUMBERS_FILE, err)
-            return {}
 
-    def _save_numbers_json(self):
-        """Set up helper method to save numbers json."""
-        try:
-            with open(self.hass.config.path(NUMBERS_FILE), 'w',
-                      encoding='utf-8') as fil:
-                fil.write(json.dumps(self.numbers))
-        except OSError as err:
-            # OSError if file write permissions
-            _LOGGER.warning("Failed to write %s: %s", NUMBERS_FILE, err)
+def _load_json(filename):
+    """Wrapper, because we actually want to handle invalid json."""
+    try:
+        return load_json(filename)
+    except HomeAssistantError:
+        pass
+    return {}

homeassistant/components/enocean.py

@@ -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)
 
 

homeassistant/components/fan/insteon_local.py

@@ -4,9 +4,7 @@ Support for Insteon fans via local hub control.
 For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/fan.insteon_local/
 """
-import json
 import logging
-import os
 from datetime import timedelta
 
 from homeassistant.components.fan import (
@@ -14,6 +12,7 @@ from homeassistant.components.fan import (
     SUPPORT_SET_SPEED, FanEntity)
 from homeassistant.helpers.entity import ToggleEntity
 import homeassistant.util as util
+from homeassistant.util.json import load_json, save_json
 
 _CONFIGURING = {}
 _LOGGER = logging.getLogger(__name__)
@@ -33,7 +32,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     """Set up the Insteon local fan platform."""
     insteonhub = hass.data['insteon_local']
 
-    conf_fans = config_from_file(hass.config.path(INSTEON_LOCAL_FANS_CONF))
+    conf_fans = load_json(hass.config.path(INSTEON_LOCAL_FANS_CONF))
     if conf_fans:
         for device_id in conf_fans:
             setup_fan(device_id, conf_fans[device_id], insteonhub, hass,
@@ -88,44 +87,16 @@ def setup_fan(device_id, name, insteonhub, hass, add_devices_callback):
         configurator.request_done(request_id)
         _LOGGER.info("Device configuration done!")
 
-    conf_fans = config_from_file(hass.config.path(INSTEON_LOCAL_FANS_CONF))
+    conf_fans = load_json(hass.config.path(INSTEON_LOCAL_FANS_CONF))
     if device_id not in conf_fans:
         conf_fans[device_id] = name
 
-    if not config_from_file(
-            hass.config.path(INSTEON_LOCAL_FANS_CONF),
-            conf_fans):
-        _LOGGER.error("Failed to save configuration file")
+    save_json(hass.config.path(INSTEON_LOCAL_FANS_CONF), conf_fans)
 
     device = insteonhub.fan(device_id)
     add_devices_callback([InsteonLocalFanDevice(device, name)])
 
 
-def config_from_file(filename, config=None):
-    """Small configuration file management function."""
-    if config:
-        # We're writing configuration
-        try:
-            with open(filename, 'w') as fdesc:
-                fdesc.write(json.dumps(config))
-        except IOError as error:
-            _LOGGER.error('Saving config file failed: %s', error)
-            return False
-        return True
-    else:
-        # We're reading config
-        if os.path.isfile(filename):
-            try:
-                with open(filename, 'r') as fdesc:
-                    return json.loads(fdesc.read())
-            except IOError as error:
-                _LOGGER.error("Reading configuration file failed: %s", error)
-                # This won't work yet
-                return False
-        else:
-            return {}
-
-
 class InsteonLocalFanDevice(FanEntity):
     """An abstract Class for an Insteon node."""